Skip to content

Latest commit

 

History

History
1930 lines (1701 loc) · 192 KB

STATUS.md

File metadata and controls

1930 lines (1701 loc) · 192 KB

Project status and evidence

Reviewed: 2026-10-16 at the M5 implementation (verification: recordings and replay, coverage and profiling, the Verify perspective, the Python client, EmbSIM as EmbLinkRTOS's emulated target) on branch claude/affectionate-allen-40uv0o. This inventory is maintained by hand until evidence tooling exists. It is not a generated support matrix. Specifications define target contracts; their acceptance does not mean the described behaviour exists.

DC motors and their driver, the robot's first parts (2026-11-08)

M7's robot on the floor begins with its motors. dc_motor (core/analog/motor.c, SPEC-004) is a brushed DC motor in the analog engine: the winding's resistance and inductance in series with the back EMF, the rotor's inertia, friction and gearbox, the current and the speed two extra unknowns of the island, a load torque on the output shaft as an input. emblink/pololu_3073_gearmotor is Pololu's 50:1 Micro Metal Gearmotor HPCB 6V (item 3073, the extended shaft that takes Pololu's encoder) with the constants its specifications give at 6 V: 4.0 ohm, ke = kt = 1.542 mN m/A at the rotor, the no-load current's friction, a 67.8 % efficient 51.45:1 gearbox. Evidence: its fixtures (no-load: 650 rpm and 0.15 A; start: 1.43 A at power-on, 407 rpm, 63 % of full speed, at its 13 ms mechanical time constant; stall: 1.5 A under 0.74 kg cm; reverse), and the best-efficiency point the constants give, 520 rpm, 0.148 kg cm, 0.79 W, 31 % at 0.42 A, against Pololu's 490 rpm, 0.16 kg cm, 0.80 W, 32 %. Not yet: the winding's inductance and rotor's inertia measured (Pololu publishes neither: estimates), the commutator's ripple, heating, the encoder, the robot itself.

The motors' driver: h_bridge (core/analog/hbridge.c) is one bridge of an integrated driver. Its FETs drive from VM through their on-resistance, so a motor slows as the battery sags, and coast through their body diodes. Its logic inputs are read as voltages through the datasheet's thresholds, with deglitch, propagation delay, dead time, sleep and wake, undervoltage lockout, current chopping and overcurrent shutdown. emblink/drv8833 is Texas Instruments' DRV8833, two such bridges with its datasheet's values.

Evidence, its eight fixtures:

  • 4.83 V across 10 ohm from 5 V (200 + 160 mohm);
  • OUT1 following IN1 1.1 us later, a 300 ns pulse lost to the deglitch, and the 450 ns dead time on reversal;
  • the 2.6 V lockout, and the wake after recovery;
  • the gearmotor at 6 V spinning up to 640 rpm;
  • 0.5 ohm on AISEN holding it at 0.38 to 0.40 A;
  • a short tripping the overcurrent protection, with nFAULT low and the 1.35 ms retry;
  • 1.6 uA asleep and 1.7 mA awake.

emblink/tb6612fng is Toshiba's TB6612FNG on the same primitive, its logic referred to its own VCC supply. Its fixtures cover the gearmotor at 6 V (640 rpm), PWM low braking, standby under 1 uA, and inputs and lockout following VCC.

Not yet: the thermal shutdown, switching edges, the L293D on the primitive.

ESP32 on the machine framework (2026-11-08)

The ESP32 now runs as a catalog MCU (espressif/esp32) on the emblink/esp32_devkitc board: two Xtensa LX6 cores in the framework (core/mcu/xtensa/lx6.c), the SoC models in core/mcu/esp32/soc/, and Espressif's ROM (ECO3), ESP-IDF v5.4's second-stage bootloader and its hello_world running unmodified on both cores at 160 MHz to Hello world! and through esp_restart (rst:0xc SW_CPU_RESET). Evidence: test_lx6 (4,332 checks), the board's three fixtures, and the ESP-IDF vendor scenarios esp32_hello_world (9/9), esp32_blink (6/6), esp32_ledc_basic (2/2), esp32_i2c_eeprom (3/3, I2C0 writing and reading a 24LC256 at 400 kHz), esp32_gptimer (17/17), esp32_uart_echo (6/6), esp32_real_time_stats (10/10) , esp32_blink_strip (7/7, a WS2812B through the RMT) and esp32_adc_oneshot_read (6/6, ADC1 and ADC2 with the eFuse Vref's calibration), esp32_dac_oneshot (4/4, the DACs read back by ADC2); Arduino-ESP32's AnalogReadSerial, ReadAnalogVoltage, DigitalReadSerial, GetChipID and RepeatTimer for "ESP32 Dev Module" (tests/vendor/arduino-esp32, ESP32_*). Not yet: Wi-Fi and Bluetooth, the double-precision accelerator's instructions, the peripherals the description's fidelity lists (I2S, SPI2/3, touch, ...), sleep. The standalone harness below remains as its own qualification fixtures.

Original ESP32 dual-core target investigation (2026-11-04)

Latest digital pad-hold update: Per-pin digital hold now follows the SDK bit mapping and combines local/global/auto-hold causes with FORCE_UNHOLD precedence and independent pad snapshots. 3,455 new native checks, 4,096 independent transition turns and 256 compiled C calls using eight unchanged SDK helpers pass. Native ROM now reaches 6,902 retirements and IO_MUX U0TXD read at 0x3ff49088. RTC pad-specific hold, IO_MUX/peripheral routing, physical board behavior and complete SDK boot remain unqualified.

Prior RTC-calibration update: the TIMG0 counter/controller profile now counts explicitly supplied XTAL ticks over selected-clock periods, with one-shot completion and single-period cycling. 919,967 native assertions, 19,208 independent comparisons and 486 compiled C harness calls using unchanged SDK access macros pass. The diagnostic with an additional explicit calibration fixture reaches 6,872 retirements, then RTC_IO_DIG_PAD_HOLD read at 0x3ff48474. The unclocked and synthetic-period cases are recorded separately; neither verifies oscillator frequency, physical calibration, full SDK boot or CPU timing.

Prior ROM-map update: an explicit per-core SDK mask-ROM profile now supplies the 448 KiB IROM view and coherent DROM tail alias using external PRO/APP images. 1,170 native assertions, 18,840 independent comparisons and 1,024 compiled C calls to two unchanged ROM getters pass. The PRO diagnostic with the additional profile reaches 6,796 retirements, then TIMG0 RTCCALICFG1 read at 0x3ff5f06c/PC 0x40008591. The default TRM-only view and prior failure remain available. Physical ROM contents, timer calibration, full SDK boot and calibrated instruction timing remain unverified.

Prior UART-bank update: the normal UART0/1/2 bank now shares one 1024-byte FIFO RAM, supports bounded allocations/overwrites and extended counts/thresholds, and coordinates idle UART1→UART2 TX reset. 271,883 new native assertions, 4,096 shared-RAM referee turns and 384 compiled C calls with twelve unchanged SDK helpers pass. Native ROM with all three explicit UART fixtures reaches 6,790 retirements, then an unmapped instruction-ROM fetch at 0x40065c18. Extended ROM mapping, advanced UART modes, full physical clock/pin/USB integration and complete SDK boot remain unqualified.

Prior UART0 update: the normal asynchronous UART0 profile now supports fixed TX/RX FIFOs, explicit source-clock framing, CTS gating, decoded RX/error input and interrupt source 34 on both native core views. 915,199 native assertions, 316,077 independent bit/frame comparisons and 128 compiled C calls with eleven unchanged SDK helpers pass. The additional explicit UART0 fixture reaches 6,737 retirements, then UART1 INT_CLR write 0x3ff50010/PC 0x40009013. UART1/2, advanced modes, full clocks/pin/electrical/USB integration and native SDK boot remain unimplemented. Serial-clock advancement does not calibrate CPU timing.

Prior GPIO update: the software-GPIO/pad-hold profile now supports explicit routes, live resolved inputs, projected drive/HiZ and hold capture/clear. With all explicit probe fixtures it reaches 6,734 instructions, then UART0 INT_CLR write at 0x3ff40010/PC 0x4000900b. Full GPIO/IO_MUX, electrical loading, board binding, power isolation and native SDK boot remain incomplete. The earlier 0x3ff48088 blocker was DIG_ISO; its former analog label is corrected.

Current implementation update: an explicit eFuse read/reload profile now supports None-coded input images, read protection and completion routing. With a supplied synthetic unprogrammed image, real ROM execution advances from seven to 6,692 retired instructions without an RTC snapshot. With the new RTC reset/retention profile and an explicit synthetic power-on snapshot, it reaches 6,698 instructions, then blocks on digital isolation control read at 0x3ff48088, PC 0x4000770a. MEMCTL now has reset/control and a bounded functional loop-buffer profile. Its physical fill/fetch/pipeline timing remains unqualified. Region protection now implements fixed ITLB/DTLB maintenance, synchronized permissions and causes 20/28/29. ATOMCTL now has six-bit privileged register access, reset, memory-type selection, local/RCW atomics and cause-3 dispatch. Internal cache operations, complete memory-system and physical loop-buffer behavior, and full SDK boot remain absent. The timing qualification tools now build a hardware cycle-capture firmware and validate complete logs; no physical capture or calibrated instruction-time model exists yet. Read completion is an explicit external event; no physical duration is inferred. The earlier synchronous profile took the ROM failure/reset path. The owner's actual fuse image is not inferred. A separate Giantec GT25Q32A-U storage subset now matches the reported ID, with independent timing/WEL behavior. Full native boot, complete chip behavior, OTP programming and SoC hardware consumers remain absent.

Initial no-eFuse-image boot verification, 2026-11-05: a pinned unmodified ESP-IDF v4.4.7 example boots both schedulers and prints Hello world in Espressif QEMU. Native EmbSIM using the same image and QEMU-distributed PRO ROM fails after seven retired instructions: PC 0x4000fdd8, eFuse read 0x3ff5a000. This is a confirmed boot blocker, not successful SDK/board boot. The owner subsequently supplied a physical esptool readout: ESP32-D0WD-V3 v3.1, 40 MHz crystal, JEDEC C4 60 16, 4 MB detected flash and a 3.3 V strapping setting. Giantec's GT25Q32A-U datasheet matches the ID; exact ordering/package remains unresolved. The Winbond fixture is a different part and does not qualify this board. Evidence and reproduction separate reference success, native failure and unresolved hardware identity.

The owner requested an original dual-core ESP32 development board. The listing is now tied to TECNOIOT ASIN B07N97DD1B: the advertised photo shows a 30-pin ESP-WROOM-32 board. Exact PCB revision and BOM remain unverified. Identity and implementation gates document the new Xtensa LX6 backend, dual-core SoC, board circuits, radio, low-power and qualification work needed. Native image-info esp32 now validates standalone image headers, segments, XOR checksum and optional SHA-256, with explicit rejection of signed/encrypted/merged images. An experimental, unregistered Xtensa integer kernel now executes the wide arithmetic/logic/immediate/low-multiply subset against a supplied register window: 111 native assertions and 9,728 separately assembled all-register comparisons pass. Mixed-width fetch, compact arithmetic, non-windowed calls/returns, conditional branches and callback memory access now execute an assembled summing/subroutine program. The execution test passes 618 assertions; a separate assembler/linker referee passes 4,800 execution cases and 1,152 failed accesses. Complete exception/interrupt behavior, full ISA, SMP, SoC boot and timing remain unimplemented. The new 64-AR window engine implements windowed calls/ENTRY/RETW, lazy spill/fill exception transitions, RFWO/RFWU retries, selected special registers and hardware loops (1,337 native assertions). The actual Espressif ESP32 GCC toolchain passes 128 shallow windowed C runs. A further suite executes ESP-IDF's actual spill/fill handler instruction bodies through the bus, passing 224 windowed-ABI runs (160 C, 64 assembly) and all six event paths with matching overflow/underflow counts. This does not establish ESP-IDF boot or SoC fidelity. Additionally, 96 compiler-generated C executions (sum/sort/copy, 33,472 fetched instructions) pass buffer, guard, return and callee-save checks. SAR setup/variable shifts and exchange, RSIL state and selected opt-in XEA2 syscall/illegal/privilege/nested entry/return now pass 785 native assertions. An additional 7,040 real ESP32 compiled bit-manipulation executions pass (37,818 fetched instructions). Unknown instructions and ambiguous bus failures are not assigned invented exception causes. The optional CPU interrupt profile now adds 32-input priority/type handling, masks, NMI edges, saved high-level contexts, RFI and WAITI suspension/wake (11,571 native assertions). CCOUNT/CCOMPARE0..2 use explicit supplied ticks, including WAITI wake and wraparound (81 assertions). Referees pass 2,048 vendor-configuration interrupt comparisons and 8,192 clock/deadline comparisons against 263,719 individual ticks. The SoC interrupt matrix is now covered by a separate functional implementation below; peripheral generators, scheduler timing, full SMP and board boot remain absent. Conditional moves/min/max/high products/division/normalization and bit branches now pass 128 additional native assertions. SCOMPARE1/S32C1I require one indivisible bus callback, with no non-atomic fallback (67 assertions). Another 832 actual ESP32 compiled atomic/division runs pass, including 64 interleaved increment pairs that force retry. A native internal-memory provider now adds SRAM0/1/2, word-reversed SRAM1 instruction aliases, PRO-only RTC fast RAM, shared RTC slow RAM, optional external ROM and per-core host-controlled boot remap. A serialized two-context harness shares this RAM while keeping CPU/interrupt/clock state private. Native fixtures cover address/permission/remap/fault/wait boundaries; 512 actual ESP32 compiled task executions and 128 replay comparisons pass through the native bus (229,322 instructions). This remains a bounded memory/execution harness: complete cache/MMU, reset domains and full SMP and SoC boot are absent. L32AI/S32RI now provide acquire/release ordering under the synchronous completed callback contract (30,732 native assertions). The compiled shared-bus acceptance includes acquire/CAS/release spinlocks protecting ordinary writes. Asynchronous transactions, cache coherence and physical timing remain unsupported. The interrupt matrix now exposes per-core DPORT maps/raw status, four shared software-generated interrupts, shared OR routes, disconnected internal-input selectors, core-local GPIO and explicit PID NMI-mask inputs. Firmware can wake a peer from WAITI, acknowledge its source and return. Delivery synchronizes after instruction commit, including paused-peer edges. New fixtures pass 64,374 matrix and 103 integration assertions; pinned-header referees pass 4,288 routes and 512 combined-source/mask cases. Actual ESP32 C sender/C handler acceptance with an assembled entry/return wrapper passes 256 mailbox executions, 4,224 interrupts and 128 exact replays (512,128 retired instructions), in both directions. Peripheral generators, PID hardware, complete reset domains, APB timing, complete flash/cache and boot remain absent; no complete ISR/RTOS or timing claim follows. APP clock/stall fields and the ROM-consumed boot-address register now work through the machine bus. APP starts clock-disabled; fixture setup explicitly enables it. Gate/stall stops fetch/retirement and resumes at the same PC, without resetting shared state. Gate-aware supplied-clock/deadline APIs suppress APP counter ticks while gated. New evidence: 163 native assertions, 384 vendor-field comparisons and compiled control/mailbox stress (256 runs, 4,224 interrupts, 128 replays, 551,232 retired instructions). APP reset/release requires the separate opt-in supported reset profile below; the boot-address register does not bypass missing ROM code or set PC directly. Physical clock/pulse timing, power and cold boot are still unqualified. PS now masks reserved fields on read/write/exchange and RFI restoration; XSR.PS preserves its old-value result with privilege/window checks before the transition. This adds 1,304 native assertions and 3,456 independent assembled PS/RFI comparisons, including atomic interrupt-mask changes. A bounded reset/vector profile now supports explicit static reset-input selection, PS/LCOUNT/VECBASE reset fields and aligned VECBASE relocation with fixed vendor offsets. Undefined CPU register values use an explicit fixture policy, not a silicon retention claim. Opt-in APP reset input holds/releases the core after instruction commit and preserves shared source state. Evidence: 2,281 CPU/104 machine assertions, 3,072 assembled VECBASE accesses, 960 vendor-offset dispatches and 128 reset-address comparisons. Original test-ROM handoff passes 128 compiled supervisor/worker cycles and 16 exact replays. Actual Espressif ROM, full reset-domain behavior and SDK/board boot remain absent. An opt-in read-only mapped-flash profile now supports PID0/1 normal-mode per-core tables, 64 KiB pages, access masks and explicit flush/enable sequencing. Evidence: 7,289 native assertions, 488 parsed vendor-fact translations, 256 compiled mapped workers and 64 exact replays. Compiled PRO setup plus original test-ROM handoff also passes 128 reset cycles into a mapped worker. Immutable backing and disabled-cache table edits bound this profile; the default attachment omits SPI programming. Real cache tags/timing, live SDK mmap/invalidation, PSRAM/high PIDs and actual ROM/SDK/board boot remain unimplemented. The separate named-part fixture below adds bounded programming. The CPU task-context register profile now implements unprivileged THREADPTR, privileged MISC0..3 and read-only PRID with an explicitly supplied fixture constant. PRID's full silicon value is still unverified; the SDK's bit-13 core extraction is tested without inventing it. Evidence: 9,723 native context/access/reset assertions, 7,680 independent assembler comparisons and 1,536 actual ESP32-compiled TLS calls across six persistent banks (16 exact replays, 52,224 retired instructions). Firmware selects the banks; this does not establish a scheduler, interrupt-driven task switching or SDK boot. MOVSP now implements caller-window checks and configured AllocaCause 5 before changing SP. Evidence: 13,475 native assertions, 32,768 independent assembler comparisons and another 1,536 actual TLS C calls with dynamic stack buffers (16 replays, 253,812 retired instructions). Vendor alloca-handler restoration, preemptive scheduling and RTOS boot remain unqualified. An opt-in SPI1 read profile now executes USER 03h single-line reads against installed immutable flash backing, with receive buffers, completion/counter state and source-29 interrupt routing. Transfers require both caches disabled. Evidence: 37,466 native assertions, 27 parsed register defaults/384 reference comparisons and 128 actual ESP32 C reads pass; 32 of these also load and execute a generated RAM worker (32 exact replays, 91,568 retired instructions). Seven unchanged SDK helper bodies are tested, not the full SDK initialization or boot stack. The default attachment omits program/erase. DMA, SPI timing, GPIO/pin mux and actual ROM/SDK boot remain unsupported; the named-part option below extends the storage commands. An explicit W25Q32JV-IQ programming profile now adds write-enable/BUSY, page programming/wrap and aligned erase through SPI1. It requires an explicitly selected unprotected 4 MiB part fixture; the requested board reports Giantec-matching C4 60 16, different from this fixture's EF 40 16. External microseconds drive conservative datasheet-maximum durations. Native tests and 2,631 independent command/time comparisons pass; compiled firmware programs and executes 32 RAM workers (32 exact replays, 125,856 retired instructions). Fresh post-completion flush is required before cache enable. Full chip/protection/electrical behavior, physical timing and real ROM/SDK boot remain unqualified. No runnable ESP32 target is added, and the existing RISC-V ESP32-C3 is not a substitute.

The library's categories (2026-11-03)

Parts are filed by category and sub-category as Proteus's device picker and KiCad's libraries file them: catalog/taxonomy.json names 24 categories and their sub-categories in English, French and Spanish, every one of the 207 components has both, and the validator rejects what the taxonomy does not list while still loading the older names with a warning. The library browses the tree with counts and searches category names in the interface's language (libraryFilters.test.ts, ctest taxonomy_ui).

Part families fill it from datasheet tables (catalog/families, tools/catalog/families.py): 2184 parts in 47 families so far (2392 components in all): Vishay's 1N400x and 1N540x rectifiers, 1N581x Schottky rectifiers, BZX55 C and B, 1N4728A to 1N4761A and 1N5221 to 1N5267 zeners; onsemi's BZX79 zeners; onsemi's 1N914, 1N916, 1N4148 and 1N4448 switching diodes; onsemi's BC546 to BC548 NPN and BC556 to BC558 PNP transistors; onsemi's MC7805 to MC7824 and MC7905 to MC7918 regulators (the regulator primitive's negative polarity); Vishay's CCF55 (E96, 1 %) and CCF07 (E24, 2 % and 5 %) metal film resistors; Nichicon's UVR and UHE aluminium electrolytic capacitors (323); Vishay's K series radial MLCCs (385); Kingbright's 5 mm and 3 mm LEDs (30); Vishay's W0xG bridges; Triad's F series power transformers on the new transformer primitives (13); Vishay's SFH617A, CNY17 and 4N35 optocouplers (11); TI's LM358, LM258, LM2904, TL072 and NE5532 dual op-amps (40) and LM324, LM224 and LM2902 quad op-amps (23); Bourns' RLB radial inductors (203); onsemi's TIP31, TIP32, BD135 to BD140, 2N3055 and MJ2955 power transistors (17) and TIP120 to TIP127 Darlingtons (6); onsemi's 2N4401, 2N4403, P2N2222A, MPSA42, MPSA92 and BC327 small-signal transistors (8); Vishay's IRF, IRFZ and IRL N-channel and IRF95/96 and IRF9Z P-channel power MOSFETs (43); onsemi's 2N5060 to 2N5064 sensitive-gate SCRs (4, the thyristor's two-transistor equivalent) and MAC97A4 to MAC97A8 triacs (3, on the new triac primitive; a generic diac beside it). Every row is found in its datasheet's text by families.py verify (2184 rows, 128 datasheets, sha256 checked) and every part is held to its table's limits by its fixtures (ctest catalog_fixtures; catalog validate: 4600 fixtures). The engine now has what SPEC-004 listed for the junctions: a diode's depletion and diffusion charge (its capacitance and reverse recovery), a zener's own breakdown path (soft knee and dynamic resistance apart from the forward series resistance), a bipolar transistor's charges (switching delays, storage time) and breakdown beside its Early effect, and triac and diac primitives. The families do not set them from their datasheets yet. Not yet: comparators, film capacitors, a diac family (no datasheet reachable), and the 74HC and CD4000 functions as families; the MOSFETs' voltage-dependent capacitances (so the gate charge), avalanche and temperature; the op-amps' offset, bias, input range and noise; a resistor's power rating and self-heating; an inductor's saturation, core losses and tolerance; a transformer's core (saturation, losses) and magnetising inductance (no datasheet gives it); a capacitor's leakage, its ESR's frequency dependence and an X7R's DC-bias and temperature loss.

AI assistants: the MCP server (2026-11-02)

embsim-mcp gives an AI assistant the session a person has (ADR-035): 27 tools over the session protocol, from creating and wiring a project to building firmware, running, working inputs and reading what the circuit and boards do. python/tests/test_mcp.py checks the JSON-RPC (initialize, tools, errors, batches) and an assistant's session against the engine. Not yet: MCP resources and prompts, notifications of the session's changes to the assistant, the bench's 3D layout tools beyond set_layout.

M6, the flagship, delivered (2026-11-02)

Each of M6's exit criteria (07-roadmap) and its evidence:

Criterion Evidence
Each part's library example sketches run unmodified and pass scenarios Thirty of the most used parts, the roadmap's list among them (DHT22, DS18B20, BME280, MPU6050, HC-SR04, SSD1306, HD44780 with its I2C backpack, WS2812, servo, stepper and driver, 4x4 keypad, DS3231, MFRC522, NEO-6M): tests/vendor/arduino (see "Parts" below and the entries before it)
Each part's fixtures check its datasheet's timing and values each part's tests/*.json in the catalog, run by catalog_fixtures in ctest
The Uno's coverage table has no peripheral its core touches left unmodelled docs/coverage.md: ATmega328P 15 of 15 modelled
An ESP32-class board (Q11) the ESP32-C3-DevKitM-1: 35 of 35 peripherals modelled (docs/coverage.md); ESP-IDF v5.4's examples unmodified in tests/vendor/esp-idf (Wi-Fi, Bluetooth LE, TWAI, I2S, flash encryption, memory protection, HCI over UART among them), Arduino-ESP32's sketches in tests/vendor/arduino-esp32, EmbLinkRTOS's suite at 160 MHz
A host terminal opens the Uno's port and talks to a running sketch "A board's serial port on the host" in the table below: tests/protocol/test_host_serial.py
A circuit fed from the Uno's 5V pin sags and trips its polyfuse at the datasheet's current the MF-MSMF050-2 (ptc_fuse) on the Uno's USB path and its fixtures
A world panel setting ambient values and distances "The world (ADR-026)" below: tests/protocol/test_world.py, e2e/world.spec.ts
Paced real time (ADR-032) test_grid_slices and the paced-run entries below
Contact bounce and tolerances (ADR-034) "Imperfections on by default" below

The workbench's screenshots of the ESP32-C3 work are in docs/gallery/c3-peripherals. M7 (the world and the breadboard) is next.

The ESP32-C3's UHCI: every peripheral modelled (2026-11-02)

UHCI0 is modelled (esp32c3-uhci): a UART's data to and from the GDMA, with SLIP framing and escapes and the length, separator, break and idle ends of a received frame. ESP-IDF v5.4's HCI-over-UART controller example runs unmodified with a terminal in hex mode as the host: HCI_Reset and HCI_Read_BD_ADDR are answered as Espressif's controller answers them. Not yet: the HCI packet header and its CRC, the quick-sent queues, UHCI1. All 35 of the ESP32-C3's peripherals are now modelled.

The ESP32-C3's permission control (2026-11-02)

SENSITIVE is modelled (esp32c3-pms): the CPU's fetches, loads and stores to internal SRAM, the RTC memory and the ROM are checked against the areas and permissions ESP-IDF's memory protection sets, a denied access is blocked and the monitors latch it and interrupt. ESP-IDF v5.4's memprot test app passes all 16 of its ESP32-C3 checks unmodified, and every other ESP-IDF example still runs with the protection on. Not yet: world 1, the peripheral regions, the DMA and cache checks. 33 of 35 peripherals are modelled; UHCI0/1 remain.

The ESP32-C3's flash encryption (2026-11-02)

XTS-AES is modelled (esp32c3-xts): manual encryption through SPI1's page programs and the cache's decryption while SPI_BOOT_CRYPT_CNT is odd, with Espressif's addressing as espsecure computes it. ESP-IDF v5.4's flash_encryption runs unmodified in Development mode: the first boot burns a key and encrypts the flash in place, and the chip boots again from it encrypted. A unit test checks the ciphertext against espsecure's. Not yet: the encryption's time, the download-mode encryption controls. 32 of 35 peripherals are modelled; UHCI0/1 and the permission control remain.

The ESP32-C3's HMAC and digital signature (2026-11-01)

The HMAC accelerator and the digital signature are modelled, with the eFuses' read and write protection of key blocks. ESP-IDF v5.4's nvs_encryption_hmac runs unmodified: it burns a read-protected HMAC key and encrypts NVS under keys the HMAC derives. Unit tests check the HMAC against Python's hmac and an RSA-1024 signature, from parameters encrypted as ESP-IDF's generator encrypts them, against Python's pow. 31 of 35 peripherals are modelled; UHCI0/1, XTS-AES and the permission control remain.

The ESP32-C3's I2S (2026-11-01)

I2S0 is modelled (esp32c3-i2s) as a master in TDM and the standard formats, through the GDMA both ways. ESP-IDF v5.4's i2s_std runs unmodified in duplex mode: what it writes comes back through the shared data pin, with BCLK at 1.024 MHz and WS at 16 kHz. I2S0's clock enable was on the wrong bit of PERIP_CLK_EN0 (4, not 21) and is fixed. Not yet: slave mode, PDM transmission, the MCLK output. 29 of 35 peripherals are modelled; UHCI0/1, HMAC, the digital signature, XTS_AES and the permission control remain.

The ESP32-C3's TWAI (2026-11-01)

TWAI0 is modelled (esp32c3-twai): an SJA1000-compatible CAN 2.0 controller run bit by bit on its matrix signals, with arbitration, the acceptance filters, the receive FIFO, error frames, the error counters and bus off. ESP-IDF v5.4's twai_self_test runs unmodified with TX jumpered to RX (300 frames at 25 kbit/s), and a unit test checks a frame's edges against an independently computed one. Not yet: overload frames, triple sampling, the clock output. 28 of 35 peripherals are modelled.

The ESP32-C3's sigma-delta modulation (2026-11-01)

GPIO_SD is modelled (esp32c3-sdm): four pulse-density channels on matrix signals 55 to 58, a bit every SDn_PRESCALE + 1 APB cycles, (SDn_IN + 128) / 256 of them high. ESP-IDF v5.4's sdm_led runs unmodified: over a whole 2 s sweep of its density, GPIO0 is high 118/256 of the time. Probes take a capacity (their memory depth) for long, busy captures. The ESP32-C3 has 27 of 35 peripherals modelled; I2S, UHCI0/1, HMAC, the digital signature, XTS_AES and the permission control remain (docs/coverage.md). EmbLinkOs/EmbLinkRTOS#46 runs EmbLinkRTOS's ESP32-C3 board at 160 MHz from the PLL, as ESP-IDF's bootloader does.

Parts: the MAX7219, the buzzer, the GL5528, the push button, a bar graph, the LM35DZ, the 74HC595, the 8x8 matrix and the DS1307 (2026-11-01)

Nine more of M6's most-used parts are verified by unmodified examples on the Uno (tests/vendor/arduino): LedControl's LCDemo7Segment on the MAX7219 8-digit module (27 assertions: the text and each digit's lit segments) and the IDE's toneMelody on a passive buzzer (11: each note's Timer2 frequency, the rest and the gaps), and the IDE's Calibration with a GL5528 photoresistor (5: the calibrated range, the LED's duty at 100 lux from the project's drawn parts, full on, off), and the IDE's Debounce and StateChangeDetection against a bouncing push button (7 and 8: seven edges for one press, yet one toggle or count each; a 20 ms tap ignored), and the IDE's barGraph on a new 10-segment bar graph of independent LED junctions in the DC-10 pinout (emblink/led_bargraph_10), and the IDE's ReadAnalogVoltage on an LM35DZ (0.25, 0.37, 0.60 V at 25, 37.5, 60 degC), and ShiftRegister74HC595's example on a 74HC595 wired to D0-D2 as it says (through the board's resistors to the USB-serial bridge), and the IDE's RowColumnScanning on the 8x8 LED matrix (its dim cursor moved by two pots). RTClib's ds1307 and ds1307nvram run on a DS1307 rewritten from its data sheet (user buffers, countdown reset, 12-hour mode, a new part halted until CH is cleared). With these, thirty of M6's most-used parts are verified by unmodified examples. The analog solver now factors in a minimum-degree order over each pivot row's nonzeros (0.61 of the time on that matrix circuit, same steps). The GL5528 now follows the GL55 datasheet: gamma 0.6, 10-20 kOhm at 10 lux drawn per part, 1 MOhm dark. The MAX7219 model shows decimal points, its code-B font per digit and the segment patterns libraries send, and shifts DOUT on CLK's falling edge; a passive buzzer falls silent two periods after its drive stops. Fixtures: max7219_display/tests/raw_segments, buzzer/tests/stops. The GL5528 follows a change of light with its datasheet's response time, a first-order lag in conductance of 20 ms rising and 30 ms decaying (gl5528/tests/response-rise, response-decay).

Not yet: the MAX7219's 8x8 matrix variant and chained devices, its multiplexing and brightness as light; the buzzer's sound pressure and resonance; the GL5528's response times as they vary with the light, and its slow tail toward the dark resistance.

Visual Benchmark v0.1: the workbench redesigned, in English and French (2026-11-01)

The workbench's shell and perspectives redesigned around the simulation (docs/engineering/visual-benchmark.md): a navigation bar and a simulation bar; the state named in words and an icon, never by colour alone; simulated time apart from the measured host rate; a status bar led by the simulation; a connection screen when the engine is not there; a Settings page (language, theme, text size, density, layout restore and reset, time unit, precision, rate format) applied at once and persisted; English and French from typed catalogs with English fallback, the shared packages included.

Evidence: pnpm typecheck, lint, test (370, i18n.test.ts among them: key parity, placeholders, plural pairs); the Playwright suite with e2e/settings-language.spec.ts (settings applied and kept, the workbench in French without overflow, back to English) and workspace-layout.spec.ts at 1440, 900 and 768 px; twelve workflows captured before, after and in French (docs/gallery/visual-benchmark-v0.1).

Since then: the engine's diagnostics carry their French (messages.fr, every format the engine raises, checked by ctest diagnostics_fr; messages passed through whole from a parser, a validation or a Lua model stay English), and every catalog entry carries its text in French under i18n.fr (225 entries, checked against their English by ctest catalog_fr; the library and inspector show it). Compact density now reaches the plots drawn on canvases (the oscilloscope's, the logic analyzer's and the power profiler's rows, margins and labels, which also follow the text size as it changes) and the schematic canvas's screen-space chrome (tooltip, HUD, legend, navigator); the schematic's own drawing keeps its sheet size (e2e/compact-density.spec.ts). Panels move between perspectives: Run's Meters, Air and Diagnostics and the Debug perspective's seven panels float over every perspective in the instrument windows, their home docks keeping a way back (e2e/movable-panels.spec.ts). Spanish is the third interface language (all 1008 messages; i18n.test.ts, settings-language.spec.ts); the catalog's text and the diagnostics are English and French only and show in English in Spanish.

Not yet: the catalog's text and the diagnostics in Spanish.

Imperfections on by default: bounce and tolerances (2026-11-01)

ADR-034's first imperfections are on by default.

Bounce.

  • Push buttons and toggle switches bounce: six transitions over 2 ms and 5 ms, on press and on release. The keypad already bounced.
  • "bounce": false gives an ideal contact.

Tolerances.

  • Resistors, capacitors, electrolytics and inductors carry a tolerance.
  • Each instance's value is drawn uniformly inside it, from the project's settings.seed and the instance's id.
  • The run report's snapshot.drawn lists the values.
  • settings.imperfections: "ideal" gives nominal parts (Q17).

Evidence.

  • examples/button-bounce passes for 31 seeds: six raw edges per press, and one debounced edge behind an RC and a Schmitt inverter.
  • The resistor's tolerance fixture checks seed 7's draw (1026.41 ohm).
  • The push button's and keypad's bounce fixtures count their edges.

Board changes.

  • The Blue Pill gains its 100 nF NRST capacitor, which filters the reset button and delays the boot by about 0.8 ms.
  • The Uno's DTR auto-reset is a bounce-free part of its own.

Paced real time is host-independent. Islands take a step boundary on a 1 ms simulated grid and paced slices end on it, so a sliced run equals an uncut one to the bit (test_grid_slices).

A reset is now a fresh start. Islands stop at the start of a reset, so a replay from reset matches a recording begun mid-run to the picosecond (test_reset_is_load, the Python client's recording tests).

Firmware. EmbSIM's own tours and the NUCLEO-F446ZE example debounce in software. ST's unmodified F446ZE examples that press B1 (gpio_exti and the USB HID mouse) run with ideal contacts, and the project says why: the board has no filter on B1 (C52 not fitted), and how many times the example acts depends on the real switch.

Not yet.

  • Temperature coefficients drawn per part.
  • Noise on converters and sensors.
  • Missing-decoupling effects.
  • Breadboard contact resistance.
  • Bounce varying from press to press: every press of a part bounces the same way.
  • Tolerances on parts other than R, C and L.

Damage and the fault mode (ADR-034, 2026-11-02)

An LED is damaged as a real one is: above its 30 mA DC or 5 V reverse rating a warning (Kingbright WP7113ID), its junction heated by its own power through the datasheet's thermal resistances (560 K/W to ambient, 390 K/W to the leads; two thermal nodes solved in closed form, so a quiet circuit warms for minutes at no cost and the part wakes exactly when its junction passes 125 C), then burnt out open (part.damaged) until its replace input. A regulator with its thermal resistances and shutdown temperature (the Uno's NCP1117ST50, from onsemi's NCP1117/D: SOT-223 160 K/W minimum pad, 15 K/W to the case, the die held near 175 C) heats with what it drops; its thermal shutdown then limits its current to what holds the die there, so 12 V into 25 ohm without a heatsink settles at about 2.2 V with a 175 C die (part.thermal_shutdown). The ATmega328P's pins warn past their absolute maximum ratings (40 mA, -0.5 V to VCC + 0.5 V; datasheet section 28.1) and are held about a diode drop past their rails by their protection diodes. A project's faults (a cut pin, a short between nets or pins, a two-terminal part failed open or short) are emblink/fault switches wired in at load and switched by their active input at any time. Evidence: the LED's fixtures (no resistor: burnt out in milliseconds; 20 mA for 10 minutes: about 50 C, alive; 45 mA: warned, alive; 110 mA: alive after 1 s, dead within 2 minutes; replaced after the fault), the fault part's fixtures, and tests/protocol/test_faults.py (a cut anode, a bridged LED, a shorted resistor burning the LED, replacement, the project keeping its list; the Uno with D13 shorted to ground warning of 60 mA out of the pin, and 6 V through 100 ohm into D3 held at 5.7 V and warned). Not yet: noise on converters and sensors; the other MCUs' pin ratings (their ioh_max/iol_max are recommended drive currents, not absolute maxima); damage to MCU pins (no failure point is published), capacitors and semiconductors other than the LED; the LED's heat capacities are estimates (not published) and it is taken to fail at its absolute maximum junction temperature; an intermittent fault's chatter.

Bench instruments: the Fluke 87V multimeter (2026-11-02)

The fourth bench instrument (ADR-033): emblink/fluke_87v, from Fluke's 83V/87V detailed specifications and Eaton's DMM-B fuse data sheet. Its jacks (COM, V Ω, mA/µA, A) are its pins and its rotary switch an input; it loads the circuit as the meter does: 10 MΩ on volts, a source per range on ohms (the typical short-circuit currents, < 7.3 V open), 0.6 mA on diode test, the current jacks' shunts at their burden voltages (100 µV/µA, 1.8 mV/mA, 0.03 V/A) in every position, F1 440 mA and F2 11 A fast fuses opening after their total clearing time from Eaton's curves and staying open until replaced. The display: 6000 counts, 4 updates a second, autoranging, DC averaged and AC true RMS over the update, OL. Evidence: nine fixtures (5.000 V; 3.333 V on a 10 M/10 M divider, its own loading; 4.700 kΩ after autoranging down from 50 MΩ; OL open; 4.99 mA in series with 1 kΩ; the lead left in mA/µA across a supply blowing F1 in milliseconds; 400 mA carried for 2 s; 1.000 V RMS of a 50 Hz sine within the 87V's accuracy; an LED's forward voltage on diode test) and the Run perspective's front panel (display, switch, jacks, fuses, Fluke87vPanel.test.tsx). Not yet: capacitance, frequency, temperature, MIN MAX and the other buttons, the continuity beeper (its threshold is not published in the specifications), the input alert's chirp, the accuracy as an error, the fuse element's cooling.

USB host mode, a USB mouse, a flash drive, and Adafruit's TFT shield (2026-10-31)

The STM32F446's OTG FS core works as a host too (stm32-otg-fs with FHMOD: the port, frames and twelve channels as ST's HCD driver uses them), and the MCU is both ends of its cable. USB parts share a device core (core/model/usb_dev.c); emblink/usb_mouse is a low-speed HID boot mouse, emblink/usb_flash_drive a full-speed mass storage device (Bulk-Only, SCSI) whose medium is FAT16 as from the shop. The NUCLEO-F446ZE's U12 (emblink/stmps2151str, values from ST's datasheet) powers CN13's VBUS from PG6. emblink/st7735_tft18 (a C model of the ST7735R and its 1.8" panel) and emblink/adafruit_tft_shield18 (its joystick ladder from Adafruit's schematic) give ST's host examples their display. Evidence: test_stm32f4's test_otg_host (connection with PPWR, PRST's reset and the port enabled at full and low speed, SOFs every 1 ms, a SETUP waiting for its FIFO words and taking 14 us, IN data with its statuses and XFRC on the taking, NAK stopping the channel, TXERR, the halt and CHH, an OUT's toggle, an interrupt channel once a frame, disconnection, a low-speed SETUP's 113 us, PSUSP and PRES); the mouse's fixture on the PC's host; U12's four fixtures (on at 0.5 A within the datasheet's resistance, EN at VIL and VIH) and the board's usb-host-vbus; the TFT's six fixtures (16 bits a pixel, MADCTL's mirroring, BGR and inversion, sleep, the reset cancel time, ST's cursor-only CASET); the shield's six (each direction in BSP_JOY_GetState's window); CubeF4's USB_Host/ HID_Standalone, unmodified, 13/13: VBUS on through U12 at 150 ms, the mouse enumerated at low speed (address 1, report protocol), the log on the LCD, SEL starting the mouse demo once the log is quiet (while it scrolls the main loop draws and does not read the joystick, as on the board), its window drawn, reports as the mouse moves and clicks; the drive's fixture on the PC's port; CubeF4's USB_Host/MSC_Standalone, unmodified, 14/14: the drive enumerated at full speed, its LUN taken, FatFs mounting it, B1 writing 'USBHost.txt' and reading it back, the drive then holding USBHOST.TXT (40 bytes). The analog islands lag up to 10 us behind an MCU's SPI clock instead of stepping at each edge (caught up before any reading), which brought this run from 18 min to 2.5 min. Not yet: the ID pin, SRP and HNP, the drive's NAND busy times and an image file kept between runs, hubs and split transactions, the over-current flag's blanking and current limit in U12, the shield's microSD socket, a workbench view of the LCD and the USB host's state.

Bench instruments: the Rigol DS1054Z (2026-10-31)

The third bench instrument: emblink/rigol_ds1054z, from Rigol's DS1000Z specifications. Inputs loading the circuit (1 MΩ or 10 MΩ ∥ 15 pF), the sample rate by channels and memory, 8-bit quantisation over 10 divisions, the 50 MHz (or 20 MHz) bandwidth, DC/AC/GND coupling, the edge trigger in Auto, Normal and Single with holdoff. Evidence: eight fixtures (1 V behind 1 MΩ read 0.909 V through the 10x probe and 0.5 V at 1x; Normal triggering on a clock and waiting on a level; Auto refreshing; Single stopping; 100 MSa/s at 10 ms/div from the memory; 250 MSa/s with four channels) and tests/protocol/test_oscilloscope.py (an RC step: the time constant measured from the trace as 100.5 µs for 100 µs, 63 % and 86 % at one and two time constants, 8-bit codes, Single re-armed). The Run perspective draws its screen and front panel live (scopeMeasure.test.ts; the gallery). Not yet: the other trigger types and serial decoders, math, FFT, XY, Roll, averaging and peak detect, gain and offset errors and noise; Auto's wait is assumed; the hardware frequency counter. The automatic measurements are made on the screen's 1200 points a channel, as the DS1000Z's are: a fast signal on a slow timebase measures as badly as on the scope, where users meet it.

Bench instruments: the Nordic PPK2 (2026-10-31)

The second bench instrument: emblink/nordic_ppk2, Nordic's Power Profiler Kit II, from its user guide's section 8. Source meter (0.8 to 5.0 V, at most 600 mA) or ampere meter (in series); the current at 100 kS/s, each 10 µs sample at its range's resolution (five ranges, 0.2 µA to 1 mA); negative currents read 0; D0 to D7 of its logic port at 100 kHz. Evidence: six fixtures on its core (3.3 V into 330 Ω read 10.00 mA; into 1 Ω the 600 mA limit and 0.6 V; 3.3 µA read 3.4 µA at 0.2 µA resolution; the ampere meter's 20.00 mA; a reverse current read 0; no samples before Start), one on the whole kit (current and logic port together), and tests/protocol/test_power_profiler.py (a load sleeping at 1 mA and waking for 1 ms every 10 ms at 101 mA: 5000 samples in 50 ms, both levels at their ranges' resolution, a 10 % duty, an 11.00 mA average, D0's edges where the current steps). The Run perspective's panel follows it live (powerCapture.test.ts; the gallery). Not yet: the measurement resistors' voltage drop (unpublished: r_series assumed), the accuracy as an error, range-switching transients, the logic port's thresholds (assumed).

Bench instruments: the Saleae Logic 8 (2026-10-31)

The first of three real bench instruments (docs/engineering/bench-instruments.md): emblink/saleae_logic8, Saleae's 8-channel logic analyzer. Its leads load the circuit (1 MΩ to ground ∥ 10 pF, high above 1.2 V and low below 0.6 V); it samples at 1 to 100 MS/s (100 MS/s on up to 3 channels, 50 on up to 6, 40 on up to 7, 25 on all 8, as its data sheet gives) exactly as a sampler does, without waking at each sample: an edge lands on the first sample after it and a pulse between two samples is missed. Start/Stop, a capture length, a trigger on one channel's edge with a pre-trigger share; the capture is read live with instrument.read. Evidence: eight fixtures (a 1 MHz clock's 200 edges in 100 µs, a 5 ns pulse missed at 1 MS/s and seen at 50 MS/s, the rate limits, the trigger's armed, capturing and done), tests/protocol/test_logic_analyzer.py (a terminal's "Hi" at 9600 baud captured at 1 MS/s and decoded from the transitions alone; a capture triggered on the start bit opening 0.5 ms before it). Not yet: the Logic 8's analog inputs; the SPI and I²C analyzers in its panel (they need several channels mapped). The Run perspective's Logic 8 panel follows a capture live, decodes Async Serial, and exports Logic 2's CSV and VCD (logicCapture.test.ts; the gallery shows a triggered capture of a terminal's "Hi" decoded).

USB on the bench: the STM32F446's OTG FS and a computer's port (2026-10-31)

USB cables are part of the bench (core/engine/usb.h, ADR-031's native USB devices as transactions): a host part and the device whose controller's D+ is on its net. The STM32F446's OTG FS core works in device mode (stm32-otg-fs, on an OTGFS register block laid out as RM0390 has it), and emblink/usb_host is a computer's USB 2.0 port that powers VBUS and enumerates the device as Windows and Linux do, then polls its HID endpoints. Evidence: test_stm32f4's test_otg_fs (the soft reset waiting for the 48 MHz clock, the forced modes' 25 ms, VBUS sensing on PA9, suspend after 3 ms, SETUP and the receive FIFO's statuses, IN packets waiting for their words, SET_ADDRESS's status stage, data toggles, STALL, SEDET, the OTG_FS interrupt as a level re-entered while asserted); CubeF4's USB_Device/HID_Standalone, unmodified, 21/21 on the NUCLEO-F446ZE with a host on CN13: enumerated as 0483:5710 'STMicroelectronics' 'HID Joystick in FS Mode' on USB 2.0's timeline and three presses of B1 moving the cursor -5, +5, +5; the same image suspended by the host (remote wakeup armed), woken by B1's remote wakeup, unplugged and enumerated again after the cable is put back, 16/16; CubeF4's DFU_Standalone downloading ST's GPIOToggle .dfu as dfu-util would (with its static allocator's size corrected: as shipped it overruns into the PCD handle and never answers SET_CONFIGURATION, which its own scenario asserts), resetting into it with the flash kept, 10/10 and 5/5; emblink/usb_host's and emblink/usb_host_controller's fixtures. Not yet (then): host mode and U12 (now above), class drivers beyond HID's polling and DFU's download (CDC and MSC are configured, then idle), the USB/IP bridge to the computer's own USB, LPM, low-speed devices (now above) and hubs, the other MCUs' USB controllers (RP2040, nRF52840, PIC32, ESP32-C3).

The STM32F446 completed further, and the NUCLEO-F446ZE (2026-10-31)

The F446's model gains what firmware sees of its clocks and flash: each oscillator and PLL is ready DS10693's typical start-up time after it is enabled (LSE's 2 s, a crystal's 2 ms, a PLL's 75 to 100 us), CIR's ready interrupts, the flash's program and erase times with BSY and the bus stall of code running from it, the CRC unit, and TIMx_OR's remaps (TIM5 measuring LSI). Evidence: test_stm32f4's test_startup_times, test_crc, test_tim5_lsi and its flash test (BSY's 16 us and a sector's 250 ms with no instruction run meanwhile); CubeF4's NUCLEO-F446RE suite, its EEPROM_Emulation now ending past 13 s.

The NUCLEO-F446ZE (MB1137, STM32F446ZE in LQFP144) is a board: its LEDs, buttons, power paths and jumpers, the Zio and morpho connectors (every I/O on the morpho once), CN13's lines and the VCP on USART3. Evidence: its six fixtures, and 21 of CubeF4's STM32F446ZE-Nucleo examples run unmodified under scenarios (run.py --board nucleo_f446ze). The board follows ST's MB1137 B-01 schematic part by part (its LED, button and USB circuits, its solder bridges), and the NUCLEO-F446RE was checked against MB1136 C-03 and C-04 (B1's network, CN7's SB48/SB49). Not yet (then): the USB OTG FS controller (now in device mode, above) and U12, the switch that powers VBUS for a host; MCO1/MCO2 on their pins; the ST890, TSV631 and S9013 datasheets' own values (their parts declare what is assumed).

The PIR sensor (2026-10-31)

emblink/pir_sensor is the HC-SR501 as its datasheet describes it (warm-up, Tx, H/L trigger modes, the BISS0001's block), its motion read from the world when not set: a warm body moving in its cone and range. Evidence: five fixtures (hold, warm-up, single trigger, retrigger, block; flipping the mode breaks the retrigger one) and tests/protocol/test_pir.py (a cold moving box and a still person unseen, a walking person seen at the next look, OUT falling a hold after they leave the range). A person is drawn as a figure in the box the sensors see, walking in step with virtual time (figure.test.ts). The lens's view cones followed (zone, 7.5° by default, an assumption as the HC-SR501's pitch is unpublished): the element sees a warm body whose image crosses from one cone to the next, so walking across is seen sooner than walking straight at it (test_pir.py: mid-cone at 2 m, walking across at 0.5 m/s, unseen at 150 ms and seen by 400 ms; walking straight at it from 2.8 m at 1 m/s, unseen at 500 ms and seen by 800 ms, as the image climbs to the next cone at 2.17 m). Not yet: the lens's real pattern, the element's response to speed and size; warm-up glitches on OUT.

Moving bodies (2026-10-31)

World bodies move in virtual time (velocity_mm_s, travel_mm), in the engine (esk_world_body_at): distance sensors read them where they are. Evidence: tests/protocol/test_world.py (a cart out and back over its travel; a project body added at 3 s placed on the timeline from 0), NewPing's unmodified example measuring an approaching wall (105, 104, 101, 99 ... 66, 64 cm, 8/8 assertions), world-motion.test.ts (the bench's copy of the motion, the same numbers), and the gallery. Not yet: physics (gravity, collisions; Rapier is the plan's choice). (PIR sensors reading motion followed, above.) Bodies then walk paths (path_mm, speed_mm_s, loop): round a loop or there and back, in the engine and drawn the same way (test_world.py and world-motion.test.ts check a walker on a 1 m square at 1 m/s at (1000, 500) after 1.5 s and home after 4 s, and one on an open path half a metre back after 2.5 s). Shadows reach the floor: the shadow map follows what the camera shows (shadowfit.test.ts), the shell shades only the sun (room.test.ts), and the gallery shows the lamp's and the sun's. Bodies fall (falls, restitution): under standard gravity, bouncing off the table or the floor, at rest once a bounce would rise under 0.1 mm (test_world.py and world-motion.test.ts: 0.3 s after letting go from 1 m it has fallen g t²/2; the first bounce off the table rises a quarter of the drop at restitution 0.5; beside the table, or thrown off its edge, it rests on the floor). Not yet: collisions between bodies or with walls, rolling, sliding, spin.

The window's sunlit patch (2026-10-31)

When the sun shines through the window, only a window-shaped patch of the table is sunlit: the walls, ceiling and the window's bars cast shadows, and the sun's shadow camera starts outside the room. Evidence: room.test.ts (which room surfaces cast shadows, the pane not), the gallery, and the edge's position measured against the projected bench axis (38° N, 21 December, noon: the edge at x = -29 mm where the frame's top bar puts it at +24 mm, half a degree of elevation). Not yet: floor shadows outside the table's 2 m shadow frame, physics.

MicroPython on the Pico (2026-11-02)

MicroPython v1.24.1's rp2 port, built unmodified for RPI_PICO, goes onto the Pico as on the bench: a Pico running pico-blink-serial is plugged into a computer's port with BOOTSEL held, MicroPython's firmware.uf2 (666 KB) is copied onto the RPI-RP2 drive (about 4.8 simulated seconds of erasing and programming), the Pico reboots into it, enumerates as MicroPython's own USB device (2e8a:0005 "MicroPython" "Board in FS mode") and the terminal opens its serial port. At the prompt print(1+1) answers 2, machine.Pin('LED', machine.Pin.OUT).value(1) puts GPIO25's net high, and a file written to its littlefs filesystem (formatted at the first boot through the bootrom's flash functions) is listed by os.listdir() (tests/vendor/micropython/run.py, CI's linux-gcc job). The whole run takes about 1.2 s of wall time. For it the RP2040 gained its RTC (MicroPython sets the time at boot and waits for it to run). Its USB serial port is also a serial port on the computer: port.open on the USB host gives a pseudo-terminal, a program opening it raises DTR and closing it drops it, and a terminal's print(6*7) and mpremote's raw REPL (Ctrl-A, the code, Ctrl-D) are answered over it with the session in real time. Not yet: mpremote itself in CI (its raw-REPL protocol is what the test speaks). At the prompt rp2.StateMachine runs an rp2.asm_pio program and rp2.DMA copies memory.

Debug probes: the NUCLEO's ST-LINK, the Pico's Debug Probe (2026-11-02)

The plan is docs/engineering/debug-probes.md; its first three steps are in. Every Cortex-M core has its halting debug as a debugger reaches it through the debug port: DHCSR's halt, step and restart, DCRSR and DCRDR, DEMCR's vector catch, DFSR, BKPT, the FPB's breakpoints and the DWT's watchpoints. A halted core runs nothing while the clocks and peripherals go on, unlike the session's own debugger, which pauses the whole simulation (tests/unit/test_cm_debug.c). The NUCLEO-F446RE's ST-LINK/V2-1 (U2) answers OpenOCD 0.12's commands for firmware V2J37M26 and reaches the target through its SW-DP and MEM-AP. The session shares it on the host as ST's stlink-server does (stlink.serve, embsim serve --stlink). tests/protocol/test_stlink.py passes 32 checks:

  • the probe's identity and the target's voltage;
  • SWD, the IDCODE, a halt, registers, memory, a fault's address, a step, a restart and NRST;
  • DBGMCU's DBG_TIM2_STOP and DBG_IWDG_STOP holding a timer and the watchdog while the core is halted;
  • unmodified OpenOCD programming a blank board, the program then running (its banner, LD2 blinking);
  • GDB through OpenOCD stopping at a breakpoint on main, stepping a line, and stopping on a watchpoint in SysTick_Handler;
  • printf over SWO: a program's ITM writes on PB3's TRACESWO, read through the probe by OpenOCD's tpiu and itm commands, and garbage when the TPIU's rate is not the probe's (the ARMv7-M cores' ITM and TPIU, cortexm/itm.c).

The probe's own USB device on CN1 (0483:374B, composite) with its NODE_F446RE drive: a .bin copied onto it by a computer's USB port is programmed into the flash over SWD at the flash's times and the board runs it (tests/protocol/test_stlink_drive.py). With CN1 free, the session's USB/IP server (usbip.serve, embsim serve --usbip) puts that USB device on the computer's USB stack for st-flash, st-info and STM32CubeProgrammer (tests/protocol/test_usbip.py: device list, import, enumeration, ST-LINK commands on the bulk endpoints, an unlinked URB, the drive's INQUIRY).

In CI's linux-gcc job the kernel's own vhci-hcd attaches that device and stlink-tools' st-info reads the STM32F446's chip id through it (tests/protocol/usbip_kernel.sh).

The Raspberry Pi Debug Probe (emblink/rpi_debug_probe) drives a Pico's SWD pads and bridges its UART, as the debugprobe firmware's CMSIS-DAP v2 build: its packets are clocked bit by bit on the RP2040's own serial wire, whose three multi-drop debug ports (each core's and the Rescue DP) answer as ADIv5.2 has them (core/mcu/swd.c; test_rp2040's bit-level checks). tests/protocol/test_debug_probe.py drives it over USB/IP with OpenOCD's packets (the dormant wake-up, TARGETSEL, both cores' debug, TransferBlock, the UART's echo, the Rescue DP), and unmodified OpenOCD with target/rp2040.cfg halts both cores and reads the flash through it on vhci-hcd in CI (examples/pico-debug-probe, docs/user/pico-debug-probe.md).

embsim ide writes VS Code's launch configurations and tasks from the board's debug section: through the probe with OpenOCD, and on EmbSIM's GDB server for any board. tests/protocol/test_ide.py carries both out as VS Code does.

Not yet:

  • the ST-LINK's virtual COM port's data on USB;
  • SWO in Manchester (the V2-1 reads NRZ), and the F103's and nRF52840's trace pins (their ITM and TPIU are there, no pin carries TRACESWO);
  • the Blue Pill's ST-Link clone, the nRF52840 DK's J-Link OB (its values are SEGGER's and Nordic's, on sites this session cannot reach; the nRF52840's own debug port, CTRL-AP and APPROTECT are in, for any probe on the DK's SWD pins), and the PICkit (its host protocol is unpublished).

The RP2040's PIO and DMA (2026-11-02)

PIO0 and PIO1 (core/mcu/rp2040/pio.c) and the DMA controller (core/mcu/rp2040/dma.c) are modelled, written for EmbSIM from the datasheet's chapters 3 and 2.5. The Pico SDK's pio_dma app, built unmodified with its pioasm, passes 9 assertions: a PIO program sends "pio says hello" at 115200 baud out of GP2 to a terminal; a second state machine makes a 1 kHz square wave on GP3 (40 edges in 20 ms, counted through the SIO); DMA copies 1 KiB, chains two channels and raises DMA_IRQ_0, computes CRC-32 0xcbf43926 of "123456789" with its sniffer, and sends lines paced by UART0's and PIO0's TX requests and reads the ADC's FIFO paced by its request. A stalled state machine costs nothing while it waits for its FIFO. Not yet: the bus's arbitration between DMA and the cores (a transfer takes no core cycles), the input synchroniser's two cycles, the XIP streaming DREQs.

USB for a Pico's own program (ADR-031, 2026-11-02)

The RP2040's USB controller works in device mode as TinyUSB drives it: the pull-up from MAIN_CTRL and SIE_CTRL, bus reset and SOF, SETUP into the DPRAM, each endpoint's buffer control words (single and double buffered, the RESET bit, BUFF_STATUS per buffer or per pair), STALL with EP_STALL_ARM, EP_ABORT, INTR, INTS and USBCTRL_IRQ. The Pico SDK's stdio over USB, built with the unmodified SDK and TinyUSB, enumerates on a computer's port as 2e8a:000a "Raspberry Pi" "Pico" with the flash's unique ID as its serial number, and the port (emblink/usb_host) opens its CDC ACM serial port as a terminal does: the greeting arrives, and what is typed comes back in upper case (tests/vendor/pico-sdk/apps/usb_hello, 6/6). Not yet: the CDC port as a serial port on the computer itself (ADR-032), host mode, isochronous endpoints, suspend and remote wakeup on the RP2040, MicroPython (next: its rp2 port uses this USB stack).

The Pico's USB boot and UF2 files (ADR-031, 2026-11-02)

The Pico is programmed as a real one is: with BOOTSEL held at reset (the flash's chip select low through R_BOOT), with no valid boot2, or after reset_to_usb_boot, the RP2040 attaches to its USB cable as the bootrom's RPI-RP2 drive (VID 0x2E8A, PID 0x0003, "RP2 Boot", a mass storage interface and the PICOBOOT one), a 128 MiB FAT16 volume holding INFO_UF2.TXT and INDEX.HTM. A computer's port (emblink/usb_host) copies a file onto it as a file manager does on FAT16 (INQUIRY, READ CAPACITY, the boot sector, FAT and root directory read; the FAT's copies and the directory entry written; the data in WRITE(10) commands of up to 64 KiB); every 512-byte sector that is a UF2 block of the RP2040's family for flash is programmed, its 4 KiB sector erased first, at the W25Q16JV's times (the bulk endpoint NAKs meanwhile), and once every block of the file is in, the part reboots through the watchdog into it. Evidence: tests/protocol/test_uf2.py (a Pico running pico-dual-core plugged in with BOOTSEL held enumerates as 2e8a:0003, takes pico-blink-serial's UF2 file and reboots into it, printing its banner; a UF2 file of the nRF52840's family is ignored), the Pico SDK suite. Inside: the bootrom's code does not run; its USB device is done by the host, as its other functions are. Not yet: picotool's PICOBOOT commands, UF2 files for RAM, a blank board (no firmware entry) in its USB boot, MicroPython.

The schematic's frame times (ADR-028, 2026-11-02)

e2e/schematic-frame-budget.spec.ts measures the schematic on a 500-part sheet (250 RC sections in a ladder, about 750 wires and 250 labels) opened as a person opens a file: each frame's main-thread work (input, style, layout, paint recording) while zooming 40 wheel notches, panning with the middle button and dragging a part, reported against ADR-028's 8.3 ms and 16.7 ms. In headless Chromium on a shared CPU (SwiftShader): panning and dragging a part within 2 and 5 ms at the median, 15 to 45 ms at the 95th percentile depending on the load beside it; zooming 2 to 3 ms at the median and 27 to 30 ms at the 95th percentile, its slow frames those with the whole sheet in view, where Blink repaints every symbol at the new scale (the JavaScript in them is under 1 ms). So the schematic does not yet meet the budget while zoomed out on a large sheet: ADR-028's WebGL path for the schematic is the remedy, not yet built. A compositor-only transform was tried and measured worse on the main thread (the <svg>'s style change per frame costs more than the paint it saves), so it was not kept. The numbers are reported in CI, judged with EMBSIM_FRAME_BUDGET=enforce on a reference machine; the frame-budget specs run without Playwright's trace (its DOM snapshot at every input was most of a measured frame). Not yet: the instruments at their widest in the harness, a reference machine in CI.

GPU frame times (2026-10-31)

GpuTimer (frames.ts) times each frame on the GPU where the browser exposes EXT_disjoint_timer_query_webgl2, as the measure embsim.bench3d.gpu; the frame-budget spec reports it. Evidence: frames.test.ts (results read in order once available, a disjoint event discards them, no extension does nothing). CI's SwiftShader has no timer queries, so the GPU column is measured only on real GPUs.

Capped sections (2026-10-31)

A section's cut faces are capped (caps.ts): stencil helpers per closed body, one cap plane on the cut. Evidence: caps.test.ts (the helpers' sides and stencil operations, plates and see-through bodies left out, the cap on the plane and never under the pointer, everything removed with the section) and the gallery. The quality passes' own materials are clipped too. The outline's mask shader takes three's clipping chunks, so a cut part is outlined as cut. Not yet: open meshes (a KiCad model with open surfaces) may cap imperfectly.

Static batching (2026-10-31)

Stage 7: batch.ts merges each built part's meshes in the shared static materials, one mesh per material (the NUCLEO-F446RE: 581 meshes to 22). Evidence: batch.test.ts (a header strip's bounds and triangles unchanged, one gold mesh; the NUCLEO's buttons still pressable), the renders unchanged, and the frame harness (demo bench, headless: quality p95 10.4 to 6.5 ms). Not yet: instancing across parts (a hundred resistors are still a hundred batches), level of detail.

The sun by the time of day (2026-10-31)

The world may declare the room's size and its window's direction (world.room) and where and when it is (world.sun); both are presentation and kept with the project (set_world takes them; an empty one is removed). The bench's key light follows the sun when its beam reaches the table through the window, soft window daylight when it does not, the ceiling lamp at night. Evidence: sun.test.ts (noon elevations at 40° N in June and December, sunrise and sunset azimuths at an equinox, the beam through the window or the wall), world-sun.test.ts, the world spec in e2e/world.spec.ts, tests/protocol/test_world.py, and the gallery. The sun's patch on the table followed (above). Not yet: the illuminance following the sun (it stays the declared field, which the light sensors read), physics.

The room around the bench, and frame times (2026-10-31)

Stage 6 of the 3D plan has begun: the bench's surface is the top of a 750 mm lab table in a room (walls, floor, ceiling, a window on the left), lit by the world's illuminance. Evidence: room.test.ts (the table's top at the bench's surface, the window a hole through the wall, the light level by illuminance) and the gallery. Not yet: shadows on the floor, and physics (the room's size and the sun followed the same day, below).

Stage 7's harness: each frame's render is a User Timing measure, and e2e/frame-budget.spec.ts reports the percentiles while orbiting the demo bench in draft and quality (headless SwiftShader: draft p95 about 3 ms, quality p95 about 4.5 ms of CPU time). The time is the CPU's (the GPU's work is asynchronous, so it is a lower bound); CI reports it, and EMBSIM_FRAME_BUDGET=enforce judges it on a machine with a GPU. GPU timer queries followed (below); not yet: instancing and level of detail.

Gull-wing leads and small-outline parts (2026-10-31)

More of stage 2: QFP leads are gull wings (MS-026), and parts whose package is SO/SOIC, VSSOP/MSOP or TSSOP stand on an SO-to-DIP breakout (the LMV358), the package at its JEDEC dimensions on the breakout's pads. Board features turn by any angle; the NUCLEO-64's MCUs sit at 45°, marked. Evidence: packages3d.test.ts (the outlines' nominal dimensions, each foot on its pin, tip-to-tip span, the breakout's posts on the DIP pins) and surface-packages.test.ts. Not yet: J-leads (PLCC, SOJ), SO parts whose catalog pins carry no package numbers.

Parts from KiCad's 3D models (2026-10-31)

Stage 3 of the 3D plan has begun. A catalog part may name a 3D model file (bench.model3d: a VRML file, its scale, offset, rotation, source and licence). The server sends the file with the part (catalog.get's files.model3d), and the bench draws the model in place of the body it builds, its origin on the part's first pin. The Bourns 3296W trimmers and the buzzer use KiCad's models (CC-BY-SA 4.0 with KiCad's design exception, each a separate file with its licence, ADR-029).

Evidence: models3d.test.ts (the legs of each model on its pins; a wrong turn fails; an unreadable file keeps the built body; Phong to physical materials) and the gallery. KiCad's 2020 library has no model for the other parts the bench draws approximately (the G5LE relay, the D2F switch; for the Phoenix MC 3.81 mm parts it has the fixed header, not the plug the catalog part is), so none is used for them. Not yet: glTF models, and GPU instancing (parts share a model's geometry and materials, but each is drawn on its own).

Boards as boards (2026-10-30)

Stage 4 of the 3D plan has begun. Every board's PCB is built from what its artwork says:

  • the outline is the pcb path or the #pcb rounded rectangle: the Uno's chamfers and step, the DevKit's rounded corners;
  • the soldermask colour is the .pcb rule's fill, used for the underside;
  • the mounting holes are the .mount circles: the Uno's four, drilled through with plated barrels and rings.

The cut edge shows the glass-epoxy core, and the top is the artwork under a clearcoated mask. Evidence: board-artwork.test.ts (the Uno's outline, mask and 3.2 mm holes read from its real artwork; the body's extents and barrels) and the gallery. Not yet: copper traces under the mask (the artworks are pictures, not layers), and holes on boards whose artwork does not mark them.

Packages at their standard dimensions (2026-10-30)

Stage 2 of the 3D plan is under way. A package module (ui/packages/bench/src/packages3d.ts) draws parts from their standards' dimension tables, as KiCad's generator does:

  • DIPs per JEDEC MS-001/MS-011, the 28-pin per Microchip's 28P3: drafted bodies, pin-1 notch and dimple, stamped leads whose tips land on the pins;
  • DIP sockets;
  • 2.54 mm socket strips with their openings and contacts, and pin strips;
  • the USB-B (USB 2.0 mouth and tongue), micro-USB and USB-C receptacles;
  • a 2.1 mm barrel jack;
  • the 6 mm tactile switch;
  • HC-49/US crystals;
  • QFP and QFN bodies sized by pin count (MS-026, MO-220);
  • radial electrolytics with the stripe over the negative lead;
  • an RF module (the ESP32-C3-MINI-1's shield can and antenna area), a new board-feature kind.

Evidence: packages3d.test.ts (16 tests: the standards' nominal dimensions, every DIP lead's tip on its pin, outlines, which way mouths face, the stripe's side) and the gallery's close-ups. Not yet: SOIC/TSSOP and chip passives on modules, gull-wing bends on QFP leads (they lie flat), and models from files (stage 3).

The 3D bench as an inspection viewer (2026-10-30)

The owner asked for the 3D bench and world to reach Proteus's, KiCad's and Altium's level. The plan compares the bench with their 3D views and sets seven stages: inspection, JEDEC package geometry, glTF model assets, the board's stack-up, CAD interaction, the world, and performance. Stage 1 is built (ui/packages/bench, the bench's toolbar):

  • standard views on KiCad's keys, and an orthographic camera;
  • a measure tool, snapping to pins and holes;
  • a section plane on any axis, and a height plane that lists the parts through it (the Proteus height check);
  • layer visibility;
  • a quality render, with ambient occlusion and bloom only on what emits light, falling back to draft when frames miss 60 Hz;
  • a PNG still at 2× or 4×, and GLB export (glTF binary in metres, a node per part).

Evidence: inspect.test.ts (12 tests: view framing, measurement, section, height plane) and bench-tools.spec.ts. The spec measures R2's legs as 10.16 mm (4 × 2.54 mm) through the pointer, checks that the GLB file starts with glTF, and checks that no tool edits the project. Not yet:

  • real package geometry, model files and the board's copper, mask and silkscreen (stages 2 to 4), which is where the bench still looks least like a professional tool;
  • capped section faces;
  • STEP export (no permissively licensed B-rep kernel);
  • frame times measured against ADR-028.

I2C parts' captures (2026-10-30)

replay_captures.py now replays I2C captures: the master's half of SCL and SDA is played back at the captured times, SDA is released in the slots the part drives, and every bit it drove (each ACK or its absence, each bit read from it) is compared one for one. Another part on the bus is played back as captured. 19 sigrok captures of a real Microchip 24AA025UID (public domain, i2c/eeprom_24xx/microchip_24aa025uid) match through the new emblink/eeprom_24aa025uid, about 20,000 bits in all:

  • byte writes 1 to 6 ms apart, where the part does not answer during its write cycle (between 3.10 and 4.03 ms on this part; the model takes 3.5 ms, the datasheet gives a 5 ms maximum);
  • page writes of 8 to 48 bytes, wrapping at 16;
  • reads of the whole array, ending in the protected half's codes and serial number.

With a 5 ms or 3 ms write cycle, or the 24C02's 8-byte pages, the same captures fail, as they should. Two captures of a DS3231 module (i2c/rtc_dallas_ds3231) match through emblink/ds3231 with its new start: the ACKs, the time and temperature reads. Three reads show registers set before the capture, so only their ACKs are compared. The DS1307's captures are sampled too coarsely (200 and 500 kHz) to replay. Not yet: SPI parts (MAX7219 and others) and the remaining I2C sensors in sigrok-dumps (BH1750, SHT3x, ...).

Real parts' captures (2026-10-29)

The first evidence from real hardware beyond datasheets: 15 sigrok captures of a real AM2302 (public domain, sigrok-dumps am230x/am2302 at 0ad13477; about 230 reads, starts from 100 us to 20 ms, reads 71 ms to 2.3 s apart) are replayed into emblink/dht22 by tools/verify/replay_captures.py (real_captures test). The host's starts are played back at the captured times; the model's answers are decoded and compared with the real part's: answered or not for every read from the real part's first answer, each timed phase's mean within 2 us (6 us for the response's end, which a host that drives the line after its start masks), the checksums. All 15 match. The comparison found the model's datasheet timing 3-14 us off the real part's, a byte-boundary delay the datasheet does not show, a start threshold of 800 us where the part answers from about 400 us, and no busy time where the part ignores reads for about 0.4 s after one; all are now modelled as measured. Four sibling parts' captures (AM2303, AM2320, AM2321, AM2322) agree with the AM2302's times within 2 us; they are not part of the suite. A capture of two real DS18B20s on one bus (sigrok-dumps onewire/ds18b20) is replayed the same way through emblink/ds18b20 twice over: the four ROM searches, 512 bits the parts sent, match bit for bit (the two ROM codes and their CRCs among them); the presence (27.4 us after the reset, 120.1 us) and a read 0 (28.4 us) now match within 0.4 us where the model had the datasheet's 30 us. The capture's scratchpad reads all come before a conversion could finish, so they show what the parts held before it and are not compared. Not yet: captures of other parts (sigrok-dumps holds DS3231, MAX7219, BH1750, SHT3x and more, each needing its protocol's decoder in the harness) and of the boards themselves (a capture kit for an Uno and a NUCLEO is described in tests/captures/README.md).

Diagnosis, documentation and planning commands (2026-10-28)

Issues #86-#102, from the same project. Evidence: test_diagnose (a stale image warned and a fresh one not; --dump-regs decoding USART2; the circuit profile; perf.island_size for a 4.7 kOhm pull-up from the Uno's UART TX to 5 V, and not for the PWM line that drives an LED; export svg of a sheet and of an SSD1306; plan on the NUCLEO-F446RE checked against the F446's alternate-function table, no pin twice, clear of LD2 and SWD, and refused on the ATmega328P, which has no such table); test_json's test_match and test_session's diagnostics rules; the MFRC522's card-swap fixture; and tests/vendor/freertos, which builds the unmodified FreeRTOS kernel V11.1.0 and checks every task's state, wait (delay, notification index 1 for ever, the rxq queue), pending notification and stack high-water mark, with scenario rtos assertions sampled each millisecond. mcu.irq_storm was checked by hand (INT0 held low on the Uno: "INT0 (exception 1) entered 401 times in 787 us"). Not done: a regulated rail as a boundary between analog islands (#86 warns instead), SMP and 16-bit FreeRTOS ports, live symbol states in exported SVG, pin plans for MCUs without an alternate-function table.

Diagnostics found at load, probes and images (2026-10-28)

Issues #80-#85, from a FreeRTOS access-control firmware on the NUCLEO-F446RE. The STM32 I2C model keeps the SR1-then-SR2 ADDR sequence across a CR1 write (the reference manual's single-byte receive clears ACK in between) and clears BTF and TXE when a START completes in transmission; test_stm32f4's test_i2c_master now runs the one-byte receive and a repeated START after BTF (14 failures on the old model, none now). Diagnostics carry the phase they were raised in and a run's reset keeps the load's, so --json reports, scenario reports and diagnostics.forbid see the netlist checks (test_session's test_load_diagnostics). embsim run stops at load when a firmware image cannot be read (--allow-no-image to run without it); a probe with an unknown kind or target fails the load with a suggestion; embsim validate reports the netlist checks and the circuit settled at its first instant. Not yet: checking that an output: or device: probe's quantity exists on its part.

Live schematic milestone (2026-10-26)

Branch feat/live-schematic-workbench makes the schematic the primary Run surface and adds native symbol bindings, on-sheet controls, accepted-time electrical LED exposure and ideal differential voltage leads. Generic bicolor and 8×8 matrices reuse independent junctions. Existing LCD/OLED, serial displays, segments and bargraphs now show model outputs on their symbols. Floating-common functional segments/bargraphs stay dark. Attached repeated labels complete drawing traces.

Local checks pass 49 native CTest targets, 274 UI unit tests, all 31 browser workflows, strict validation of 899 JSON descriptions/projects/fixtures and the native live-schematic browser acceptance. The live circuit passes ten assertions; the fully routed firmware RGB example retains all 39 assertions. Analog tests include 1 kHz independent 25/50/75% RGB exposure, repeated reads and reset. Actual native captures are in the gallery.

See implementation, evidence and remaining release gates and the live acceptance circuit. This is not completion of all surveyed capabilities, full device qualification, a Proteus-parity claim or a 1.0 release. Editable project hierarchy, triggered capture, advanced analyses and managed engineering workflows still require the explicit gates in that document. No new 3D development is included.

Wired instrument loading and electrical feedback (2026-10-26)

Branch feat/loaded-instruments adds generic configurable wired voltmeter, ammeter, scope-input and function-generator equivalents. Their finite input, shunt and output impedances enter the native solve; scope capacitance reuses the adaptive integrator. The loading bench checks 13 independent analytic targets; twelve component fixtures exercise loading, polarity and transient behavior. Local verification passes 49 native CTest targets, 12 instrument fixtures / 37 assertions, and the 13-assertion loading and 3-assertion deliberate-fault scenarios. Native tests check zero/one/two-lead construction without implicit grounding, current conservation, reset, refined RC convergence, digital conflict clearing and loaded opposing drivers. Protocol checks verify current contention and receiver identities for digital and mixed nets.

The Run panel shows impedance, lead nets and actual readings with locate/trace actions. Selected nets expose every terminal, junction and label. Pin names and live states remain horizontal through rotation. Live input warnings distinguish Z, X and opposing known drives, and locate their nets; unwired declared digital inputs without declared pulls also produce structural warnings. A zero analog voltage is not treated as proof of floating.

See the instrument contract and limits and interactive loading bench. These are linear equivalent circuits, not commercial instrument accuracy, bandwidth, protection, noise, thermal/damage or earth/chassis qualification. Ideal observation probes remain available alongside the explicitly wired loads.

Firmware-driven RGB and waveform measurements (2026-10-26)

Branch feat/indicator-pwm-evidence extends the named indicators with an ESP32-C3-DevKitM-1 circuit booted from a normal flash image through the ROM. Firmware programs LEDC and polls a physical MODE button; 39 assertions check 1 kHz at 25/50/75% duty, off/full-on/return transitions, mean/RMS currents and finite GPIO voltage drop against independent source-derived bounds. Scalar MCU resistance/slew settings now initialize base GPIO models; the example uses the declared 20 Ω driver instead of the generic 25 Ω fallback. This linear driver is representative and does not qualify MCU drive-strength or process corners.

CLI and workbench share time-weighted sample-and-hold mean/RMS/digital duty semantics, rejecting missing coverage and unknown/nonfinite intervals. Reports retain measurement/window identity and units. The scenario editor exposes these checks; scope/logic strips show RMS, duty and coverage. Native probe metadata preserves declared units/sample rates, and the scope separates voltage/current groups on its single vertical axis. Same-time waveform events retain their original timestamps.

Local verification passes all 48 native CTest targets, 249 UI unit tests and all 30 browser workflows. The CLI measurement contract checks 22 valid/invalid assertions. Repeating the firmware circuit at doubled capture rates passes its 39 assertions and agrees within 1 nA for measured mean/RMS currents and 0.001 of duty fraction. These are numerical circuit checks, not real-device accuracy. Native streaming checks also cover bounded 30,001-sample delivery, eviction of unsent versus already delivered history, constant-signal watermarks and restart. The workbench does not extrapolate a partial delivered chunk to the engine clock. The selected advance interval is shared by the toolbar, F7 and command palette. PWM evidence and limits and the rebuildable example explain the source bounds, sampling, raw-image analysis limits and unsupported effects. Thermal/charge/optical behavior remains open; configurable physical instrument loading follows in the milestone above; the 3D emitter still shows instantaneous observations and can alias PWM.

First named indicator evidence batch (2026-10-26)

Branch feat/qualified-indicators builds on the circuit-construction milestone. It adds WP7113ID and WP154A4SUREQBFZGC with source-backed pin maps and body envelopes and a checked 25 °C, 2–20 mA typical DC curve envelope. The latter uses independent RGB die parameters and the manufacturer's R/COM/B/G order at 1.27 mm pitch. The library and inspector expose the evidence scope. This is not full manufacturer corner, optical, thermal, damage, transient or mechanical qualification. Numeric LED body dimensions replace the generic dome envelope for these exact entries; source lead forming is not automatically manufactured.

Native indicator terminal mapping now preserves open leads as floating private nodes. Optional channel overrides inherit generic global parameters, and mixed zero/nonzero series resistance allocates only active internal rows. Source-point holdouts, loaded 3.3/5 V circuits and a physical-switch named RGB example exercise those contracts. Indicator source/evidence methodology records reproduction, fixtures and exclusions. Further named families precede realistically loaded instruments.

Local verification passes all 45 native CTest targets, 73 LED/RGB fixtures with 354 assertions, and the named RGB example's 28 assertions. The UI passes 241 unit tests and all 29 browser workflows, typecheck, lint and the production build. Both exact source PDFs reproduce the stored plot samples. Native captures show unequal red/blue currents and the evidence panel without engine diagnostics or browser errors. These checks establish the declared nominal DC envelope and integration, not the excluded device behavior.

Circuit construction and live RGB indication (2026-10-25)

Branch feat/circuit-construction builds on the workspace milestone. It adds existing-jumper selection, appearance and route editing, atomic reconnection, shared net/strip tracing, and native load/commit plus Python validation of direct wire invariants. Appearance-only transactions preserve the clock and probes. RGB electrical behavior uses three native junctions with external current limiting; functional mode requires a known common return. The 3D emitter consumes engine color/luminance instead of an independent animation. The switch-driven RGB acceptance circuit visits every mix and off, with 28 assertions; isolated LED/RGB fixtures execute 143 assertions across 30 circuits. These are generic model checks, not manufacturer qualification or an expanded IC support claim.

Construction contract and evidence and bench instructions state the controls and limits. Local checks pass all 45 native targets, 238 UI unit tests, 134 validator tests and 819 strict schema/catalog files. Native RGB captures show engine-observed magenta and off without browser errors. Subsequent work prioritizes qualified named component families before loaded instruments. Native pose-dependent component-leg import occupancy, an external ESP32-C3 firmware/PWM RGB circuit, optical calibration and full mechanical qualification remain open.

Responsive workspace and deferred bench loading (2026-10-25)

Branch ui/workspace-layout, based on main 896e4f0, separates the project menu, perspective navigation and utilities from the simulation controls. Long project names truncate within their menu instead of intercepting navigation. The shell fits compact windows; dock minima scale only when space is insufficient, retain saved proportions/fold choices, and restore them as space returns. Split resizing starts from the displayed pane edges. Status details remain keyboard-scrollable. The schematic ribbon uses a more compact height and stays out of Bench view.

The pure bench model is separate from the optional 3D renderer. Schematic startup does not request the renderer; loading retains keyboard selection and a later choice of 2D. Asset failure retains 2D and offers a fresh-page reload, separately from in-place context-loss retry. The initial JS entry changes from 1,550.42 to 909.17 kB (estimated gzip 466.36 to 300.17 kB); 640.97 kB is deferred until 3D is requested. Frame-time and wall-clock startup qualification remain open.

Workspace behavior and limits, bundle evidence and the gallery record the scope. Local typecheck, lint, production build, 232 unit tests across 49 files, all 27 browser workflows, the affected follow-up workflows, 790 schema/catalog files and documentation integrity pass. A fresh GCC Debug CLI build validates the Uno project and serves its deferred renderer without browser page errors. Hosted platform checks are recorded on the milestone PR; these are client viewing/layout changes, not new simulation models or hardware qualification.

Named surface-mount package milestone

Branch feat/named-package-bodies adds reusable SOT-23 and SOT-223 procedural bodies. BSS138 and LM1117IMP-3.3 use reviewed manufacturer outlines and their canonical terminal identities. BAT54 uses a clearly marked reference family outline; its manufacturer-source gap remains open. Surface-mount leads cannot become breadboard insertions through top-down overlap. Close-up labels follow body bounds. These are representative visual bodies, not PCB land patterns, soldering support or electrical-model qualification. LM1117's rendered output tab shares OUT2 and is not independently wireable.

The package evidence records sources, dimensions and omissions; native captures inspect isolated parts. Local typecheck, lint, production build, 221 UI tests across 47 files and all 40 native CTest targets pass. Hosted checks and browser results are recorded on the milestone PR.

Physical assembly authoring milestone

Branch feat/bench-assembly builds on the inspection milestone. Every proposed leg lists its hole, occupancy owner or unseated state; keyboard proposals draw viewing-aid rings on the native bench. Workbench insertion and direct-hole jumper authoring reserve occupied holes while allowing another hole on the same strip. Rejected placement leaves the project untouched. Numeric bench placement is independent from schematic coordinates. Breadboard moves and quarter turns carry inserted parts by a shared rigid transform, preserving hole IDs, nets and undo. Raised board headers no longer become inferred breadboard insertions from 2D overlap. A completed asynchronous breadboard placement preserves a later user selection; a browser regression dispatches both intents before the placement promise settles.

These are client authoring guards, not a native loader/mechanical qualification. Partial insertions and abstract component-pin lead connections remain supported; imported conflicts are not automatically certified or repaired. Jumper curves update on commit rather than continuously following a dragged assembly. Per-leg, occupied-hole, batch-swap, all-quarter-turn and mutation-atomicity fixtures cover these boundaries. Native GCC Debug passes all 40 CTest targets after integrating the world/sensor merge. UI/browser results are recorded on the milestone PR; native Uno previews show rejected and free-strip insertion.

Physical bench inspection and wiring milestone

Branch feat/bench-inspection develops the merged 3D bench rather than replacing it. The bench targets projected contacts, names source/destination endpoints, rejects ambiguous neighboring contacts, validates typed terminals, and avoids duplicate/reversed jumpers. Pending wire/placement gestures cancel on Escape, pointer cancellation/capture loss, focus/visibility loss and tool/edit/live-mode changes; interrupted button holds send a release. Selection focus/top cameras, paper/graphite/mat surfaces, label modes, notes and a foldable keyboard list make inspection configurable. The list stacks below narrow scenes. Focus canvas exposes the existing side-panel focus mode directly from the bench. Renderer failure or context loss selects an explained 2D fallback with retry.

Board bodies, contact positions and renderer pin heights share thickness, standoff and header-style data. Selected-part geometry labels identify catalog dimensions, artwork anchors or approximate package geometry, without a qualification claim. Generic lead anchors remain approximate, and picking ignores the owning body when checking occlusion; it is not a mechanical accessibility/collision validator. GLB/STEP import, all-catalog qualification, complete label occlusion and measured ADR-028 rendering budgets remain outstanding.

Local UI validation passes typecheck, lint, production build, 212 tests across 46 files and all 17 Playwright workflows. Hosted CI results are recorded on this milestone's pull request. Local GCC Debug validation passes all 39 CTest targets, including native bench and protocol regressions; native-server Uno captures are in the gallery. The new browser regressions cover endpoint cancel/commit/exact undo, interrupted live-button holds, appearance persistence, compact keyboard-list access and renderer context-loss recovery. The button checks use the demo engine; the screenshots use embsim serve and the Uno project.

Schematic graphics and interaction milestone

Branch schematic/visual-interaction, based on merged PR #34 (333f091), separates idle wire color from component strokes, strengthens selection feedback, renders hollow pin sockets and adds pencil/grab/grabbing cursor cues. Reference/name/value annotations include effective catalog defaults and SI units, with deterministic candidate placement and a compact option. Device appearance preferences include wire palette and label detail. Navigation no longer hides pins and annotations. Candidate placement reduces collisions; it does not guarantee an overlap-free dense drawing or move electrical geometry.

Local validation passes 149 UI tests across 34 files, typecheck, lint and production build; 36 repeated browser workflows plus three focused visual checks; and the real-engine schematic regression, including direct drawing, exact undo, track editing and group operations. The visual checks cover selected wires during simulation, hollow sockets, pencil/grab cursors, catalog defaults, persistent color and label settings, and visible pins/details during navigation. Native light/dark, terminal-detail and compact screenshots are in the gallery. The first hosted macOS browser run exposed immediate assertions before selection color transitions and duplicate selection completion. The browser checks now wait for the resulting color and selected duplicate before continuing. Hosted platform validation is pending for this correction.

Circuit organization milestone

Branch schematic/circuit-organization, based on merged PR #31 (322817a), adds persistent flat groups, selectable canvas outlines, an object browser, native placement locks and top-level inventory export. Group assignment, rename, removal and lock changes use transactional history; instance deletion prunes groups. Locked parts remain fixed obstacles in automatic placement. Direct transforms refuse mixed locked selections. Complete copied component groups remap identities and unlock copies. Export aggregates exact explicit model/version/parameter data, without flattening boards or qualifying a purchasing BOM. ADR-025 is proposed.

Local verification: 146 UI tests across 33 files; typecheck, lint and production build; 33 Chromium browser workflows (11 repeated three times); the real-engine browser regression including groups, lock-safe dragging, undo and themes; native session organization checks and protocol save/reload regression; 552 schema/catalog files and documentation integrity all pass. All 36 native CTest entries pass (90.71 seconds); the local firmware-build wrapper explicitly skips because no supported cross compiler is installed. The hosted matrix exercises compiler and platform coverage. Native screenshots are in the gallery. Each MCU's peripherals, modelled or not, are tabled in coverage.md (generated; the coverage_tables test fails when it is stale). The first hosted macOS browser run caught a focus/drag race: Objects navigation scheduled viewport focus after the test had read its pointer coordinates. Direct navigation now focuses synchronously unless a preview must first be discarded; the drag regression verifies a stable unobscured header before reading coordinates. The corrected organization workflow passes 10 consecutive local browser runs; typecheck, lint and production build pass. Hosted cross-platform validation is pending for this correction.

Schematic cross-platform CI corrections

The authoring PR's first hosted run exposed an extensionless-import collision: SelectionProperties.tsx and selectionProperties.ts resolved to the helper on case-insensitive filesystems. The helper is now parameterEditing.ts, and the repository policy checks ambiguous source-module paths with regression fixtures. An unchanged delayed server refresh also invalidated active wire drafts; refresh now retains revision identity when canonical project content is unchanged, while real changes still invalidate stale drafts. The selection browser assertion now checks the logical selection rather than counting only viewport-mounted symbols. Failed browser jobs retain screenshots and traces for diagnosis.

Local verification: 138 UI tests across 32 files, typecheck, lint and build pass; source-path policy and its fixtures pass. The hosted cross-platform rerun passed all 17 checks, including the merge gate: run 38965461112.

Schematic authoring and repair milestone

Based on merged main 2183be8 (including PR #29's native peripheral changes), schematic/authoring-workbench integrates existing-track segment repair, exact part/board placement, group offsets, shared-parameter batch editing, contextual actions, net drawing/terminal controls and navigable structural/drawing checks. Track reshaping previews before committing, preserves original endpoints and same-net contacts, cancels without history and commits geometry in one undo step. Clearing a drawing keeps the net; terminal disconnection is a separate action.

The check report runs in a cancellable revision-bound worker with timeout/error recovery. It identifies structure and drawing problems, provides filters and location/repair actions, and treats unused pins as information. Declared hidden terminals are distinguished from invalid references. This does not implement full electrical rules, physical clearances, persistent routing constraints or large-sheet qualification. ADR-024 is proposed for review.

Editing rejects stale/concurrent snapshots and preserves history entries when undo/redo fails. Placement no-ops preserve manual tracks. Foreign-net tracks no longer follow a coincident pin when a part moves or is removed. Focus-mode layout namespaces restore panel order/weights without remounting the canvas.

Evidence on the integrated tree:

  • 136 UI tests across 31 files pass, including worker stale-result/failure/retry/ timeout cases, junction-preserving track reshaping, hidden terminals, batch parameter validation, edit guards, failed history recovery and dock restoration.
  • Typecheck, lint and production build pass. Ten Chromium workflows pass: pointer and numeric track edits, Escape/pointer cancellation, contextual keyboard actions, exact placement, mixed batch properties, check-to-route repair, terminal disconnection, manual bends, previous layout/background and run flows.
  • The native engine rebuilds on current main. All 35 CTest entries report success in 101.55 seconds; firmware_build explicitly skips compilation because no supported firmware cross-toolchain is installed (34 entries perform checks).
  • The expanded real-server browser regression passes preview/apply/undo/redo, connection/auto-arrangement, explicit bends, layout-only segment repair, native batch properties and geometry-clear/check navigation with exact project restoration. Light, dark and compact views are captured in the gallery.
  • Documentation integrity checks 110 documents and 103 requirements without problems; banned-construct checks pass. Hosted platform/desktop checks are pending, and no new macOS/Windows execution is claimed.

Manual schematic wire authoring

The schematic accepts multiple orthogonal wire legs, with visible committed waypoints and a live final leg. Space flips the live elbow, Backspace/Delete removes a leg, and Escape cancels without a project mutation. Arrows and Enter support keyboard routing. Explicit routing takes precedence over smart wiring and auto-arrange when the connection is completed; the entire connection is one undoable edit. These waypoints are geometry, not persistent routing constraints; a later automatic layout may replace them, and no clearance validation is claimed.

Evidence on schematic/manual-wire-routing, based on merged main 977957e: 115 UI tests, typecheck, lint and production build pass. Six Chromium smoke workflows pass, including pointer bends, elbow flipping, backtracking, keyboard bends, cancellation and undo with auto-arrange both enabled and disabled. The real native-server schematic regression also passes: unfinished bends do not mutate the project, the completed bend survives serialization, components remain in place and one Undo restores the complete previous project. Documentation integrity checks 109 documents and 100 requirements with no problems. Native code is unchanged; no new native build or full native test run is claimed for this UI change.

Continuous canvas appearance and reloads

A viewport-covering, world-anchored background replaces the finite SVG sheet surface that exposed a gray strip after panning. Engineering, line, dot, cross and plain patterns have paper, warm, graphite and blueprint palettes in both themes. Spacing, line/dot weight and contrast are adjustable. Validated local preferences persist through reloads and apply to Design, inside and Run views; editing snap and electrical data remain independent. System typography, rounded chrome and restrained shadows refine the schematic workspace.

Reload testing exposed a native-server stall while the old WebSocket remained attached. Auxiliary HTTP requests are now serviced between session polls without replacing its notification target. Host/origin restrictions remain enforced; a second session upgrade returns HTTP 409 and incomplete auxiliary headers have a 250 ms deadline. The regression covers asset delivery while the circuit is running, time advancement, authority rejection, busy upgrades and partial requests. ADR-022 records the proposed decision for review.

Integrated main 067852b (including the Pico SDK work) on Linux, GCC 14.2, Python 3.12 and Node 24. Observed locally:

  • All 34 development CTest outcomes pass. The firmware-build wrapper explicitly skips compilation without a supported toolchain; other targets execute.
  • The affected host, HTTP asset and protocol tests pass under Address/undefined- behavior sanitizers (3/3). This is targeted sanitizer evidence, not a claim that the entire sanitizer suite was rerun.
  • All 114 UI tests pass; typecheck, lint and production build pass. All four Playwright smoke tests pass, including preference persistence and pan coverage.
  • The new native-engine browser check passes for five patterns, four palettes, size/contrast/spacing changes, three consecutive reloads, reset, both themes and 1024×700. Pixels sampled across a panned plain canvas match the selected surface color; the background fills the viewport without a finite-sheet seam.
  • The existing native-engine schematic/undo and library/live-input/waveform browser regressions also pass without page errors.
  • All 552 JSON files validate; documentation checks 108 documents and 99 requirements with no problems. Repository policy checks pass.

The gallery contains original screenshots. Remote platform and installer checks for this branch remain to be observed.

Schematic Studio

The Design perspective now includes connected auto-placement, route-only planning, whole-sheet and selected scopes, spacing/direction options, reviewable worker previews, layout-only application and single-step undo. Placement avoids existing symbols; an opt-in connect-then-arrange mode combines connectivity and layout in one edit. Smart wire previews and transform rerouting use exact pin anchors, obstacle clearance and foreign-net track reservations. Missing geometry remains an airwire with a warning; disconnected drawn clusters are counted correctly.

The ribbon adds alignment/distribution, component/net search, net spotlight, selection focus, side-panel focus mode and display controls. The canvas adds a navigator and grid-compatible magnetic drag guides. The user guide documents heuristics and limits, including unchanged label/bus positions, allowed crossings and bounded planning searches. The desktop worker policy permits the bundled worker; installers still require platform CI evidence.

Integrated with main baf3f49 (including the vendor-firmware/analog-reference work) on Linux, GCC 14.2, Python 3.12 and Node 24. Observed on this branch:

  • All 33 development CTest outcomes pass on the integrated revision. The firmware-build wrapper explicitly skips compilation because no supported firmware toolchain is installed; the other targets execute, including replay, analysis, catalog assertions, multiboard and headless examples.
  • All 108 workbench tests pass, including layout determinism, obstacle/track routing, transformed anchors, free placement, disconnected airwire clusters, magnetic guides, presentation-only application and stale-preview rejection.
  • TypeScript, lint and the production build pass. The three Playwright smoke tests pass, including the new worker-preview/apply/undo/focus-mode workflow; this test is included in the existing three-platform smoke job.
  • The native-engine schematic browser regression passes: Preview sends no transactions; Apply changes only layout and does not restart the engine; Undo/Redo restore geometry; connect-then-arrange undoes as one edit. Finder, display controls, light/dark themes and 1024×700 are exercised without page errors. The existing real-engine library/live-control regression also passes.
  • All 552 JSON files validate with no errors/warnings; documentation integrity checks 107 documents and 97 requirements with no problems. Policy checks pass.

This branch's remote platform/installer checks remain to be observed. Local Chromium evidence does not establish native webview behavior on every platform.

Scenario editor hardening

Integrated with main 7ddeafb after PR #14. The Verify editor checks draft timing, assertion IDs, input identifiers and expectation fields before Run or Save. Invalid JSON remains visible and blocks execution instead of silently using an earlier expectation. Edits clear previous assertion badges. Project binding and model-specific value validation remain engine responsibilities. This change does not qualify electrical models or complete the remaining release gates.

Observed locally: 92 UI tests pass, including editor correction and validation regressions; TypeScript checks, lint and the production build pass. Documentation integrity checks 103 documents and 96 requirements with no problems. Native code is unchanged. This branch still needs its own platform CI results.

Release hardening

The 1.0 readiness checklist tracks release gates separately from implementation milestones. Debugger board selection now clears inspected state and rejects responses from an earlier selection; delayed and overlapping request regressions are covered in the workbench store tests. Observed on this branch: all 86 UI tests, TypeScript checks, lint and the production build pass. Documentation integrity checks 103 documents and 95 requirements with no problems. Native code is unchanged; native and platform CI results have not been rerun locally for this slice. PR #14 was subsequently observed with all 17 remote checks passing, including platform builds, desktop and browser smoke jobs. This is not a declaration of 1.0 readiness.

Implemented subset

Area Current implementation Evidence and limits
Design Architecture 01 to 09 (ADR-001 to ADR-021 and ADR-023 accepted; ADR-022/024 proposed), SPEC-001 to SPEC-014, 103 requirements Reviewed documents; tools/docs/check_docs.py passes
Repository CMake presets, Makefile wrapper, CI matrix, documentation and policy workflows, templates, ruleset JSON, policy and banned-construct checkers Local runs of the checkers; remote workflow results are recorded here when observed
Core: scheduler and time Rational clocks, class-ordered event heap, delta-cycle bound, cancellation by generation (SPEC-002) test_sched: ordering, cancellation, overflow, limits, 72 MHz and 32.768 kHz clocks exact over 10^9 edges
Core: nets and digital engine Pin models and logic families, four-value resolution with strengths, contention and floating diagnostics, inertial delays, islands and bridges, the model API; gates, flip-flop, sources, pulls, transmission-gate switches, indicator, probe, UART virtual terminal (SPEC-003) test_engine: resolution, floating inputs, gate timing, inertial pulses, clock, switch, UART loopback
Core: analog engine MNA per island, Newton-Raphson, deterministic dense LU, gmin and source stepping, trapezoidal with LTE control and backward-Euler restarts, breakpoints, bridge crossings bisected to the configured resolution, steady islands quiet (not stepped until touched or a breakpoint); resistor, capacitor, inductor, V and I sources (dc, pulse, sine, pwl, exp), switch with bounce, potentiometer, diode, LED, Zener, NPN/PNP, NMOS/PMOS, op-amp, regulator, pull (SPEC-004) test_analog: 1224 checks (including multi-island stepping and regulator rails) and seven analytic fixtures under GCC and Clang, each also against ngspice 42's solution of the same netlist (ngspice.json, tools/analog/ngspice_fixture.py --check in CI): operating points agree to seven digits, transients within 6.4 mV (0.21 %); BDF2, junction capacitances, sparse solver not implemented
Core: models and catalog loading Registry of primitives with merged digital and electrical tiers; libraries by path; component instantiation with parameter validation, presets, $param pin models and composite expansion through ports; boards as composites whose MCU runs firmware (SPEC-005, 006, 007 subset); user libraries from $EMBSIM_LIBRARIES or the user data directory test_session: temporary library, loader, inputs, snapshots, scenario assertions, determinism across sessions, composite expansion, bad project
Lua model tier Lua 5.4.7 vendored (third_party/lua, MIT), one state per instance with its own environment, text chunks only, a 1,000,000-instruction budget per evaluation and a 64 MiB memory cap; ctx with pins (value, level, voltage), drive, release, timers, inputs, diagnostics and print; I2C and SPI slaves decoded in C (ctx.bus.i2c_slave, ctx.bus.spi_slave); on_input, on_time, on_set, observe; errors and budget overruns stop the instance until reset (SPEC-013 §2) test_lua: a counter, determinism across runs, faults and the budget, I2C and SPI slaves, syntax errors; 38 catalog parts are Lua models and pass their fixtures
Component SDK and validation embsim catalog validate [DIR] [--library] [--json] in the engine: every item instantiated under each fidelity policy it declares and its fixtures run as project and scenario, items reported ok, broken or invalid; catalog new component|board NAME [--lua] writes a template that validates as written; catalog install DIR|ARCHIVE.zip|URL [--to] [--force]: a directory, a zip archive (stored and deflated entries, the inflater and the reader EmbSIM's own) or a URL fetched with curl, unpacked into a staging directory that is removed after (SPEC-014 §3 to §6) catalog_sdk (tests/protocol/test_sdk.py): a Lua component and a board from the templates validate, install into a user library and are listed from it through $EMBSIM_LIBRARIES; the same library zipped deflated with a top directory, stored at its top, at fast compression and served over HTTP installs byte for byte the same files; an archive with an entry outside the library, a corrupt one (its CRC-32) and a file that is not one are refused, and no staging directory is left; a part whose fixture fails is reported broken and install refuses it; test_zip (stored, fixed-code and dynamic-code streams from zlib, an archive, and every truncation and one-byte change of each refused or decoded in bounds under ASan and UBSan)
Importers tools/importers/rtos2board.py (EmbLinkRTOS board YAML), dts2board.py (DeviceTree source, its own parser), kicad2project.py (KiCad netlist to a laid-out project), sharing boardgen.py; svd2regs.py (SPEC-014 §7); edc2regs.py (a PIC32's or a PIC24's EDC from Microchip's device pack, with a PIC32's CLR/SET/INV registers and vectors, a PIC24's PPS functions and configuration words, pin functions and the package) importers (tools/test_importers.py): the boards they write validate and pass their power fixture; edc2regs.py on a made-up PIC32's and PIC24's EDC; examples/kicad-flasher is a KiCad netlist imported and run
Core: session and protocol Command path with virtual timestamps and the input log, probes (digital on change, analog and value at a rate, thresholded digital on analog nets), snapshots and topology, pacing slices, notifications, scenarios with assertions and the run report, project transactions (edits from the workbench: layout-only commits keep the run, circuit changes are checked then rebuild it) and project.save, the JSON-RPC method table over in-process, stdio and WebSocket (SPEC-008) test_session (in-process), tests/protocol/run_conformance.py (nine cases on stdio and WebSocket, transports compared), test_host (files, sockets, SHA-1, base64, frames)
MCU runtime Cortex-M3 core extracted from EmbCC (Thumb-2, NVIC, SCB, SysTick, DWT, FPU); on ARMv7-M, exception entry (12 cycles), return (12), tail-chaining (6) and late arrival timed as the Cortex-M4 TRM gives them at zero wait states (tests/unit/test_cm_timing.c; docs/engineering/timing-fidelity.md §4.1 lists what is not charged), with ARMv7E-M's DSP instructions for the Cortex-M4 (the parallel adds and subtracts, SEL, the saturating, packing and dual multiplies), and what an RTOS port relies on (SPEC-009 §3): the MPU on the parts that have one (PMSAv7 and PMSAv6, eight regions, subregions, the background region, HFNMIENA, MemManage with MMFAR), the default map's execute-never regions, LDRT and STRT, unprivileged access to the private peripheral bus refused, stacking and unstacking faults taken as derived exceptions, and lazy floating-point context stacking (LSPACT, FPCAR, FPDSCR), bus with bit-band and aliases, ELF and Intel HEX loaders, semihosting; decoded instructions kept per memory region's generation and bursts of instructions between the run's checks, and lazy device clocks on the STM32s (about 31 million instructions a second on a release build for a busy firmware at 180 MHz); register files from EmbSIM JSON (ADR-020); STM32F1 models: RCC, GPIO, AFIO, EXTI, USART, TIM (time base, and output compare and PWM on the AFIO pins), ADC1 and ADC2 (the regular group from the pins' voltages, at the ADC clock), SPI1 and SPI2 as masters or slaves (receive-only, bidirectional, MODF, CRC) and I2C1 and I2C2 as masters or slaves (10-bit addresses, stretching, arbitration, PEC, SMBus) on their pins, IWDG and WWDG, RCC_CSR's reset flags, the flash interface (stm32f1-flash: KEYR's unlock, halfword programming with PGERR, page and mass erase, WRPRTERR, the option bytes loaded into OBR and WRPR at reset, BSY for DS5319's 52.5 us and 20 ms with a program in the flash stalled), PWR; runs in quanta on the scheduler with pins as signal events (ADR-019); USART frames on the TX pin and decoded from the RX pin; NRST and BOOT0 (SPEC-009) test_mcu (16214 checks; the flash interface's keys, programming, erases, protection, option bytes and times among them): EmbCC's Blue Pill golden fixture with five documented USART timing deltas, the same output from a description converted from ST's SVD, serial input, a breakpoint-and-continue run equal to an uninterrupted one (MCU-006); 101 DSP and ARMv7-M instructions over 4096 operand pairs each give QEMU's mps2-an386 results and flags (dsp_differential, the expected hashes checked against QEMU in CI); 28 cases of the MPU, privilege, stacking faults and FP stacking print what QEMU's mps2-an386 prints (cm4_core_differential, tests/firmware/cm4-core, its expected output checked against QEMU in CI); examples/bluepill-button-led runs firmware built by Clang and by EmbCC; an application built with ST's unmodified STM32F1 HAL and CMSIS device files (their GCC startup and linker script, a CubeMX Makefile's flags, GCC 13.2 and newlib-nano) passes 7/7, in CI's linux-gcc job too: the HAL's clock tree to 72 MHz from HSE through the PLL, HAL_Delay on SysTick, EXTI0, TIM2's update interrupt and USART1 both ways; a second, adc_pwm, 6/6: the HAL's ADC calibrated at 12 MHz, polled and by its interrupt, TIM3's PWM at 1 kHz exactly, and the PWM's average through an RC low-pass read back at 0.8 and 2.5 V; a third, spi_i2c, 6/6: the HAL's SPI master at 2.25 MHz against the catalog's 25LC040 (WREN, WRITE, RDSR through its write cycle, READ) and its I2C master at 100 kHz against the 24C02 (Mem_Write, IsDeviceReady through the write cycle, Mem_Read of one, two and five bytes, an absent address); a fourth, flash, 9/9: the HAL's page erase in 20 ms and halfword in 52.5 us on the DWT's cycle counter, PGERR as HAL_FLASH_ERROR_PROG, the option bytes erased, Data0 programmed and loaded by HAL_FLASH_OB_Launch's reset (tests/vendor/stm32cube/run.py); test_mcu's TIM3 PWM edges to the cycle and an ADC conversion's 504 cycles and code
MCU runtime: AVR AVR5 core extracted from EmbCC (cycle-exact, SREG, the vector table, SLEEP), its state a parameter; ATmega328P models over the register file written from the datasheet: PORTB/C/D with pull-ups and PUD, INT0/INT1 and pin-change interrupts, Timer/Counter0, 1 and 2 in every waveform mode with double buffering and the OC pins switching at their clock, Timer/Counter1's input capture (ICP1 or the comparator, the noise canceler, ICR1 at the edge's clock), USART0 at its baud rate, the 10-bit ADC from the pins' voltages, the SPI master (modes 0 to 3, SPI2X, WCOL, SS's mode fault) on PB2 to PB5 and the TWI master (the datasheet's master statuses, repeated START, TWWC) open-drain on PC4 and PC5, the watchdog (time-outs on its 128 kHz oscillator, WDR, interrupt and system reset modes, the timed sequence, WDRF through its reset), the analog comparator (AIN0 or the bandgap against AIN1 or the ADC multiplexer's pin, its edges and vector, the crossing found in the analog solver), the EEPROM, the clock prescaler; the peripherals' clocks run lazily (owed cycles paid before the core touches a timed device, at the next event and before outside input) and a lone AVR with quiet islands runs 100 µs quanta with its UART frames queued on the TX pin (SPEC-009 §8); an AVR disassembler; DWARF with 2-byte addresses test_avr (1318 checks: flags, cycles, Timer0's interrupt, fast PWM's overflow flag clock by clock, a USART frame's cycles, ports, the ADC, the SPI's frames in loopback, its timing, modes, WCOL and mode fault, the TWI's START, a NACKed SLA+W, a repeated START, SLA+R and bytes ACKed and NACKed, STOP, TWWC, SCL's period and prescaler, the watchdog's time-out, timed sequence, both modes, WDR and its reset with WDRF, the comparator's ACO, ACI, edges, vector, bandgap, ACME, ACD and its thresholds on the pins, input capture's edges, noise canceler, ICR1 as TOP, the comparator as its source and its vector, the disassembler); examples/uno-blink-serial 7/7 with firmware built by clang and by EmbCC; Arduino sketches built with the unmodified ArduinoCore-avr (11b9130, avr-gcc 7.3 with the IDE's flags; Blink 924 bytes as the IDE reports) pass their scenarios, in CI's linux-gcc job too: Blink 4/4, a core tour 10/10 (delay, millis, analogRead, analogWrite on Timer0 and Timer1, attachInterrupt, Serial at 115200 both ways), and spi_wire 5/5: the core's SPI library at 4 MHz against the catalog's 25LC040 (WREN, WRITE, RDSR through its write cycle, READ; every SCK edge through D13's LED counted) and its Wire library against the 24C02 (a page write, NACKed polls, a repeated START into requestFrom at 100 and 400 kHz, an absent address), and watchdog 5/5: avr-libc's WDT interrupt waking the part from power-down four times, then wdt_enable left to time out twice, a boot count in .noinit surviving each reset, MCUSR's PORF then WDRF, and comparator 3/3: the comparator's interrupt times an RC network charged and discharged through 10 kOhm into 1 uF against 2.5 V, 6960 and 6956 us measured with micros() where R * C * ln 2 is 6949 us, and input_capture 4/4: Timer1's input capture measures analogWrite(3, 64) wired to ICP1, 32640 cycles a period every time (490.196 Hz) and 8192 high, as the datasheet's phase-correct PWM gives (tests/vendor/arduino/run.py, which builds the libraries a sketch includes); EmbCC's QEMU-refereed AVR fixtures not run here (no QEMU)
MCU runtime: RISC-V RV32IMAC core extracted from EmbCC (Zicsr, machine-mode traps, compressed instructions), its state a parameter, interrupt lines from the devices, WFI as sleep; physical memory protection (the part's entries, OFF, TOR, NA4 and NAPOT, locks binding machine mode, user mode and MPRV, partial matches failing); FE310-G002 models written from SiFive's manual: the CLINT (mtime at the 32.768 kHz RTC, exactly), the PLIC (priorities, threshold, claim and complete), the GPIO (interrupts, IOFs), the UARTs (FIFOs, watermarks), the PRCI (HFROSC, HFXOSC, PLL), the always-on domain's watchdog (key, scale, comparator, zerocmp, sticky interrupt, a chip reset the domain survives) and RTC, PWM0-2 (comparators, zerocmp, deglitch, sticky, one-shot, the channels on IOF1) and SPI1 and SPI2 (FIFOs, modes 0 to 3, csmode AUTO, HOLD and OFF, the delays, watermarks) on their pins; the RISC-V disassembler test_riscv (285 checks: ALU and divide cycles, stores at negative offsets, an ECALL trap, the CLINT interrupt at exactly one RTC second, a UART frame, the PLIC's reserved words, a locked NAPOT entry against machine mode's store, user mode with and without an entry, the RTC's compare at one second, the watchdog's key, zerocmp period and food, its reset and what survives it, the disassembler); examples/hifive1-blink 7/7 with firmware built by clang and by EmbCC; fourteen of SiFive's freedom-e-sdk examples, built with the unmodified freedom-metal library (the SDK's pinned 1cec4a2) and the HiFive1 Rev B's BSP by riscv64-unknown-elf-gcc 13.2 with picolibc, pass their scenarios (47 assertions), in CI's linux-gcc job too: hello, sifive-welcome (the RGB LED on the CLINT's timer), csr, uart-interrupt (through the PLIC), example-user-mode, minimal-boot, example-rtc, example-watchdog, example-pmp, timer-interrupt, software-interrupt, return-pass, example-pwm (PWM1 at 1 Hz on the RGB LED), example-spi (three frames on SPI1 with CS held) (tests/vendor/freedom-metal/run.py; an example's exit status printed by a wrapper around freedom-metal's metal_shutdown); example-i2c waits on I2C0, which is not modelled, and the PMU's sleep is not
MCU runtime: RP2040 Cortex-M0+ (Armv6-M) on both cores, interleaved on one clock with each core's NVIC, SysTick and event register (WFE, SEV), core 1 launched through its bootrom's FIFO handshake and powered off and on by the PSM; the register file converted from Raspberry Pi's RP2040.svd (BSD-3-Clause) on the part's bus rules (atomic XOR, set and clear aliases; byte writes across the word) with peripherals held in reset by RESETS; models extracted from EmbCC: the clocks (XOSC, ROSC, the PLLs, the generators, FC0) with clk_sys as the core's clock, PSM, the watchdog's microsecond tick and its reset, the timer's alarms, IO_BANK0 and the pads (function select, overrides, pulls, interrupts to each core), the SIO (GPIO, spinlocks; each core's CPUID, divider and FIFO, SIO_IRQ_PROC0/1), the PL011 UARTs timed at their divisor, the SSI with the Pico's flash; the PWM's slices (fractional divider, free-running and phase-correct, double-buffered CC and TOP, the wrap interrupt) on their pins and the ADC (clk_adc's 96 cycles a conversion, GPIO26-29 and the temperature sensor, START_MANY with DIV, round robin, the FIFO and its interrupt), the SPI masters (PL022: FIFOs, 4 to 16 bits in modes 0 to 3, CSn, loopback, overrun) and the I2C masters (DW_apb_i2c: the command FIFO with RESTART and STOP, open-drain SCL and SDA at HCNT and LCNT, the bus held between commands, aborts and their source) on their pins, written for EmbSIM; a bootrom stand-in that checks boot2's CRC, copies it to SRAM and enters it, and the bootrom's documented functions done by the host (ADR-021): the table lookup, the bit operations, memcpy and memset, the flash functions (erase and program with the W25Q16JV's times), reset_to_usb_boot, the float and double tables (version 3, correctly rounded arithmetic, the bootrom's conventions) test_rp2040 (1940 checks: the crossbar's contention, the striped banks, priority and the performance counters, SPI0's frames in loopback, its timing, FIFOs, overrun and modes, I2C0's NACKed address and its abort, a held bus kept through a disable and enable, a repeated START, the clear registers, a disable that lets the bus go; PWM slice 0's edges, wrap and buffered CC, the ADC's conversion time on clk_adc and none without it, its codes, round robin and FIFO, the boot through boot2 and a bad CRC, the aliases and byte writes, RESETS, PLL_SYS at 125 MHz measured by FC0, a timer alarm on the 1 µs tick, the divider, a UART bit time, core 1's launch, CPUID, a WFE ended by the other core's SEV, the PSM's power, the ROM's functions through its tables); examples/pico-blink-serial 7/7 and examples/pico-dual-core 9/9 with firmware built by clang and by EmbCC; an application built with the unmodified Pico SDK 2.3.1 (its CMake, GCC 13.2, newlib-nano) passes 9/9, in CI's linux-gcc job too: the SDK's clocks (clk_sys 125 MHz), float and double through the bootrom's tables, the divider, core 1 through multicore_launch_core1 and the FIFO, flash_range_erase and flash_range_program read back through the XIP, a repeating timer, a GPIO interrupt, stdio on UART0 both ways; a second, pwm_adc, 7/7: hardware_pwm at 1 kHz exactly with its wrap interrupt, hardware_adc on a 1.0 V source, the temperature sensor and the PWM's average through an RC low-pass (0.8 and 2.5 V), free-running conversions round robin through the FIFO's interrupt; a third, spi_i2c, 7/7: hardware_spi and hardware_i2c against the catalog's 25LC040 (WREN, WRITE, RDSR through its write cycle, READ) and 24C02 (a page write, NACKed polls through its write cycle, a current-address read and a random read after a repeated START, an absent address), every SCK and SCL edge counted; a fourth, usb_hello, over TinyUSB; a fifth, pio_dma, 9/9: a pioasm program's serial line and square wave, DMA copies, a chain, the sniffer's CRC-32 and DMA paced by UART0, PIO0 and the ADC (tests/vendor/pico-sdk/run.py); PIO0/PIO1, the DMA controller and the bus fabric's arbiters (rp2040-busctrl: the cores' and the DMA's accesses contending for the crossbar's ports by BUS_PRIORITY and round robin, a cycle's wait for the loser, BUSCTRL's performance counters) written for EmbSIM; the SDK's runtime_init_usb_power_down touches USB while it is held in reset, as on the part, which is one mcu.held_in_reset warning
MCU runtime: STM32F446RE (in progress, the NUCLEO-F446RE plan) The Cortex-M4F core with FPU, DSP and the MPU (core.mpu); the register file converted from ST's Apache-2.0 STM32F446.svd by tools/importers/svd2regs.py, with reset values and interrupt assignments corrected from RM0390 where the SVD differs (recorded in its source); the LQFP64 pinout and the ADC channels converted from ST's BSD-3-Clause open pin data by tools/importers/stm32pins.py; the clock tree to 180 MHz (stm32-rcc: HSI, HSE as crystal or ST-Link MCO bypass, LSE, LSI, the main PLL's P and R outputs, the bus prescalers, TIMPRE, the core clock from HCLK; out-of-spec VCO, SYSCLK, APB clocks and flash wait states reported) and PWR's voltage scaling and over-drive (stm32f4-pwr), with the low-power modes: Stop (the 1.2 V domain's clocks stopped but the RTC's and IWDG's, HSE and the PLLs off, an EXTI line's interrupt or event waking the core on HSI, under-drive's UDRDY) and Standby (RAM lost, the backup SRAM kept by BRE, the pins let go but the WKUP pins and RTC_OUT, a WKUP edge, an RTC event, NRST or the IWDG ending it with a power reset of all but the backup domain, WUF, SBF, EWUP, CWUF, CSBF, the option bytes' nRST_STOP and nRST_STDBY), and the core's SLEEPDEEP, SLEEPONEXIT and SEVONPEND; the flash interface (stm32f4-flash: KEYR's unlock, programming at PSIZE's width with its errors, sector and mass erase, EOP and the interrupt, the option bytes through OPTSTRT and their write protection; the times not modelled); the GPIO ports (stm32f4-gpio: the four modes, push-pull and open-drain, the speed setting the pin's output resistance and edge rate, pulls, BSRR, LCKR's lock sequence, AFR choosing among the alternate functions of io.alternate, converted from ST's open pin data), SYSCFG (stm32f4-syscfg: EXTI line ports, the memory at 0, the compensation cell) and EXTI's 23 lines with events; RCC's peripheral reset bits; the timers (stm32-tim, shared with the F1: up, down and center-aligned counting, repetition, output compare and PWM, input capture with filters, complementary outputs with dead time and break, LOCK, COM, the slave modes and encoder mode, external clocks, TRGO between timers); SysTick's HCLK/8 reference; the USARTs and UARTs (stm32-usart, shared with the F1: frame formats with parity, OVER8, overrun and the error flags, IDLE, breaks and LIN, mute mode, flow control, half-duplex, the synchronous clock), the runtime carrying each frame's format on the TX waveform and to the RX decoder; DMA1 and DMA2 (stm32f4-dma: streams and channels by RM0390's request mapping, direct and FIFO modes, circular and double buffer, memory-to-memory, the flags and interrupts) with the USARTs', SPIs' and timers' requests; SPI1-4 (stm32-spi, shared with the F1: master and slave, receive-only and bidirectional, NSS and MODF, the TI mode, CRC with the automatic CRC frame after a DMA transfer); I2C1-3 (stm32-i2c, shared with the F1: master and slave, 10-bit addresses, clock stretching, arbitration, BUSY and BERR from the bus, PEC, SMBus, DMA with LAST); ADC1-3 (stm32f4-adc: both groups, the timers' and EXTI's triggers, scan, continuous and discontinuous, RES, OVR, the watchdog, DMA, the internal channels and the temperature sensor at the world's temperature; the common block's dual and triple modes) and the DAC (stm32f4-dac: triggers, noise and triangle, DMA and underrun, the buffer, its voltage on PA4 and PA5); the device signature with its calibration values; the IWDG and WWDG (stm32-iwdg, stm32-wwdg, shared with the F1) and the RTC (stm32f4-rtc: calendar, alarms, wakeup, timestamp and tamper, RTC_OUT, calibration, backup registers); RCC_CSR's reset flags and the backup domain kept through resets; the other peripherals keep their register values and raise mcu.unsupported_access (docs/coverage.md) tests/firmware/cm4-core prints QEMU's output on a bare board around the part; tests/unit/test_stm32f4.c (the HAL's clock sequence to 180 MHz, HSE's kind, the spec warnings, the backup domain, GPIO's modes and lock, the AF table, EXTI on PC13 through SYSCFG, an internal line, an event, the boot remap, PWM on PA5, center-aligned and repetition counting, capture with overcapture and the filter, dead time and break on TIM1, TIM3 clocking TIM2, a quadrature encoder, one-pulse, SysTick's reference, USART2's frames, parity, breaks, OVER8, overrun, the error flags and IDLE, mute mode, nCTS and nRTS, the synchronous clock, USART2 sent and received by DMA in circular and double-buffer modes, memory-to-memory through the FIFO, the FIFO configuration and transfer errors, a timer's DMA burst, SPI1 as master with OVR and MODF, as slave across NSS, CRC-8 and CRC-16, full-duplex DMA with its CRC, the bidirectional, receive-only and TI modes, I2C1 as master against a device (POS read, stretching, ARLO) and as slave against a hand-driven bus (stretching, STOPF, AF, dual address, general call, BERR), I2C DMA with PEC and LAST, I2C1 wired to I2C3 with a 10-bit address and PEC, ADC conversions against the calibration words, scan by DMA, OVR, injected groups, TIM2-paced conversions, dual mode, the DAC's timing, voltage, triangle and underrun, the reset flags, the watchdogs' timing, window and hardware option, the RTC's calendar, alarms, wakeup, backup domain, timestamp and tamper, and its time across a switch to 180 MHz, Stop's stopped timer and RTC wake-up event, under-drive's UDRDY, Standby's lost RAM, kept backup SRAM, released pins, WKUP edge and kept flags, the option bytes' low-power reset, SEVONPEND and SLEEPONEXIT, the flash interface's keys, programming and its errors, a sector erase, the option bytes' write protection and OPTSTRT, a slave receiving over a written DR and no STOPF after a NACK); STM32CubeF4's own examples for the NUCLEO-F446RE built unmodified (its STM32CubeIDE projects' sources, defines and linker scripts, GCC 13.2, newlib-nano) pass 21 scenarios on the board, in CI's linux-gcc job too: GPIO_IOToggle, HAL_TimeBase_TIM, _RTC_ALARM and _RTC_WKUP, RCC_ClockConfig, RTC_Calendar (var probes on its time and date strings), TIM_PWMInput (a 20 kHz, 25 % input measured), UART_Printf, UART_ReceptionToIdle_CircularDMA (typed text echoed across the buffer's wrap), PWR_CurrentConsumption in Sleep, Stop, under-drive Stop, Standby (woken by PA0) and Standby with the RTC with and without the backup SRAM (woken 20.48 s later by the RTC on LSI), the four I2C_TwoBoards examples on two boards (ComPolling, ComIT, ComDMA: the buffers whole, SCL's edges counting exactly the bytes; AdvComIT: 19 checked write-and-read cycles in 0.65 s), and EEPROM_Emulation through the flash interface (tests/vendor/stm32cubef4/run.py); tools/validate.py --all; the importers' unit tests
Board: NUCLEO-F446RE (in progress, the NUCLEO-F446RE plan, step 9) emblink/nucleo_f446re (MB1136 C-03, UM1724 Rev 14): the STM32F446RET6 with HSE from the ST-LINK's 8 MHz MCO and X2 for LSE; LD2 on PA5, B1 on PC13 (R29, R30, C15), B2 and C14 on NRST, LD3 on +5V, BOOT0 held low by R33, C26 on VCAP_1; the power paths (U5V through T2 STS7PF30L and JP5, VIN through U3 LD1117S50 and D4 STPS2L30A to E5V, U4 LD39050PU33R to +3.3V, JP6 (IDD) to VDD with an ammeter's place across it); the Arduino and morpho headers, every pin a port, D0/D1 open as the solder bridges leave them; the ST-LINK's virtual COM port as the console on USART2; original artwork; linker script and toolchain profiles. Not yet: the ST-LINK itself (enumeration, its current negotiation, drag-and-drop programming, LD1), the STM32's supply current, reference.json and the 3D bench's exact positions the board's fixtures (USB power, VIN with JP5 left on U5V and moved to E5V, JP6 removed with an ammeter, B1); examples/nucleo-f446re-blink-serial (180 MHz from the MCO, LD2's 1 Hz blink, B1 through EXTI13, the VCP's echo, reg, mem and var probes; examples_headless); the STS7PF30L's and STPS2L30A's fixtures
Board: ESP32-C3-DevKitM-1 (the RTOS boards plan, part 2, step 6) emblink/esp32c3_devkitm1 (V1.0 schematic and dimension drawing): the ESP32-C3-MINI-1 (espressif/esp32c3's mini1 package); VBUS through D1 (1N5819) to 5V, U2 (SGM2212-3.3) to 3V3, D5 on 5V through 5.1 k; R5 (10 k) and C6 (1 uF) on CHIP_PU, RST (SW2) on it, BOOT (SW1) on GPIO9, R20 holding GPIO8 high; the SK6812MINI-HS RGB LED on GPIO8 (emblink/sk6812mini_hs); J1 and J3, every pin a port; the CP2102N as the console's bridge on UART0 and a host serial port; original artwork; its features on the 3D bench. CHIP_EN low holds the chip off; RST restarts it with rst:0x1 (POWERON), BOOT held through RST gives the ROM's download mode. run --target plugs it into a USB port. Not yet: the auto-program circuit (Q1, Q2) on DTR/RTS, which a pseudo-terminal does not pass, so esptool's reset into download mode; the CP2102N's USB and supply current; decoupling and bulk capacitors (C1: the analog engine does not converge with it on the regulator's output yet); reference.json; the first 200 ms of a run cost about 2.5 s of wall time while C6 charges the board's six fixtures (USB power, CHIP_PU's delay and release, RST held and released, BOOT); ESP-IDF v5.4's hello_world through embsim run --target and BOOT+RST into download mode by hand; the SK6812MINI-HS's fixtures
MCU runtime: ESP32-C3 (in progress, the RTOS boards plan, part 2, steps 1-7) espressif/esp32c3: the ESP-RV core (esp-rv32imc, TRM v1.4 chapter 1): RV32IMC with user mode and no A, only the part's CSRs (mie, mip and the standard counters are illegal), mstatus's MIE, MPIE, MPP and TW, a vectored mtvec on a 256-byte base, five-bit mcause codes, MRET clearing MPIE; the performance counter (mpcer, mpcmr, mpccr, also at 0x800-0x802 where the ROM starts it) and the user trap CSRs the ROM writes; the trigger module (eight triggers, exact or NAPOT match on execute, load or store); 16 PMP entries without static priority; the cpu_gpio CSRs. The interrupt matrix and controller (esp32c3-intmtx). The boot: Espressif's own boot ROM, from its Apache-2.0 ROM ELF (tools/importers/esprom.py), runs from the reset vector: its banner, the strapping (esp32c3-gpio's GPIO_STRAP), the reset cause (esp32c3-rtc), then an ESP image loaded from the flash through SPI1, its checksum and SHA-256 checked on the SHA accelerator (esp32c3-sha, Typical SHA: SHA-1, SHA-224, SHA-256), and its entry; a blank flash prints invalid header: 0xffffffff until the RTC watchdog's flash-boot protection resets the part (rst:0x10 (RTCWDT_RTC_RST), Saved PC from esp32c3-assist's PC logging). The in-package flash, an XMC XM25QH32C (nor.c: its instructions, status registers, typical busy times, security registers, suspend, power-down), behind SPI0 and SPI1 (esp32c3-spimem: user commands and the fixed ones); the cache and MMU (esp32c3-cache): 128 entries of 64 KB pages on the instruction and data buses, invalidate, preload, lock and freeze. UART0 and UART1 (esp32c3-uart); RTC_CNTL (esp32c3-rtc: reset causes, the RTC timer, the RWDT, the software resets). A project's bin firmware is a flash image at offset 0. Clocks and timers: SYSTEM (esp32c3-system: CPU_CLK from XTAL_CLK / 2 out of reset, the PLL's 80 or 160 MHz or RC_FAST_CLK, APB_CLK, the peripherals' clock enables and resets, the software interrupts); the system timer (esp32c3-systimer: two 52-bit counters at 16 MHz, three comparators in target or period mode); TIMG0 and TIMG1 (esp32c3-timg: T0 with its prescaler, direction, alarm and auto-reload; the MWDT's stages, write key, configuration update and flash-boot protection, so a blank chip resets with rst:0x7 (TG0WDT_SYS_RST) after 1.3 s; the RTC_SLOW_CLK calibration); the eFuse controller (esp32c3-efuse: read and program commands, the chip's factory bits: v0.3, QFN32, 4 MB XMC flash, a MAC, or the one its board's settings.mac gives). Pins: the GPIO matrix and IO MUX (esp32c3-gpio, esp32c3-iomux: the pads' reset configuration from TRM table 5.12-1, outputs, inputs, interrupts, the UARTs on whichever pins the matrix gives them); USB Serial/JTAG (esp32c3-usbjtag) with no host on its pins, as on a DevKitM-1. ESP-IDF: the analog blocks' I2C master (regi2c.c), RND_DATA (esp32c3-apbctrl, seeded), the radio's register blocks with the PHY's calibrations answering as an ideal radio (radio.c, regi2c.c), the Wi-Fi MAC on the session's air (wifi.c: transmit queues, completions, the receive list with ESP-IDF's rx_ctrl header, the address filters, ACKs, the interrupt, the microsecond counter and TSF, the key table and CCMP, the random number register; each chip's random numbers its own); the SHA accelerator's DMA-SHA, the AES accelerator (esp32c3-aes: Typical AES, DMA-AES in ECB, CBC, OFB, CTR, CFB8 and CFB128) and the RSA accelerator (esp32c3-rsa: modular multiplication and exponentiation by Montgomery products, multiplication, to 3072 bits), a 40 MHz BSS's primary channel, the key entry a frame names, the ROM's layout pointer, a CPU reset clearing the permission control; ESP-IDF v5.4's hello_world runs unmodified from the ROM through its bootloader and app to esp_restart. Peripherals: the GPIO matrix carries any modelled peripheral's signals; RMT (esp32c3-rmt: two transmitters and two receivers over the 192-word RAM, normal, wrap and continuous modes, loop counts, the carrier, the receivers' idle threshold, filter and demodulation); LEDC (esp32c3-ledc: four timers, six generators, dithering, fading); I2C (esp32c3-i2c: master's command list with its bus timing, stretching, arbitration and timeout; slave with 7- and 10-bit addresses, the general call, ACK control and stretching); GP-SPI2 as a master (esp32c3-spi2: CMD, ADDR, DUMMY and data on 1, 2 or 4 lines or QPI, full and half duplex, the four modes, its buffer or DMA); the GDMA (esp32c3-gdma: three channels each way on descriptor lists, memory to memory); the SAR ADCs and temperature sensor (esp32c3-adc: one-time sampling, the timer's scanning into the GDMA, filters, thresholds, the world's temperature). the Bluetooth LE core (ble.c: the native clock, its timers, the interrupt FIFO, the exchange memory and table, advertising events on the air, a CONNECT_IND received, connection events as the slave and as the master with their receive and transmit descriptors and sequence numbers, channel selection #1 and #2, scan and initiating events with the CONNECT_IND). Not yet: a USB host on GPIO18/19, GP-SPI2's slave mode, TWAI, I2S, HMAC and the digital signature, Wi-Fi beyond a scan, a station, an access point, ESP-NOW and HTTP to the internet beyond a router, Bluetooth beyond advertising, scanning and connections (docs/engineering/c3-radios.md: steps 1 to 3 are done for a scan, step 4's air and access point are under way: ESP-IDF's wifi/scan lists the bench's access points with their RSSI and its station, as it ships, joins a WPA2-PSK network and gets its address by DHCP; step 6 is under way: NimBLE's bleprph advertises, a phone's scanner lists it, a tablet's GATT browser connects and discovers its database, and blecent on a second board connects to it as the master; Arduino-ESP32's WiFiScan, WiFiClientConnect and BLE Server and iBeacon (Bluedroid) run as they ship; scan responses are sent to the phone's active scanning and BLE packets collide on the air; ESP-IDF's http_request and Arduino-ESP32's BasicHttpClient reach a web server beyond the router) test_esp32c3 (the core's CSRs, atomics, counter, trigger, PMP, interrupts and WFI; the ROM on a blank flash, booting an image that reads the flash through the MMU, a bad digest; the flash's commands and busy times; the cache's staleness and invalidate; SHA-1, -224 and -256; the PC logging; the CPU clock and the software interrupts; the system timer's target and period alarms; T0's alarm and reload, the MWDT's stages and key, the RTC_SLOW_CLK calibration; the eFuses; the blank chip's TG0WDT reset; the GPIO's reset, output, input, interrupts and matrix UARTs; the periodic calibration; the analog I2C master; RND_DATA and the radio's blocks; the PHY's calibrations; the Wi-Fi MAC's queues, completions, receive list, filters, reload and TSF, its CCMP both ways, its random number register and another chip's own numbers; DMA-SHA's one- and two-block messages; AES against FIPS 197 and SP 800-38A's CBC and CTR; RSA's modular product and power, product, search position, interrupt and a wrong M' against Python's integers; the BLE core's version, clock, timers, interrupt FIFO and an advertising event on three channels, a connection event as the slave (its channel, window, receive descriptor, answer, acknowledgement and a resent packet), as the master on channel selection #2 (the specification's sample channels), a scan event and an initiating event's CONNECT_IND and window offset, a SCAN_REQ answered with the scan response, an active scan event's SCAN_REQ and the SCAN_RSP taken; the temperature sensor's own clock; USB Serial/JTAG without a host; a CPU reset's permission control; a peripheral's reset keeping its timers' rates; RMT sending and receiving through the matrix, its loops, wrap, carrier, filter and stop; LEDC's PWM, 0 and 100 %, dithering, fading and overflow counter; I2C as master against a device the test plays (writes, a repeated-START read, a NACK, the bus timing, a stretched clock, END) and as slave to a bit-banged master; GP-SPI2 in the four modes, quad I/O, LSB first and by GDMA; the ADCs' one-time samples, attenuations, grounded input and monitor, their scanning by GDMA, the temperature sensor), tools/test_esprom.py; ESP-IDF v5.4's own examples, unmodified, under scenarios (tests/vendor/esp-idf: hello_world, blink, ledc_basic, temp_sensor, adc_oneshot_read, i2c_eeprom, gptimer, uart_echo, real_time_stats, wifi_scan, wifi_station_open, wifi_station, bleprph, blecent with bleprph on a second board, Bluedroid's ble_ibeacon as sender and receiver on two boards, espnow on two boards, wifi_softap with the station example on a second board, http_request fetching example.com's page through the router; CI's esp-idf job); Arduino-ESP32 3.2.0's sketches through arduino-cli (tests/vendor/arduino-esp32: Blink on the RGB LED, DigitalReadSerial, Fade, GetChipID, RepeatTimer, WiFiScan, WiFiClientConnect, the BLE library's Server (Bluedroid) read by a tablet's GATT browser and its iBeacon decoded by a phone's scanner, HTTPClient's BasicHttpClient; CI's arduino-esp32 job)
MCU runtime: nRF52840 Cortex-M4F; the register file converted from Nordic's nrf52840.svd (BSD-3-Clause), peripherals that share an address space merged, FICR with a part's factory words; the NVMC (nrf-nvmc: word writes to the flash and the UICR, page, partial, UICR and whole erases, READY for 85 ms a page, 41 us a word and 169 ms ERASEALL, the last two recalled from the Product Specification and not yet checked, with a program in the flash halted) and the UICR kept through resets (nrf-uicr); Nordic's tasks, events and interrupts; models extracted from EmbCC: CLOCK (HFXO, LFCLK), the GPIO ports (drive modes, pulls, SENSE, LATCH, DETECT), UART0/UARTE0 and UARTE1 with EasyDMA and SHORTS, timed at BAUDRATE on their PSEL pins, TIMER0-4, RTC0-2; GPIOTE written for EmbSIM (event and task channels, PORT), and SPIM0-3, TWIM0-1 (EasyDMA, the shorts, SUSPEND, ERRORSRC; open-drain SCL and SDA), PWM0-3 (EasyDMA sequences in the four decodings, Up and UpAndDown, loops) and the SAADC (AIN0-7, VDD, gains and references, oversampling, limits, scans into Data RAM) on their pins test_nrf52 (275 checks: SPIM2's transfer with ORC and its events, TWIM0's NACKed address held until STOP, a TXRX through LASTTX_STARTRX and LASTRX_STOP, PWM0's two channels and its period, the SAADC's calibration, scan, codes and limit; FICR, the HFXO's debounce, the ports and GPIOTE's edges and tasks, a UARTE buffer's frames and ENDTX, a TIMER compare, an RTC compare); examples/nrf52840dk-blink 7/7 with firmware built by clang and by EmbCC; an application built with Nordic's unmodified nrfx 4.6.0 drivers and MDK (its system file, GCC startup and linker script, GCC 13.2 hard-float, newlib-nano) passes 8/8, in CI's linux-gcc job too: nrfx_clock's HFXO and LFXO, nrfx_uarte both ways through its RX buffers, nrfx_timer's compare and CLEAR short against nrfx_rtc's counter and compare, nrfx_gpiote's falling edge; a second, nrfx_periph, 8/8: nrfx_spim against a 25LC040, nrfx_twim against a 24C02 (a page write, NACKed polls, TXRX, a suspended TX then an RX, an absent address), nrfx_pwm at 1 kHz exactly and nrfx_saadc on a 1.0 V source, VDD and the PWM through an RC low-pass, every SCK and SCL edge counted; a third, nrfx_nvmc, 9/9: nrfx_nvmc's page erase in 85 ms, words in 41 us, partial erases to the driver's 85 ms, -EACCES within a page, UICR's CUSTOMER[0] kept through a reset (tests/vendor/nrfx/run.py); the radio and PPI are plain registers
MCU runtime: PIC32MX MIPS32r2 with MIPS16e extracted from EmbCC, its state a parameter: the M4K (EIC mode, two register sets, fixed mapping, the core timer) and QEMU malta's 24Kc; WAIT and idle loops sleep; the MIPS32 disassembler; the PIC32MX795F512L's register file converted from Microchip's Apache-2.0 device pack (tools/importers/edc2regs.py) with its CLR, SET and INV registers, shared vectors and pin functions; models extracted from EmbCC: the EVIC (priorities, subpriorities, single- and multi-vector modes, the shadow set), the oscillator from the configuration words (the PLL, the switch, PBDIV, SYSKEY's lock) with SYSCLK as the core's clock, Timer1-5 with 32-bit pairs, ports A-G with the change notices and their pull-ups, UART1-6 timed at their baud rate on their pins test_mips (168 checks: a delay slot, exceptions in and out of one, the core timer in compatibility and EIC modes, MIPS16e, ll/sc, the disassembler); test_pic32 (1326 checks: CLR/SET/INV and the pins, the clock from the configuration words and the lock, Timer1, a change notice, UART2's bit time and persistent interrupt, the example's image); examples/explorer16-pic32mx 8/8 with firmware built by clang and by EmbCC; the ADC, SPI, I2C, DMA, USB, Ethernet and CAN are plain registers
MCU runtime: PIC24 The PIC24F core extracted from EmbCC, its state a parameter (and its dsPIC33E mode with the DSP engine, untested here): every PIC24F instruction and addressing mode, REPEAT and the iterative divide, the Extended Data Space and program space visibility, table reads, traps (mcu.trap) and interrupts through the vector table, DISI; PWRSAV and a branch to itself sleep; program memory at twice its address and the data space at 0x2000000 on one bus; the disassembler; the PIC24FJ1024GB610's register file converted from Microchip's Apache-2.0 device pack with its PPS functions and configuration words; models extracted from EmbCC: the interrupt controller, the oscillator (FNOSC from the configuration words, OSCCON's unlock sequences, the PLL's 32 MHz and CPDIV) with FCY as the core's clock and the PPS lock, Timer1-5, ports A-G with ANS, the pulls and the interrupt-on-change; UART1-6 written for EmbSIM, timed on the pins the PPS gives them test_pic24 (1465 checks: instructions as xc16-as assembles them and their cycles, an address error trap, an interrupt taken from PWRSAV, the clock from the configuration words and OSCCON's lock, Timer1, the interrupt-on-change, UART2 through the PPS and IOLOCK, the disassembler, the example's image and its XC16 line table); examples/explorer16-pic24 8/8 with firmware built by XC16 v2.10; the ADC, SPI, I2C, the capture/compare modules, DMA, USB and the RTCC are plain registers
Record and replay Recordings (SPEC-012): the engine, the project's and images' SHA-256, every input, and observations in time order (each core's interrupt entries, digital probe transitions from reset, the serial probes' text, warning and error diagnostics, the end); embsim run --record, embsim replay (exit 4 at the first divergence, with both observations; a changed project or image refused unless --allow-drift), embsim record to-scenario, and record.start, record.stop, record.replay (a file or the recording itself) and record.to_scenario over the protocol; a recording made in a running session begins with the digital probes' levels and replays from its start (from_ps, from_seq, immediate inputs); tools/verify/compare_reports.py diffs two run reports record_replay (tests/protocol/test_replay.py): all twenty examples recorded twice in two processes with equal observations, each replayed exactly, an injected divergence, a changed image refused, a recording turned into a scenario passing, record.replay over embsim sidecar; python_client: recordings made from reset, from 7 ms and after an earlier input each replay identically and pass as scenarios; test_host checks SHA-256 against FIPS 180-4's vectors; event traces (--trace-events) and analog observations are not implemented
Coverage, profile, stacks and faults Every core watched instruction by instruction when a machine carries analyses (SPEC-009 §12; extracted from EmbCC's analyses): coverage per source line and function from the DWARF line tables and the ELF's functions and code labels; the profile by call path on a shadow stack per core, from each core's calls and returns and the exception entries and returns every core reports (Cortex-M, AVR, RISC-V, MIPS with its delay slots, PIC24; the RP2040's two cores rooted apart); embsim run --coverage (gcov-style text with the source, lcov, JSON) and --profile (text, collapsed stacks, JSON); the stacks' depths (--stack, analysis.stack: each core's main and process stacks against the link's __stack_limit or the end of the data, each function's own frame and its depth with its callees, mcu.stack_overflow when the main stack goes past its limit); the fault report (--faults, analysis.faults, mcu.fault: a Cortex-M's faults with HFSR and CFSR decoded, RISC-V and MIPS exceptions, PIC24 traps, the instruction, the registers, a backtrace from .debug_frame or the shadow stack, the handler); analysis.start, .stop, .coverage, .profile, .stack, .faults; the run report's summaries analysis (tests/protocol/test_analysis.py): all nine firmware examples measured twice in two processes alike, the profile's functions adding up to the instructions and cycles, lcov agreeing with the JSON line for line, the collapsed stacks adding up to the cycles, every board's stack within its limit and main's depth at least its frame, a recursion past __stack_limit (tests/firmware/stack-overflow) raising mcu.stack_overflow once in the right function with the depths adding up, a load from nothing (tests/firmware/fault) raising mcu.fault once as a HardFault (FORCED, PRECISERR, BFAR) with the backtrace peek, read_sensor, main, Reset_Handler from .debug_frame, the protocol's methods; RISC-V and MIPS faults decoded by hand (a load access fault on the HiFive1, an address error on the PIC32MX, each with its .debug_frame backtrace); the PIC24's decoding is not exercised (no XC16 in CI); the Pico's two-core scenario runs in the same wall time with both on
Python client python/embsim (pip install ./python, standard library only): Session over embsim sidecar (time, inputs, serial text, probes, scenarios, recordings and replay, coverage and profile, the debugger), run() and replay() over the command line with its exit codes, a pytest fixture python_client (python/tests/test_session.py) against this build
An emulated target for test runners embsim run --target BOARD --image FILE (a catalog board, no project), --console, --until-text TEXT (ends at the millisecond the text appears; exit 1 when it never does), --image ID=FILE over a project; docs/user/ci.md (the CI contract, GitHub Actions, GitLab CI, Python) run_target (tests/protocol/test_target.py); EmbLinkRTOS's nine Arduino Uno conformance tests pass on EmbSIM's Uno in 4.4 s (its avr-uno-embsim preset and tools/embsim/run_embsim.py, EmbLinkOs/EmbLinkRTOS#12, whose avr-embsim CI job builds EmbSIM's main and passes them); its ten Cortex-M4F conformance tests pass on EmbSIM's NUCLEO-F446RE in 4 s (its nucleo_f446re board at 180 MHz, the cm4-nucleo-embsim preset and the cm4-embsim CI job); its twelve RV32IMC conformance tests pass on EmbSIM's ESP32-C3-DevKitM-1, each booted by Espressif's ROM from its flash image (its esp32c3_devkitm1 board, the rv32-c3-embsim preset and the rv32-embsim CI job, EmbLinkOs/EmbLinkRTOS#20); --target plugs the board into a USB port (5 V on its USB_VBUS, VBUS or U5V)
Multi-board projects several boards in one project, each MCU with its own firmware on the session's time, connected by nets multiboard (tests/protocol/test_multiboard.py): an Uno and a Blue Pill exchange bytes over one serial line at their real baud rates and logic levels; two runs agree on every event
Debug Breakpoints by address, symbol, or file and line; watchpoints; step, halt, continue; registers and memory read and write; Thumb disassembler; ELF symbols; DWARF 2 to 5 line tables (XC16's packed sections too); debug.* methods; GDB remote protocol server (embsim gdb) test_mcu (source lines), tests/protocol/test_gdb.py (registers, memory, breakpoints, step, continue over RSP); LLDB debugged the example through embsim gdb in this workspace
Toolchains Detection from the profiles' version commands, builds by template expansion (embsim build, embsim toolchains, toolchain.detect, toolchain.build) (SPEC-010 subset) tests/protocol/test_build.py; the EmbCC and Clang profiles built the examples here; the gcc-arm profile (GCC 13.2) builds the Blue Pill, both Pico examples and the nRF52840 DK, gcc-avr (avr-gcc 7.3) the Uno, and gcc-riscv (Ubuntu's riscv64-unknown-elf-gcc 13.2 with picolibc, found under its alternative prefix) the HiFive1, each passing its scenario unchanged, in CI's linux-gcc job too; XC16 v2.10 (free mode, installed by hand) built examples/explorer16-pic24; the TinyCC, XC8 and XC32 profiles are not exercised (not installed), and CI has no XC16
CLI run (with --record, --coverage, --profile, --target/--image, --until-text, --console), replay, record to-scenario, validate, serve (with --allow-origin), sidecar, catalog (list, validate, new, install), board, models, gdb, build, toolchains, version tools/ci/run_examples.py: twenty examples validate and pass their scenarios (40 steps): counter-bus, button-led, button-transistor-led, rc-filter, bluepill-button-led with its firmware (the LED driven through an NPN transistor as 01 §8 describes), display-showcase 6/6, kicad-flasher, temperature-alarm, temperature-divider, light-controlled-switch, optocoupled-input, transistor-relay, uno-blink-serial 7/7, hifive1-blink 7/7, pico-blink-serial 7/7, pico-dual-core 9/9, nrf52840dk-blink 7/7, explorer16-pic32mx 8/8, explorer16-pic24 8/8, two-boards-uart 8/8
Catalog 181 components in 20 categories with symbols, artwork and 480 component fixtures, named manufacturer parts among them (passives, sources, semiconductors, 74HC and CD4000 logic, the 555, regulators, displays: 7-segment, the TM1637 4-digit module, HD44780 LCDs (16x2, 20x4), SSD1306 OLED, MAX7219, WS2812B LEDs and strips; I2C and SPI devices: the PCF8574 expander, 24C02, 24LC256 and 25LC040 EEPROMs, DS1307 and DS3231 clocks, sensors, the DS18B20 on 1-Wire, the BME280 and BMP280, the MPU-6050, the HX711 with a load cell; the NEO-6M GPS; the TSOP38238 IR receiver with an NEC remote; the MFRC522 RFID reader with a MIFARE Classic card; breadboards of 830, 400 and 170 points whose strips and rails are ties, with the bench's place for every leg (layout.bench, SPEC-007 §2); actuators: servo, the 28BYJ-48 stepper motor with the ULN2003A and its driver board, a stepper driver, buzzer); nine MCUs with their register descriptions and packages (STM32F103C8 LQFP48, STM32F446RE LQFP64, ATmega328P DIP-28, FE310-G002 QFN48, RP2040 QFN56, nRF52840 aQFN73, PIC32MX795F512L TQFP100, PIC24FJ1024GB610 TQFP100, ESP32-C3 QFN32 and in the ESP32-C3-MINI-1); nine boards with artwork and power fixtures (Blue Pill, NUCLEO-F446RE, Arduino Uno R3, HiFive1 Rev B, Raspberry Pi Pico, nRF52840 DK, Explorer 16/32 with the PIC32MX795F512L PIM and with the PIC24FJ1024GB610 PIM, ESP32-C3-DevKitM-1); eight toolchain profiles; JSON Schemas for every kind; the Python validator with semantic checks embsim catalog validate catalog: 190 ok, 0 broken, 0 invalid, 503 fixtures run (catalog_fixtures); the HD44780 LCD against the LiquidCrystal library, its HelloWorld run unmodified (4-bit at the controller's own timing, nothing shown until the contrast pot is turned) and its fixtures for the busy controller ignoring a write and a floating R/W reading; the PCF8574 and a 20x4 LCD against LiquidCrystal_I2C, its HelloWorld run unmodified through a backpack wired as the common board is (address 0x27 from the pulled-up A0..A2, the backlight switched by P3) and the expander's fixtures for the address pins, the interrupt and a low supply; the DS18B20 against OneWire and DallasTemperature, the Simple example run unmodified (the search algorithm, MATCH ROM and the scratchpad's CRC, CONVERT T polled to its 750 ms end) and its fixtures for presence, conversion, 9-bit resolution and the supply (own, parasite, too low); the BME280 against Adafruit's library, its bme280test run unmodified (chip ID, soft reset, the trimming parameters, normal mode at x16, readings compensated by the library's own formulas to the room's values, the altitude from them) and its fixtures for forced and normal mode, the address pin, ctrl_hum latching, SPI and a low supply; the BMP280 on the same model against Adafruit's BMP280 library, its bmp280test run unmodified (chip ID 0x58 at 0x77, normal mode at x2/x16 with the x16 filter) and its fixtures for a forced measurement, the absent humidity and the 2 s standby; the HX711 with a 5 kg load cell against the HX711 library, its HX711_full_example run unmodified (raw readings, tare, the scale factor, power-down and up) and its fixtures for settling, a read, its end, power-down, channel B, saturation, noise and a low supply; the MPU-6050 against Adafruit's library, its basic_readings run unmodified (WHO_AM_I, DEVICE_RESET polled, the ranges and filter set, a tilt and a turn read back in m/s^2 and rad/s) and its fixtures for sleep at power-on, wake, saturation, the gyro scale, the DLPF delay, the AD0 address, the 8 kHz data-ready interrupt, temperature and a low supply; the WS2812B against Adafruit NeoPixel, its simple example run unmodified on a 16-LED ring (the library's bit-banged 800 kHz frames decoded and latched) and its fixtures for a colour, the 0.6 us threshold, a chain passing bits on, the V5's 280 us latch and a low supply; the DS3231 against RTClib, its ds3231 example run unmodified (OSF at power-up, the clock set from the build time and counting, the temperature register) and its fixtures for power-on, midnight, the countdown-chain reset, both alarms, the square wave, the 32 kHz output, temperature and a low supply; the 4x4 membrane keypad (sixteen switches with the membrane's contact resistance and bounce) against the Keypad library, its HelloKeypad run unmodified, and its fixtures for a press and the bounce; the NEO-6M against TinyGPSPlus, its DeviceExample run unmodified over SoftwareSerial (the fix, the date and time, a move, the coordinates as the Uno's floats print them) and its fixtures for the sentences without a fix, a hot fix's RMC and GGA, the cold start's 27 s, the time pulse and a low supply; the SSD1306 against Adafruit's library, its ssd1306_128x64_i2c run unmodified (the splash frame matching one rendered independently from the library's bitmap, then the single pixel) and its fixtures for the orientation with and without remap, the charge pump, the 100 ms power-up and a timed scroll; the MFRC522 with a MIFARE Classic 1K card against the MFRC522 library, its DumpInfo run unmodified (REQA, anticollision, SELECT, authentication of every sector and the whole card read) and its fixtures for the antenna, a REQA, the antenna off and a low supply; the KY-040 rotary encoder against PJRC's Encoder, its Basic example run unmodified (four counts a detent, the bounce visible in the polled count) and its fixtures for two detents, the direction, the bounce, floating without + and the press; the 28BYJ-48 stepper through its ULN2003 board against the Arduino Stepper library, its stepper_oneRevolution run unmodified (200 steps a way at 60 rpm turning the geared shaft 34.9 degrees, as on the bench) and its fixtures for full steps, the pull-in rate, a stall beyond it, a ramp past it, the wrong lead order, holding and overload, bipolar drive and the ULN2003's saturation voltage; the TM1637 4-digit display against TM1637Display, its TM1637Test run unmodified through every test (digits at each position, numbers with and without leading zeros, hexadecimal, the colon, the seven pulse widths, off and on, DONE) and its fixtures for the digits, power-on, the colon and the points, fixed addressing, the address limit, the ACK, a STOP mid-byte and the key read; the TSOP38238 IR receiver with the kit's NEC remote against IRremote, its SimpleReceiver run unmodified (frames and repeat codes decoded by the library's Timer2 sampling) and its fixtures for the leader, a frame, repeats, the bit timing and a low supply; the HC-SR04 against NewPing, its NewPingExample run unmodified (the echo from the speed of sound at the air's temperature, the range limits) and its fixtures at 20 and 0 C; the servo against the Arduino Servo library, its Sweep and Knob examples run unmodified (the horn at the rated speed, the dead band, the library's first pulse after a full Timer1 wrap) and its travel fixture; the DHT22 against Adafruit's DHT library, its DHTtester example run unmodified (tests/vendor/arduino: every read decoded, the previous measurement sent, the element's 10 s lag on a step from 23.4 to -5.3 C) and its fixtures for the datasheet's start-up second, previous data and response time; catalog_fixture_assertions runs the component fixtures through the CLI; tools/validate.py --all: 690 files, 0 errors; the tools' unit tests: 137 tests; the STM32F103C8's register description written from RM0008 (ADR-020), the RP2040's and the nRF52840's converted from their vendors' BSD-3-Clause SVD files, the PIC32MX795F512L's and the PIC24FJ1024GB610's from Microchip's Apache-2.0 device packs
The world (ADR-026) Fields (temperature, humidity, pressure, illuminance, sound, wind) declared by the project or set by inputs, read by every sensor input bound to them (inputs[].world) while the input is not set, the input's own default when the field is not declared; boxes and spheres on the bench met by a distance sensor's beam (bench.sense) from its place in layout.bench; world inputs (world, world.BODY) scheduled, recorded and replayed; set_world without a restart; world.get; reset restores the project's room; the World panel and bodies on the 3D bench with the sensors' beams tests/protocol/test_world.py (an LDR divider following the room's light, a part's own value overriding it, bad world inputs refused, bodies added and removed, set_world applied without a restart and saved, reset restoring the room); NewPing's NewPingExample 6/6 measuring a wall moved to 30, 250 and 1 cm and the room at 0 C; Adafruit's DHTtester 3/3 reading the room's 23.4 C and 61.2 %RH and its drop to -5.3 C; e2e/world.spec.ts; every fixture and example unchanged; fields as functions of position, moving bodies, physics and motion for IMUs not implemented
The air, a Wi-Fi access point, the internet, phones and sniffers (the ESP32-C3 radios plan, steps 4, 6 and 7, under way) The 2.4 GHz medium (core/engine/air.h): frames with their channel, power, rate and airtime (802.11 DSSS and OFDM, BLE), delivered when they end to every radio tuned to their channel at the free-space path loss over the bench distance (layout.bench; a board's parts where the board is) above -97 dBm, ACKs for unicast frames; emblink/wifi_ap: beacons with WPA2-Personal's RSN element or open, the 4-way handshake and CCMP, probe responses, open authentication, association with AIDs, deauthentication; data frames with LLC/SNAP, power-save buffering (TIM, PS-Poll, More Data, group frames after the DTIM); the router behind it answering ARP and pings and leasing addresses by DHCP; relaying between its stations; its NAT to the internet beyond and its DNS forwarder; the internet beyond the routers (core/engine/inet.h: IPv4 packets between the routers' WAN sides and the hosts out there, each link's latency, names resolved); emblink/web_server, a web server there (TCP as a server with its handshake, MSS, window, retransmission and FIN; HTTP/1.x GET and HEAD, 404 and 501; ICMP echo); the stations and a log in its outputs; emblink/ble_scanner, a phone's scanner app: active scanning of channels 37, 38 and 39 in turn (SCAN_REQs with the specification's backoff), each advertiser's address, PDU type, name (from its advertising or scan response) and RSSI, an iBeacon's UUID, major, minor and power; emblink/ble_central, a GATT browser: a CONNECT_IND to its target, the connection as its master (channel selection #1, acknowledgement, L2CAP fragments, the supervision timeout, a connection that failed to be established tried again), GATT discovery and reads; overlapping BLE packets on a channel colliding unless one is 21 dB above; BLE packets taken from their access address on; emblink/wifi_scanner, a phone's Wi-Fi analyzer: channels 1 to 13 scanned as a phone does (a probe request on each, or passively), each network's SSID, BSSID, channel, security (Open, WEP, WPA, WPA2, WPA3, -Enterprise) and RSSI; emblink/air_sniffer, a Wi-Fi adapter in monitor mode on one channel or an nRF-Sniffer-style dongle on one advertising channel: every frame it hears with its FCS, or the access address, PDU and CRC-24, its time, channel and RSSI, the snapshot length; the workbench's Air panel (Run, the Air tab): the phones' lists with signal bars, the sniffer's frames as Wireshark's packet list names them (802.11 management frames by SSID, EAPOL's four messages, ARP, IPv4 with its ports, BLE PDUs with their addresses and names), a frame's bytes, saved as pcap (radiotap, LINKTYPE_BLUETOOTH_LE_LL_WITH_PHDR); the supply current parts draw (ADR-036): a part's model sets it, its power pins fed by the circuit sink it to its ground; the ESP32-C3's from its datasheet (the core running and waiting at its clock over 1 ms windows, held off, the radio listening and sending by modulation); emblink/usb_power_meter, an inline USB tester (its insertion resistance, its own draw from the host's side, readings averaged over its refresh at its resolution, mAh and mWh) test_engine (airtimes, channels, path loss, delivery and ACK timing, range, reset; the access point's beacon, probe response, authentication, association and deauthentication, ARP, DHCP's offer, ACK and NAK, a ping, a frame kept for a dozing station, its TIM and PS-Poll, against a scripted station); emblink/wifi_ap's two fixtures (the beacon interval); ESP-IDF's wifi/scan 19/19 with two access points 3 m and 12 m from the board; its station set for an open network 13/13 and as it ships, WPA2-PSK, 13/13: joined, keyed and leased 192.168.1.100; test_engine's WPA2 test plays a supplicant through the 4-way handshake and CCMP; test_wcrypto (the standards' vectors). The scanner: test_engine (channels in turn, the window, two advertisers, an iBeacon decoded, active scanning's SCAN_REQ, the SCAN_RSP's name and the backoff), its fixture; the air's BLE collisions and capture (test_engine); NimBLE's bleprph listed 2 m away at -37 dBm. The browser: test_engine against a scripted peripheral (the CONNECT_IND's fields, the channels and timing, the discovery, the supervision timeout), its fixture; bleprph connected, its four services and their characteristics discovered and read (14 assertions). The internet: test_engine (a drop, a ping's round trip, names, the web server's handshake, a request in two segments, 200, FIN, RST, 404, retransmission), web_server's fixture, http_request and BasicHttpClient. The analyzer and the sniffer: test_engine (a scan of two access points listed by RSSI with their security, passive scanning, the BLE access address and CRC-24, the 802.11 FCS, the snapshot length), five fixtures; the pcap files read by scapy, every FCS and the CRC-24 its own computation's; air.test.ts; e2e/air.spec.ts; The supply current: test_analog's test_supply_current (a part's current through a supply's resistance, none when its own pin is the supply, a supply that cannot carry it), the meter's four fixtures, hello_world reading 16.7 mA and http_request 102 mA while scanning through the meter; Wi-Fi's power save: test_esp32c3's test_wifi_tsf (the TSF loaded, the TBTT's interrupt ahead of each beacon, a TSF timer, source 2, the radio deaf with the common clock off), http_request in power save at 21.9 mA, keeping its access point. http_request's association, 4-way handshake and protected data captured on channel 6, bleprph's and ble_ibeacon's advertising, the phone's SCAN_REQ and the SCAN_RSP on 37 (docs/gallery). Not yet: the host's own network, TLS, 802.11n, WPA3, BLE's 2M and Coded PHYs, BLE encryption, retransmissions, Wi-Fi contention and collisions, fading, the sniffer following a connection, light sleep, supply tables for the other MCUs and parts
A board's serial port on the host (ADR-031, ADR-032) port.open/close/list, port.state, embsim serve --serial, the Serial panel's "Open on this computer": a board's console bridge (console.bridge) or a terminal part as a pseudo-terminal on Linux and macOS; the host program's rate on the line, a mismatch decoding as garbage both ways (esk_uart_rebaud); opening the port resets the Uno through its DTR capacitor (the reset switch held 0.7 ms, MCUSR's EXTRF set, other flags kept); bytes dropped while no program has the port; the host's bytes recorded inputs ({"base64"} for binary) tests/protocol/test_host_serial.py (tests/firmware/uno-echo: the power-on banner lost, boot 02 on opening, the upper-cased echo at 9600, garbage at 115200, no reset on closing, a reset on reopening, the reset and bytes recorded); test_session's test_uart_rebaud; SerialTerminal.test.tsx; Windows (com0com, Q16), the bridge's frames on PD0 and modem lines not implemented
Programming the Uno through its boot loader (ADR-031, ADR-032) the ATmega328P's fuses (BOOTSZ, BOOTRST, CKDIV8; board mcu.fuses, project settings.fuses), IVSEL/IVCE, SPM from the boot section (page buffer, erase and write in 4.1 ms, RWW/RWWSB/RWWSRE, NRWW halting the core, boot lock bits, SPM Ready, signature and fuse reads), erased flash running through, flash written by the program kept through a power cycle; USART0's receive FIFO and DOR0; host port bytes at the line's rate and re-timed at their own rate; embsim serve --run; the ports registry and the Arduino IDE's pluggable discovery (tools/arduino) test_avr (test_boot_loader_spm, test_boot_loader_rules, test_ivsel); tests/vendor/arduino/optiboot.py (unmodified Optiboot, avrdude uploads and verifies, the sketch runs and echoes, survives a power cycle); test_host_serial.py (the discovery lists the Uno as 2341:0043, then not after close); not checked against the Arduino IDE itself here; LPM read protection by lock bits not implemented
Boards qualified against reference data (visual benchmark V1) A board's reference.json (kind board_reference, SPEC-006 §3.1): outline, mounting holes, every terminal's pad and connector bodies from sources independent of its artwork, checked by tools/validate.py within its tolerance, every port required to have a position; the Uno R3's from Arduino's A000066 datasheet and KiCad's Arduino_UNO_R3 footprint and symbol, its artwork redrawn from it (the headers had been up to 4 mm out); the ESP32-C3-DevKitM-1's from Espressif's V1.0 dimension drawing, read from the PDF's vector paths (its 30 header pads, outline and micro-USB body; the pads had been 0.39 mm high, the RGB LED 1.1 mm and the USB 0.64 mm out), the check reading oblong (rect) pads as well as round ones tools/test_validate.py's test_uno_qualified_against_its_reference (the Uno passes; D8 0.5 mm off and the earlier USB-B place are refused); test_devkitm1_qualified_against_its_reference (the DevKitM-1 passes; its earlier J1 pin 1 and micro-USB places are refused); the BB830's body, 630-point area and continuous rails cite BusBoard's datasheet; the Uno's DIP socket, resonator, reset button and LEDs, and the breadboard's hole offsets from its edges, unqualified and declared; the NUCLEO-F446RE has no reference yet (UM1724's drawing is an image)
The Uno's USB power path: a resettable PTC fuse and the VIN switch (ADR-031, ADR-034) ptc_fuse (SPEC-004): a two-node thermal model heated by the power it passes, its resistance rising gently below the polymer's switch and steeply above it, its temperatures integrated on their own clock (component wakes) with the island touched on a 1 % change; emblink/mf_msmf050 fitted to Bourns' typical time-to-trip curve, its room the world's temperature the part's 11 fixtures on a current-limited 15 V supply: holds 0.5 A for 30 minutes, trips at 1.0 A, at 8 A within 0.15 s (not after 5 ms), at 2.4 A between 0.4 and 2 s, 0.6 to 1.0 W tripped, trips at 0.6 A at 85 C and holds 0.75 A at -40 C (the derating table, not fitted), resets once the fault is removed; the post-trip resistance, part spread and ratings' damage not modelled. On the Uno: USB_VBUS through F1 and T1 (emblink/fdn340p, a level-1 P-MOSFET with its body diode) to +5V, U5A (emblink/lmv358) turning T1 off when VIN/2 is above 3.3 V
Op-amp dominant pole and slew rate (SPEC-004 §7) opamp with gbw: an internal node integrating the input stage's drive (single pole at gbw/gain, slewing at slew, gated at the output limits so it recovers from saturation at once), the output and that node depending on the supply pins; Newton limiting on tanh's argument for the static characteristic; the LM358 (0.7 MHz, 0.3 V/us) and LMV358 (1 MHz, 1 V/us) each part's slew fixture (a follower given a 2 V step) and bandwidth fixture (a gain of 11 given a 10 mV step settling with its 11 / (2 pi GBW) time constant); further poles, phase margin, input offset, common-mode range and current limits not modelled
Workbench TypeScript workspace: typed protocol client and mock session, design system with light and dark themes; schematic editing against the engine through project transactions (place, wire, move, rotate, mirror, delete, copy, paste, duplicate, net labels and renames, buses with their live value, undo and redo, save to the project file); boards drawn as blocks of their ports, and the inside of a board or composite part opened on a read-only, live sheet; the 3D bench (ADR-027, Three.js), the Design canvas's second view and the Run perspective's Board panel: boards with their PCB features, breadboards and parts built from their packages on a desk, parts dragged into a breadboard's holes and plugged in, jumpers between holes and pins, unbuilt connections as dashed links built in one click, notes, live LEDs and controls, every edit a project transaction shared with the schematic (which hides breadboards), a keyboard list of every bench action, and the flat 2D bench (artworks with live LEDs and buttons, nets as wires between their pins) without WebGL; the clock's real-time rate; oscilloscope, logic analyzer with UART, SPI and I2C decoders, serial terminal, meters with units; board view artwork states with value maps, formats and text (SPEC-005 §8); the Debug perspective (source, disassembly, registers, breakpoints, memory, peripherals, console); the bench instruments' front panels (DS1054Z, PPK2, Logic 8) opened from their part in the inspector, the schematic's context menu, the bench's parts list or the command palette, docked in Run or floating in windows over every perspective (moved and resized by pointer or keyboard, remembered); the Verify perspective (a scenario's inputs and assertions edited in place, run with each assertion's result in its row and saved into the project; recordings replayed with the divergence shown or turned into a scenario; coverage with each file's source and counts and the functions by cycles, lcov and collapsed stacks to download); command palette; platform adapter; Tauri 2 desktop shell with the engine as sidecar and its icon pnpm typecheck, lint, test (202 tests incl. axe, the decoders, artwork states and their scoping, the bench's wires, the bench model's plugging, unplugging, jumpers and unbuilt links, every catalog part's bench shape, resistor colour codes), build pass; Playwright smoke (open, run, press, observe, export; keyboard place and wire; theme) and the bench (a breadboard added, a resistor plugged into a10 and a14, a jumper to Q1's base and its undo) pass in Chromium, and e2e/front-panels.spec.ts (a front panel opened from its part in the inspector and the context menu, floated over Design, moved from the keyboard, docked back); examples/uno-breadboard passes uno-blink-serial's scenario built on a breadboard (7/7); editing, copy and paste, and save checked in Chromium against embsim serve; the Blue Pill's boot banner decoded from USART1 frame by frame; tools/perf/large_project.py 500 inverters with 1,499 wires and 1,000 labels measured by scripts/perf.mjs in headless software-rendered Chromium: pan and part drag 16.8 ms at the 95th percentile, zoom 33 ms; usable at 1024x700. The desktop shell is built and run here on Linux (WebKitGTK 4.1 under Xvfb) with the Blue Pill example loaded, and its deb is built by tauri build; macOS and Windows installers come from CI

Observed on 2026-10-16 in this workspace: Ubuntu 24.04, GCC 13.3 and Clang 18.1, CMake 3.28, Python 3.13, Node 22. ctest on the GCC Debug build: 32 of 32 targets pass (test_analog, test_avr, test_catalog, test_engine, test_host, test_json, test_lua, test_mcu, test_mips, test_nrf52, test_pic24, test_pic32, test_riscv, test_rp2040, test_sched, test_session, catalog_fixtures, tools_unittests, catalog_sdk, importers, docs_integrity, banned_constructs, catalog_fixture_assertions, protocol_conformance, gdb_server, firmware_build, multiboard, examples_headless, record_replay, analysis, run_target, python_client); the same pass on the Clang, TinyCC and AddressSanitizer builds. The CI matrix (Linux with GCC, Clang and TinyCC; macOS with Clang; Windows with MSVC; the workbench; tools and catalog; documentation; repository policy) was observed green on the M0 pull request and on the M1 pull request (#2, head 9bc3d42, 2026-10-16) the M2 pull request (#3, all 17 checks) the M3 pull request (#4, all 17 checks) and the M4 part 1 pull request (#5, all 17 checks, after its MSVC fixes), which ran the Blue Pill golden fixture, the GDB server and the firmware build on all three platforms.

First named-part catalog batch (component work)

After integration with M3, the catalog contains 128 components, including 26 manufacturer/package entries and a generic open-collector comparator channel. The named batch adds discrete semiconductors, four regulators, full LM358P/LM393P packages, NE555P, LM35DZ, TMP36GT9Z and six full 74HC packages. part metadata is searchable and shown in the inspector; all named parts have original symbols and package illustrations. See the catalog guide for the inventory, exact supported behaviors and source-review limits. Manufacturer access was blocked during the initial batch; the follow-up source review below records the recovered evidence. No manufacturer qualification of the electrical models is claimed. This batch supplements the merged M3 implementation.

Evidence from the component-work branch on Linux, GCC 14.2, Python 3.12 and Node 24:

  • ctest --preset dev --output-on-failure --no-tests=error: 20/20 target outcomes successful. firmware_build explicitly skips without a cross compiler; all other targets execute. The new native catalog test has 23 checks.
  • catalog_fixtures instantiates all 129 catalog items (components plus board); catalog_fixture_assertions executes all 251 component fixtures through the CLI, including all old fixtures, not only schema validation. It checks nominal outputs, all HC channels and delays, loaded electrical rails, comparator pull-ups, sensor endpoints, 555 retained state/reset/divider and RC oscillation, and solver health.
  • The combined Address/undefined-behavior sanitizer build passes all 20 CTest outcomes, including Lua, catalog instantiation, fixture assertions and examples. The firmware-build wrapper explicitly skips without a cross compiler.
  • Python tools: 119 tests. tools/validate.py --all: 422 files, no errors/warnings.
  • Workbench typecheck, lint, production build and 75 existing tests pass. A real-engine Chromium check verifies named-part search, manufacturer/package labels, the inspector's datasheet link, and the Run view without page errors.
  • examples/temperature-alarm passes six assertions through the CLI. Its LM35DZ, LM393P and 2N3904 circuit lights and extinguishes an LED as temperature changes.

macOS, Windows and TinyCC have not been rerun locally for this batch. Existing CI defines those checks; remote results must be observed before claiming them. The earlier workbench Debug and hold-state findings are intentionally outside this component batch.

Manufacturer source review after the M4 merge

Based on main 22deb05, including both the named-part and M4 merges. Reviewed 25 named entries against 23 manufacturer PDFs; the three L78 entries share a source. Each entry now records revision, SHA-256, review date and page references. The source record distinguishes reviewed package facts from model qualification. TMP36GT9Z's TO-92 map is confirmed from Figure 4 and its exact ordering code from the ordering guide. The onsemi 2N7000 link and the Infineon redirect are replaced by working manufacturer PDF URLs. Nexperia BAT54 remains reference-only: the document URL is unavailable and the manufacturer CDN denies alternative document requests.

The five new electrical fixtures check LM35DZ at 4 and 30 V, TMP36GT9Z at 2.7 and 5.5 V, and a TMP36 with its ground at 1.2 V. The latter checks both absolute net voltage and the sensor's output observation relative to its own ground. Nominal transfer and pin identity are covered; electrical accuracy, thermal behavior and operating corners remain unqualified. The existing pin-map regression now checks every terminal of all 25 source-reviewed entries.

Combined integration evidence on Linux, GCC 14.2 and Python 3.12:

  • All 23 development CTest outcomes pass after the two merges; the firmware build wrapper reports its missing cross compiler explicitly.
  • Current engine catalog validation: 131 valid items (128 components, three boards), no broken or invalid entries, 259 fixtures including the boards.
  • The independent fixture runner passes 256 component fixtures and 782 assertions; all 119 Python tools tests pass.
  • Schema/semantic validation: 443 files, no errors or warnings. Documentation integrity: 89 documents, 92 requirements, no problems.
  • Both merged PRs (#5 and #6) were observed with all 17 checks passing, including macOS/Windows core, desktop and browser smoke jobs. This is evidence for the merged baseline; the source-review branch needs its own CI results.
  • No UI or native engine code is changed by this source-review follow-up.

Interactive library and circuit examples

Based on main 5cc2762 after PR #8. The interactive library record lists 18 new named entries, a reusable relay contact controller, the manufacturer source status and all electrical approximation boundaries. The catalog totals 157 components, including 44 named parts; 38 have a reviewed manufacturer source, while six retain explicitly unreviewed references. No vendor qualification is implied.

The explorer adds grouped categories/counts, multiword search, manufacturer and package filters, model-tier and named-part filters, and Overview/Pins/Models previews. Unsupported policy/broken entries cannot be placed or dragged. New artwork is original and supports live input hotspots and readable decimal values. Six native electrical primitives cover environmental resistance, photodiodes, optocouplers, relay contact timing, SPDT switches and four-pad tactile buttons. The B3F-1000 fixtures include permanent pad pairs and unused duplicate pads.

Four wired examples cover a temperature divider/adjustable alarm, a light-controlled transistor switch, an optocoupled input with offset grounds, and a transistor relay driver with an R/L coil and external flyback diode. Each has a CLI scenario and GUI controls. The real-engine browser test caught a restart/subscription defect; structural edits now reload runtime bindings and restore waveforms.

Observed locally on Linux, GCC 14.2, Python 3.12 and Node 24:

  • All 23 development and 23 Address/undefined-behavior sanitizer CTest outcomes pass. The firmware-build wrapper explicitly skips compilation without a cross compiler; other targets execute, including the M4 multiboard examples.
  • Engine catalog validation: 150 valid items, no broken/invalid entries and 311 fixtures. The independent runner passes 308 component fixtures / 897 assertions.
  • All 15 example projects validate and their scenarios pass (30 CLI invocations).
  • All 522 JSON files validate; 119 Python tool tests pass. Documentation integrity checks 94 documents and 94 requirements with no problems.
  • Workbench typecheck, lint, build and 82 UI tests pass, including accessibility checks, combined library filtering and numeric artwork formatting.
  • tests/browser/test_library.py passes in Chromium against the actual engine: manufacturer/package search, category browsing, preview sections, placement, light/dark themes, live press/release, refreshed input controls and waveform samples that cross the expected high/low limits after the placement restart.

The new branch still needs its own remote macOS/Windows/TinyCC and desktop checks. Local evidence must not be confused with the green checks recorded for older merges.

Specified but unimplemented

The PIC32MX's ADC, SPI, I2C, DMA, USB, Ethernet, CAN and watchdog; the PIC24FJ1024GB610's ADC, SPI, I2C, capture and compare modules, EPMP, RTCC, DMA, USB, watchdog and flash programming, and a dsPIC33 part; and the PIC32MZ's FPU, DSP ASE and microMIPS; the RP2040's PIO, DMA, SPI and I2C slave modes and USB; the nRF52840's radio, PPI, SPIS and TWIS; the RISC-V F and D extensions; on the STM32F1 DMA, SPI and I2C slave modes, the ADC's injected group and the timers' input capture, on the ATmega328P SPI and TWI slave modes, on the FE310 the PMU, QSPI0's programmed mode and I2C (their registers hold values and raise mcu.unsupported_access); DWARF variables (debug.variables); the GDB server over the session protocol (debug.gdb); a debugger's choice of core on a part with two (it sees the core that runs next); full event traces and analog observations in recordings (SPEC-012 §1, §5), native models (SPEC-013 beyond §2), the per-project lua_budget setting (the budget is fixed), ZIP64 and compressed formats other than deflate for library archives, the catalog.validate protocol method (the CLI has it), binary waveform frames (samples are JSON arrays with encoding: "json"), a fault report for the AVR (it has no faults to decode) and MIPS16e instructions disassembled in it, editing inside a board or composite (the inside is read-only), signed installers and an update channel, importers for Eagle, Altium and EasyEDA.

Validation recorded in this workspace

Recorded as it happens: the checks listed above, on the dates given.

Known limits and unresolved evidence

  • Fast digital traffic on an analog net is costly under the electrical policy: on the Uno, D13 (SCK) carries the L LED and its resistor, so every 4 MHz SPI clock edge is an analog step (about 25 times slower than the functional policy for a polling SPI sketch). Sketches that need no analog behaviour run their examples under the functional policy (rfid DumpInfo); the paced real-time work (ADR-032) will take it up.
  • An MCU sees an input that comes from an analog comparator crossing at the start of the quantum after the crossing, at most core_quantum_ps (1 µs by default) late (ADR-019); digital inputs are exact, and so is a device's answer to the core's own edge on an analog net (the next quantum waits out the edge's ramp).
  • Five USART timing deltas from EmbCC's Blue Pill fixture are documented in tests/firmware/bluepill-golden/deltas.json (frames on the pin take their full duration; EmbCC's are instantaneous).
  • esk_host_run on Windows (CreateProcess) is exercised only by CI (firmware_build passed on the M1 run).
  • The main branch is protected by the repository's ruleset; pull requests run the CI matrix.
  • Instruction timing of every planned core is an estimate except AVR (ADR-015).
  • A supply symbol (emblink/vcc) on a net that a component model drives (a regulator's output) is not added as a source (analog.supply_driven): feed a board's regulated rail from a voltage source, as the Uno and HiFive1 examples do.
  • The Debug perspective's register view lists registers numbered below 64, so a RISC-V core's CSRs are not shown there (GDB reads them); its memory view starts at 0x20000000 whatever the core.
  • An FE310 starts at 0x20010000, where the HiFive1's bootloader jumps: the mask ROM and the bootloader are not simulated.
  • The RP2040's bootrom is a stand-in (core/mcu/rp2040/boot.c): it boots boot2 from flash as the bootrom does and the host does its documented functions (ADR-021), but the BOOTSEL button has no effect and the XIP cache is not modelled.

Updating this page

Record source revision, configuration, tool versions, runner results, cases, skips and artifacts together. Move a feature to implemented only after inspecting the code; call a requirement verified only after its named evidence passes.