Search › A-Z › N › NumWorks N0110

NumWorks N0110

2019 Open source Online

The NumWorks N0110 (NumWorks, 2019) is an open-source graphing calculator built on an STMicroelectronics STM32F730 — a 216 MHz ARM Cortex-M7 — with a 320×240 colour LCD and a full calculator keypad. This is a from-scratch emulation: the site's own ARM core executes the real Thumb-2 firmware, and a from-scratch STM32F730 + N0110 board maps the real address space and drives the on-board peripherals (the ST7789V LCD over the FMC bus and the 9×6 key matrix). It boots the REAL Epsilon operating system to its home screen; open the Calculation app and type 6×7 then EXE to compute 42. It is wired into the shared debugger, so you can single-step the Cortex-M7, read and write its registers (r0–r15, xPSR, s0–s31) and the STM32F730 memory, set breakpoints and write watchpoints, and use an on-screen keypad. The N0110 has no speaker, so it is silent.

Runs on: Web browser

NumWorks N0110 Online Emulator

Play NumWorks N0110 using JavaScript directly in your browser.

Configurations

Configuration	Emulator	Machine	OS	Legal
Epsilon — NumWorks calculator OS	NumWorks N0110	NumWorks N0110		open	Open ⛶

Machines emulated

Nascom 2

Chips

Zilog Z80

Notes

Embedding

This is a two-layer stack: a real ARM Cortex-M7 core underneath, and a from-scratch STM32F730 + NumWorks N0110 board on top. It loads the real Epsilon firmware (built from the open-source NumWorks sources) into internal + external flash and runs it on the emulated on-chip peripherals. It is genuine firmware executing on the emulated silicon, not a re-implementation of the calculator.

The CPU. cortex-m7.js executes ARMv7-M Thumb-2 + the single-precision FPv5-SP FPU — exactly the STM32F730's core. The same executor powers the Playdate-ARM emulator (an STM32F746); the F730 is the same Cortex-M7.
Real reset. Epsilon links its vector table into internal flash at the STM32F7 ITCM alias 0x00200000. On reset the board loads SP from word 0 and PC from word 1 and starts the bootstrap, which sets up clocks/flash and jumps to the userland in external flash at 0x90000000 — exactly like the silicon.
Two flash images. numworks-firmware.js carries the internal bootstrap (64 KB) and the external Epsilon userland (multi-MB) as base64; NUMWORKS_FIRMWARE.internal() / .external() return the byte images.
The board, in JavaScript. numworks-board.js maps the real STM32F730 address space and decodes the ST7789 command stream Epsilon writes over the FMC into a 320x240 framebuffer, and answers the key-matrix scan on GPIOC from the pressed keys.

Piece	Kind	What it does
`NumWorks.create(canvas)`	factory	Build the ARM core + the STM32F730 memory map + peripherals.
`loadInternal(b)` / `loadExternal(b)` / `reset()`	method	Place the two flash images; reset loads SP/PC from the internal vector table.
`runFrame()`	method	Step a batch of Thumb-2 instructions; SysTick + exceptions are handled by the core.
`setKey(n,down)`	input	Press/release Ion key number n (row*6+col) in the emulated matrix.
`present()`	method	Blit the 320x240 RGB565 framebuffer to the canvas.

Debugger integration

numworks-debug.js reads window.EMU_BOOT and hands the shared debugger a genuine ARM Cortex-M7 machine — the same core the firmware runs on, exposed instruction-accurately.

Registers. registers() reads r0-r12, SP, LR, PC, xPSR, the APSR flags N/Z/C/V and the FPv5-SP single registers s0-s31 live each refresh; each has a set() that writes straight back into the core's register file (the s-registers via the raw-bit alias cpu.sb).
Disassembly. External and internal flash are decoded with the shared cortex-m7 decoder (Thumb-2 + VFP), so the code window shows real ARM mnemonics at the real addresses — most of Epsilon lives at 0x90000000, the bootstrap at 0x00200000.
Single-step. Step calls transport.stepInsn, which advances the core exactly one Thumb-2 instruction; PC and the registers update after each step. Because the core implements the full exception model, you can also watch a real SysTick exception entry/return as Epsilon's millisecond tick fires.
Breakpoints & watchpoints. Execution breakpoints are a PC set the run-loop checks before each instruction; write watchpoints wrap the board's memory-write path and pause when a watched address is written. Both are real.
Memory map. Four chips read the real STM32F730 space side-effect-free: EXTERNAL FLASH (0x90000000, the Epsilon userland, disassembled), INTERNAL FLASH (0x00200000, the bootstrap, disassembled), SRAM (0x20000000) and the APB/AHB peripheral block (0x40000000 — RCC, PWR, GPIO, FLASH interface).
Input. The whole NumWorks keypad is the shared "keyboard" input panel; every key drives nw.setKey(ionKeyNumber), so pressing a key on screen (or on the host keyboard) is a real matrix short.

Architecture

The NumWorks N0110 is an open-source graphing calculator. Its brain is an STMicroelectronics STM32F730 — a 216 MHz ARM Cortex-M7 (ARMv7-M, Thumb-2, single-precision FPv5-SP FPU) with 256 KB of SRAM and only 64 KB of internal flash. The bulk of the firmware lives in an external 8 MB QSPI flash (AT25F641-class) that the Quad-SPI controller maps into the address space at 0x90000000 (execute-in-place). The panel is a 320x240 colour LCD (ST7789V controller) and the front is a full calculator keypad.

Boot. On reset the STM32F730 runs the bootstrap in internal flash (vector table at the ITCM alias 0x00200000): it initialises the FPU/MPU, brings up the PLL (HSE 8 MHz → 192 MHz), configures the QUADSPI for memory-mapped reads, then jumps to the Epsilon userland in external flash. The clock-tree bring-up (HSE/PLL/over-drive/voltage-scale ready bits, SYSCLK switch) and the QUADSPI status are high-level-emulated so the polling loops terminate; the external-flash bytes are directly readable at 0x90000000 (XIP), which is all Epsilon needs.
Display. The ST7789V is wired to the STM32's FMC as if it were a 16-bit SRAM: writes to 0x60000000 are commands, writes to 0x60020000 are data (the D/CX line is address bit A17). The board decodes the real ST7789 command stream Epsilon emits — MADCTL (0x36), CASET (0x2A), RASET (0x2B) and RAMWR (0x2C) — and streams the RGB565 pixels into a 320x240 landscape framebuffer, which is blitted to the canvas.
Keypad. A 9-row x 6-column matrix: rows are GPIOA PA0..PA8 driven low one at a time (open-drain), columns are GPIOC PC0..PC5 inputs with pull-ups. A pressed key shorts its column to the active row, so the firmware's scan() reads a 0 on that column. The board computes GPIOC's input register from the pressed keys and the row currently driven, so a key press is genuine hardware behaviour — Ion key number = row*6 + column.
Timing. Epsilon's millisecond clock is the Cortex-M7 SysTick (24-bit down-counter + the SysTick exception), which the core implements; the display driver's tearing-effect line (GPIOB.11) is modelled so waitForVBlank returns.
Firmware. Epsilon is NumWorks' own operating system, built from the public sources at github.com/numworks/epsilon. It boots to the home screen and runs the Calculation app; see the README for exactly what was built and the honest limits.
Audio. The NumWorks N0110 has no on-board speaker, so this emulator is honestly silent — there is no sound hardware to emulate and nothing is faked.