Epsilon Graphing Calculator OS

Epsilon is a high-performance graphing calculator operating system containing eleven apps for high school mathematics. To begin using or developing with Epsilon, you can:

1. Try it in the browser: Use the online simulator to experience the OS without installation.
2. Read the core documentation: The main documentation provides the foundation for understanding the project.
3. Develop for the platform: Depending on your goal, you can build custom firmware or create external apps.

HIDAPI is a multi-platform library for interfacing with USB and Bluetooth HID-Class devices on Windows, Linux, FreeBSD, and Mac OS X. It can be used as a shared library (.so or .dll) or embedded directly into an application by adding a single header and a single source file per platform.

Supported Back-ends

• Windows: Uses hid.dll.
• Linux/hidraw: Uses the kernel's hidraw driver. Supports both USB and Bluetooth. Note that keyboards, mice, and certain blacklisted devices may not have hidraw nodes. Kernels prior to 2.6.39 may have limitations on feature reports.
• Linux/libusb: Uses libusb-1.0. Does not support Bluetooth.
• FreeBSD: Uses libusb-1.0.
• Mac OS X: Uses IOHidManager.

Poincare is the algebraic computation engine for Epsilon. It is responsible for processing text-based mathematical expressions (e.g., 1+2*3) by converting them into an internal tree structure. Once in this tree format, expressions can undergo several operations:

• Parsing: Converting raw text into a structured format using a custom lexer and parser.
• Simplification: Applying algebraic rules to reduce expressions to their simplest form.
• Approximation: Calculating numerical approximations of expressions.
• Pretty printing: Laying out expressions in 2D to match textbook-style formatting.

The sample_c application serves as a demonstration of how to build and run C applications on a NumWorks calculator using Epsilon. The app showcases several core capabilities:

• Text Rendering: Displays content from a file (e.g., src/input.txt).
• Graphics: Renders colorful rectangles on the screen.
• Input Handling: Implements a square pointer that responds to user input via the calculator's arrow keys.

Ion is a hardware abstraction library used throughout Epsilon. Instead of interacting with hardware registers directly, Epsilon code calls Ion functions (e.g., serialNumber(), LED::setColor(), Display::pushRect()).

This abstraction allows the same Epsilon logic to run on multiple platforms by providing different implementations of the same Ion functions. For example, Display::pushRect() can be implemented to drive a physical LCD panel on a calculator or to render content in a web browser via Emscripten.

ION is the hardware abstraction layer (HAL) for the Epsilon project. Its primary responsibility is managing I/O operations.

ION provides a consistent set of headers that abstract hardware-specific details. These headers are implemented for different targets, including physical devices and simulators, allowing higher-level code to remain portable across different hardware environments. Additionally, ION is responsible for initializing the boot environment.

To optimize performance and avoid heavy v-tables, Poincare avoids heavy use of virtuality on the Tree structure. Instead of overriding methods in subclasses, use switch statements on the tree type within static methods or modules.

// Static method of Simplification module. Tree is a final class.
bool Simplify(Tree* t) {
  switch (t->type()) {
    case Type::Add:
      return SimplifyAdd(t);
    // ...
  }
}

Epsilon is embedded firmware, which differs from standard OS-based programming in several ways:

• No Virtual Memory: The firmware must know the exact memory layout in advance (stack location, heap, global variables, read-only variables, and code location).
• No Standard 'main' Function: On Cortex-M devices, the CPU jumps to the address at 0x00000000 (the start of flash memory) after a reset. Execution begins exactly where the firmware is mapped.
• Linker Scripts: Epsilon uses scripted embedded linkers to enforce precise memory layouts. The linker script can be found at ion/src/device/userland/flash/userland_shared.ld.
• System Initialization: Since there is no OS to handle startup, tasks like initializing global variables to zero must be handled manually. This is implemented in ion/src/device/shared/boot/rt0.cpp.