Search › A-Z › F › Adafruit Feather nRF52840 Express
Adafruit Feather nRF52840 Express
2019 Open source · CC0 On-board only Online
The Adafruit Feather nRF52840 Express is a Feather-format development board built on a Nordic nRF52840 (a 64 MHz ARM Cortex-M4F, ARMv7E-M with an FPU, with 1 MB flash and 256 KB RAM plus a Bluetooth Low Energy radio) — emulated from scratch in the browser on this site's shared ARM core. It runs REAL compiled firmware: a flat flash image with the ARM vector table at 0x00000000 boots exactly as on silicon (SP and PC loaded from the table), then drives the real nRF52840 registers. The on-board surface a Feather actually exposes is shown — the single WS2812 NeoPixel on P0.16 (decoded from the real bit-banged 800 kHz line), the red user LED on P1.15 and the blue CONN LED on P1.10, the USER switch on P1.02, and a UARTE0 serial console — with nothing invented: no breadboard, no fake audio (a bare Feather has no speaker, so it is honestly silent). Because the whole chip is ordinary JavaScript, it plugs into this site's shared debugger: the real Thumb-2 disassembler, live r0-r15 / xPSR / N-Z-C-V, side-effect-free FLASH / RAM / APB / GPIO memory at the real addresses, single-instruction step, execution breakpoints and write-watchpoints.
Adafruit Feather nRF52840 Express (product 4062) ↗
Runs on: Web browser
Adafruit Feather nRF52840 Express Online Emulator
Play Adafruit Feather nRF52840 Express using JavaScript directly in your browser.
Controls
Runs real compiled Adafruit Feather nRF52840 Express firmware on an in-browser Nordic nRF52840 (ARM Cortex-M4F, 64 MHz). The default "NeoPixel Rainbow" is a bare-metal C program that cycles a smooth rainbow on the single on-board WS2812 NeoPixel (P0.16), blinks the red user LED (P1.15) as a heartbeat, and announces each colour over the UARTE0 serial console — so the board lights AND prints out of the box. The NeoPixel colour is REAL: the program bit-bangs the 800 kHz WS2812 one-wire protocol on P0.16 and the board decodes the HIGH-pulse widths into a live RGB value (a long LOW latches the frame). "Blink" alternates the red (P1.15) and blue CONN (P1.10) LEDs with the nRF52 GPIO OUTSET/OUTCLR registers. "UART Hello + Counter" brings up UARTE0 (TX on P0.25) and prints a greeting and an incrementing four-digit counter to the serial console using a real EasyDMA transfer, blinking the LED each line. "Button" reads the on-board USER switch (SW1, P1.02, active-low): press it (the SW1 button in the shared Controller panel) to turn the NeoPixel green and light the blue LED, release for dim red and the red LED — each edge prints over the console. Open the debugger, or add ?debug, to single-STEP real Thumb instructions from flash at 0x00000000, set PC breakpoints and write watchpoints, and read the ARM registers (r0-r15, xPSR, N/Z/C/V) and the real nRF52840 memory map live (FLASH 0, RAM 0x20000000, APB 0x40000000, GPIO 0x50000000). A bare Feather has no on-board speaker, so it is honestly silent.
Runs real compiled Adafruit Feather nRF52840 Express firmware on an in-browser Nordic nRF52840 (ARM Cortex-M4F, 64 MHz). The default "NeoPixel Rainbow" is a bare-metal C program that cycles a smooth rainbow on the single on-board WS2812 NeoPixel (P0.16), blinks the red user LED (P1.15) as a heartbeat, and announces each colour over the UARTE0 serial console — so the board lights AND prints out of the box. The NeoPixel colour is REAL: the program bit-bangs the 800 kHz WS2812 one-wire protocol on P0.16 and the board decodes the HIGH-pulse widths into a live RGB value (a long LOW latches the frame). "Blink" alternates the red (P1.15) and blue CONN (P1.10) LEDs with the nRF52 GPIO OUTSET/OUTCLR registers. "UART Hello + Counter" brings up UARTE0 (TX on P0.25) and prints a greeting and an incrementing four-digit counter to the serial console using a real EasyDMA transfer, blinking the LED each line. "Button" reads the on-board USER switch (SW1, P1.02, active-low): press it (the SW1 button in the shared Controller panel) to turn the NeoPixel green and light the blue LED, release for dim red and the red LED — each edge prints over the console. Open the debugger, or add ?debug, to single-STEP real Thumb instructions from flash at 0x00000000, set PC breakpoints and write watchpoints, and read the ARM registers (r0-r15, xPSR, N/Z/C/V) and the real nRF52840 memory map live (FLASH 0, RAM 0x20000000, APB 0x40000000, GPIO 0x50000000). A bare Feather has no on-board speaker, so it is honestly silent.
Runs real compiled Adafruit Feather nRF52840 Express firmware on an in-browser Nordic nRF52840 (ARM Cortex-M4F, 64 MHz). The default "NeoPixel Rainbow" is a bare-metal C program that cycles a smooth rainbow on the single on-board WS2812 NeoPixel (P0.16), blinks the red user LED (P1.15) as a heartbeat, and announces each colour over the UARTE0 serial console — so the board lights AND prints out of the box. The NeoPixel colour is REAL: the program bit-bangs the 800 kHz WS2812 one-wire protocol on P0.16 and the board decodes the HIGH-pulse widths into a live RGB value (a long LOW latches the frame). "Blink" alternates the red (P1.15) and blue CONN (P1.10) LEDs with the nRF52 GPIO OUTSET/OUTCLR registers. "UART Hello + Counter" brings up UARTE0 (TX on P0.25) and prints a greeting and an incrementing four-digit counter to the serial console using a real EasyDMA transfer, blinking the LED each line. "Button" reads the on-board USER switch (SW1, P1.02, active-low): press it (the SW1 button in the shared Controller panel) to turn the NeoPixel green and light the blue LED, release for dim red and the red LED — each edge prints over the console. Open the debugger, or add ?debug, to single-STEP real Thumb instructions from flash at 0x00000000, set PC breakpoints and write watchpoints, and read the ARM registers (r0-r15, xPSR, N/Z/C/V) and the real nRF52840 memory map live (FLASH 0, RAM 0x20000000, APB 0x40000000, GPIO 0x50000000). A bare Feather has no on-board speaker, so it is honestly silent.
Runs real compiled Adafruit Feather nRF52840 Express firmware on an in-browser Nordic nRF52840 (ARM Cortex-M4F, 64 MHz). The default "NeoPixel Rainbow" is a bare-metal C program that cycles a smooth rainbow on the single on-board WS2812 NeoPixel (P0.16), blinks the red user LED (P1.15) as a heartbeat, and announces each colour over the UARTE0 serial console — so the board lights AND prints out of the box. The NeoPixel colour is REAL: the program bit-bangs the 800 kHz WS2812 one-wire protocol on P0.16 and the board decodes the HIGH-pulse widths into a live RGB value (a long LOW latches the frame). "Blink" alternates the red (P1.15) and blue CONN (P1.10) LEDs with the nRF52 GPIO OUTSET/OUTCLR registers. "UART Hello + Counter" brings up UARTE0 (TX on P0.25) and prints a greeting and an incrementing four-digit counter to the serial console using a real EasyDMA transfer, blinking the LED each line. "Button" reads the on-board USER switch (SW1, P1.02, active-low): press it (the SW1 button in the shared Controller panel) to turn the NeoPixel green and light the blue LED, release for dim red and the red LED — each edge prints over the console. Open the debugger, or add ?debug, to single-STEP real Thumb instructions from flash at 0x00000000, set PC breakpoints and write watchpoints, and read the ARM registers (r0-r15, xPSR, N/Z/C/V) and the real nRF52840 memory map live (FLASH 0, RAM 0x20000000, APB 0x40000000, GPIO 0x50000000). A bare Feather has no on-board speaker, so it is honestly silent.
Configurations
| Configuration | Emulator | Machine | OS | Legal | |
|---|---|---|---|---|---|
| Blink (red + blue LEDs) | Adafruit Feather nRF52840 Express | Adafruit Feather nRF52840 Express | open | Open ⛶ | |
| NeoPixel Rainbow | Adafruit Feather nRF52840 Express | Adafruit Feather nRF52840 Express | open | Open ⛶ | |
| UART Hello + Counter | Adafruit Feather nRF52840 Express | Adafruit Feather nRF52840 Express | open | Open ⛶ | |
| Button | Adafruit Feather nRF52840 Express | Adafruit Feather nRF52840 Express | open | Open ⛶ |
Chips
Notes
Embedding
This is a two-layer stack: a real ARM CPU core underneath, and a from-scratch nRF52840 SoC + Feather Express board on top. It loads real Cortex-M4 flash images and runs them on the actual on-chip peripherals — the CLOCK block, GPIO P0/P1, the UARTE0 serial port and RNG — at their real addresses. The bundled programs are genuine bare-metal firmware compiled with clang for thumbv7em, driving the real hardware paths, not a shim.
- The CPU.
cortex-m7.jsexecutes Thumb-2. The real chip is a Cortex-M4F (ARMv7E-M); this core is ARMv7-M, the same instruction-architecture family, so it runs the M4 image unchanged (these images are built soft-float, so no VFP init is needed). - Real reset. The image is a real flash image with the ARM vector table at
0x00000000: on reset the board loadsSPfrom word 0 andPCfrom word 1, exactly like the silicon. - The board, in JavaScript.
feather-board.jsmaps FLASH/RAM/APB/GPIO at their real nRF52840 addresses, answers the CLOCK ready bits, decodes the WS2812 waveform the program bit-bangs on P0.16 into a live RGB NeoPixel, feeds the USER switch in on its GPIO pin, and copies every UARTE0 EasyDMA transfer into the serial console.
| Piece | Kind | What it does |
|---|---|---|
Feather.create(canvas) | factory | Build the ARM core + the nRF52840 memory map + peripherals. |
load(bytes) / reset() | method | Copy the flat image into FLASH; reset loads SP/PC from the vector table at 0. |
runFrame() | method | Step ~180k instructions and latch any completed NeoPixel frame. |
setButton(down) / getSerial() | input | Drive the USER-switch GPIO level; read the accumulated UARTE0 output. |
present() | method | Draw the NeoPixel, the two on-board LEDs and the serial console. |
Debugger integration
feather-debug.js reads window.EMU_BOOT and hands the shared debugger a genuine ARM Cortex-M4F machine — the same core the firmware runs on, exposed instruction-accurately.
- Registers.
registers()reads r0-r12, SP, LR, PC, xPSR and the APSR flags N/Z/C/V live each refresh; each has aset()that writes straight back into the core's register file. - Disassembly. FLASH is decoded with the shared
cortex-m7decoder (the Thumb-2 disassembler), so the code window shows real ARM mnemonics at the reset address0x00000000. - Single-step. Step calls
transport.stepInsn, which advances the core exactly one Thumb instruction; watch the WS2812 bit-bang toggle the GPIO OUT register on P0.16 as you step through the NeoPixel driver, or the reset handler zero.bssand fall intomain(). - 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 (e.g. the P0
OUTSETat0x50000508or the UARTE0TXD.PTRat0x40002544). Both are real. - Memory map. Four chips read the real address space side-effect-free: FLASH (program, disassembled at 0), RAM (0x20000000), the APB block (0x40000000 — CLOCK / UARTE0 / TIMER0 / RNG) and the GPIO block (0x50000000 — watch P0 and P1 OUT/DIR/IN).
Architecture
The Adafruit Feather nRF52840 Express is a Feather-format development board built on a Nordic nRF52840 — a 64 MHz ARM Cortex-M4F with 1 MB flash and 256 KB RAM, plus Bluetooth Low Energy radio. This build models the SoC from scratch on the shared ARM core and wires the on-board surface a Feather actually exposes.
- Cortex-M4F CPU — runs the real Thumb-2 image. FLASH is at
0x00000000(the vector table: word0 = initial SP, word1 = reset handler), RAM at0x20000000, the APB peripherals at0x40000000and the GPIO ports at0x50000000. On reset SP and PC are loaded from the vector table, exactly as on silicon. - NeoPixel (real WS2812 decode). The board carries one on-board SK6812 NeoPixel on P0.16 (with power on P1.14). A program clocks it by bit-banging the WS2812 800 kHz protocol — each bit is a HIGH pulse (long = 1, short = 0) then a LOW gap, and a long LOW latches the frame. The board watches the GPIO OUT edges on P0.16, measures each HIGH pulse in executed instructions to recover the bit, packs 24 bits (G,R,B) and lights the live RGB value. This is the genuine line protocol, decoded — not a framebuffer poke.
- LEDs. The red user LED is on
P1.15and the blue CONN LED onP1.10, both active-HIGH (lit when the pin is driven high). The board reads the GPIO OUT/DIR of P1 to light them. - USER switch. The on-board switch (SW1, shared with DFU) is on
P1.02, active-LOW with a pull-up: released reads 1, pressed reads 0. The Controller panel drives that input level; the firmware reads it from the GPIO IN register. - UARTE0 (serial console). The nRF52840's UARTE0 at
0x40002000with the TX pin onP0.25. A program setsTXD.PTR/TXD.MAXCNTand triggersSTARTTX; the board performs the real EasyDMA transfer — copying that buffer out of memory into the on-screen serial console and raisingENDTX— so real polling UART code runs to completion. - Clocks + RNG. The CLOCK block answers
HFCLKSTARTED/LFCLKSTARTEDso bring-up spins fall through; RNG returns bytes on demand; a free-running TIMER0 counts executed instructions. The programs run on the emulator's instruction rate as the time base. - Content. Four original CC0 bare-metal programs compiled with clang for thumbv7em: NeoPixel Rainbow (default), Blink, UART Hello + Counter and Button. No proprietary firmware is used.
- Honest limits. A bare Feather nRF52840 Express has no on-board speaker, so this emulator is genuinely silent with no sound path. The BLE/802.15.4 radio, USB, QSPI flash, I2C/SPI and the interrupt-driven paths of the peripherals are not modelled — the bundled firmware polls. This is bare-metal firmware, not the CircuitPython/Arduino BSP runtime.