Embassy is a next-generation embedded framework for Rust that enables asynchronous programming on microcontrollers using async/await syntax. It provides Hardware Abstraction Layers (HALs) for multiple MCU families (STM32, Nordic nRF, Raspberry Pi RP2040/RP23xx, TI MSPM0, NXP MCX-A, etc.), an async executor for cooperative multitasking, timekeeping utilities, networking stack, USB device/host stack, Bluetooth support, bootloader/DFU capabilities, cryptographic primitives, and synchronization primitives. The framework emphasizes safety, correctness, and energy efficiency through Rust's compile-time guarantees, with an executor that automatically enters low-power sleep when idle. Applications are structured around peripheral initialization, async task spawning via #[embassy_executor::task], and event-driven communication using Embassy's synchronization primitives.
The Raspberry Pi Pico SDK is a comprehensive C/C++ software development kit for the RP2040 and RP2350 microcontrollers, providing a hardware abstraction layer, peripheral drivers, synchronization primitives, and build-system integration for embedded firmware. It is not an application itself but a library and toolchain ecosystem consumed by firmware projects, targeting ARM Cortex-M0+/M33 and RISC-V Hazard3 cores. The SDK is architected around modular libraries (pico_*, hardware_*) that expose register-level access via auto-generated structs, runtime initialization with ordered callbacks, an async context abstraction for WiFi/USB/timers, and a lightweight resource claiming system for peripherals. It supports both CMake and Bazel builds, includes a PIO assembler (pioasm), and provides a host-simulation layer for desktop testing. The codebase exhibits strong engineering discipline with extensive use of weak function overrides, config macros, and static assertions, though it carries the inherent complexity of supporting two chip generations, two architectures, and multiple third-party middleware stacks (TinyUSB, lwIP, BTstack, mbedTLS).
This repository is the foundational Rust library for bare-metal development on ARM Cortex-M microcontrollers. It provides the essential runtime startup code (cortex-m-rt), low-level peripheral access (cortex-m), and debugging support (cortex-m-semihosting). The codebase implements critical safety mechanisms for embedded systems, such as preventing multiple instances of peripherals via the singleton pattern, ensuring correct stack alignment, and managing exception handling through sophisticated procedural macros. It serves as the bedrock for the Rust embedded ecosystem, enabling safe interaction with hardware registers and interrupt controllers without a standard library or operating system. The architecture is modular, separating the runtime (cortex-m-rt) from the peripheral access layer (cortex-m) and type traits (cortex-m-types). The startup code includes a robust linker script (link.x) that handles memory layout, vector table generation, and RAM initialization in assembly to guarantee correctness before Rust code executes. The repository also includes a comprehensive testsuite that runs on QEMU and physical hardware to validate interrupt handling, critical sections, and stack management across different Cortex-M variants (M0, M3, M4, M7, M33). This is a high-quality, production-grade library maintained by the Rust Embedded community. It demonstrates deep understanding of the ARM architecture, Rust's safety guarantees, and the constraints of embedded development. The code is heavily tested with compile-fail tests to ensure macro-generated code adheres to strict signatures and safety requirements.
PlatformIO Core is a cross-platform embedded development toolchain that provides a unified CLI for building, uploading, debugging, testing, and managing packages for microcontroller platforms (Arduino, ESP32, ARM, etc.). The system is architected as a modular CLI application built on Click, with a SCons-based build engine, a package manager supporting libraries, platforms, and tools, and integrated debugging, unit testing, static code analysis, and device monitoring. Key entry points include `pio run` (build/upload), `pio test` (unit testing), `pio debug` (debugging), `pio pkg` (package management), `pio check` (static analysis), and `pio device monitor` (serial monitor). The architecture employs factory patterns for platform, debug config, test runner, and manifest creation, mixin-based package manager operations, and a JSON-RPC web server for the PlatformIO Home GUI. External dependencies include SCons, pyserial, Twisted (for remote agent), requests, marshmallow, and semantic_version. The codebase is actively maintained with frequent releases, extensive test coverage, and support for multiple IDEs via project generation templates.
SwiftIO is a Swift framework for microcontrollers that provides an easy-to-use interface for hardware peripherals. It abstracts low-level hardware details into Swift classes, allowing developers to interact with GPIO, ADC, PWM, timers, communication protocols (I2C, SPI, UART), and more without dealing with complex register manipulation. The library is structured into a C layer (CSwiftIO) for direct hardware access and a Swift layer that wraps this functionality in a safe, idiomatic API. It emphasizes error handling through Swift's Result type and provides consistent patterns for resource management and peripheral interaction.
MicroLink v2 is a production-ready Tailscale VPN client for ESP32-S3 devices that establishes secure WireGuard tunnels through Tailscale's control plane. It implements the full Tailscale protocol stack including Noise protocol for control plane encryption, HTTP/2 framing, DISCO peer discovery, STUN for NAT traversal, DERP relay fallback, and WireGuard encryption via wireguard-lwip integration. The architecture uses a multi-task FreeRTOS design with separate tasks for coordination, WireGuard management, DERP transmission, network I/O, and application logic, communicating via message queues and event groups. Key features include WiFi/cellular network failover with health monitoring, zero-copy WireGuard receive option for high-throughput scenarios, NVS-based peer caching with LRU eviction, and an HTTP configuration server for runtime management. The code demonstrates strong protocol fidelity through direct reference to Tailscale's Go source files while adapting to embedded constraints.
mruby/c is a lightweight implementation of the mruby bytecode interpreter optimized for microcontrollers with minimal RAM (<40KB). It executes Ruby bytecode generated by the mrbc compiler, supports cooperative multitasking via a built-in scheduler (rrt0), and provides a C API for embedding. The architecture splits into a core VM engine, a configurable memory allocator, a hardware abstraction layer (HAL) for portability across MCU architectures, and built-in class implementations for common Ruby types. The codebase is well-structured and demonstrates strong embedded software engineering practices, with reusable patterns for memory management, value boxing, and platform abstraction. It is not a data/research project; it is a production-quality embedded runtime.
RVX is a fully functional RISC-V RV32I microcontroller IP core written in synthesizable Verilog, targeting FPGAs (specifically Digilent Arty A7 and Cmod A7 boards). It implements the RV32I base ISA v2.1 plus the Zicsr extension and Machine-Level ISA v1.13. The core includes a custom system bus (`rvx_bus`) that can be parameterized with an arbitrary number of memory-mapped slaves, and a set of peripherals: UART, GPIO, SPI, and machine timer (`mtime`/`mtimecmp`). The repository provides complete example projects for bare-metal and FreeRTOS, including board-specific wrapper modules, constraint files, and TCL scripts for Vivado project creation. The software examples use CMake with the RISC-V GCC toolchain and the `libsteel` hardware abstraction library. A comprehensive verification suite covers all RV32I instructions via RISC-V Architecture Test programs, alongside Cocotb-based peripheral tests and a Verilator simulation framework with C++ harness. The bus interface uses a simple request/response handshake with write strobes, which is clean but non-standard (not AXI/Wishbone). The core is a single-monolithic file (~1300 lines) with a 4-state FSM and no pipelining, making it compact but harder to modify. Overall, the repository is a well-documented, professionally structured open-source hardware project with strong testing practices, suitable for FPGA-based embedded systems education or low-complexity control applications.
This repository is a comprehensive bare-metal microcontroller programming guide, providing step-by-step examples from minimal firmware to a full embedded web server with a device dashboard. The code targets ARM Cortex-M and RISC-V microcontrollers (STM32, TI TM4C, RP2040, ESP32-C3, nRF52840, etc.) and uses only GCC, a datasheet, and the Mongoose networking library. The architecture is bare-metal, single-threaded with an event loop in the webserver step; it demonstrates direct register manipulation, interrupt handling, UART, SysTick, clock configuration, printf retargeting via newlib syscalls, CMSIS integration, and Ethernet with built-in TCP/IP (MIP). The repository also includes reusable project templates for blinky, CLI, and LittleFS filesystem. Despite being educational, the code is production-quality and follows embedded best practices such as non-blocking timers, hardware abstraction layers (hal.h), and modular startup code.
micropython-ulab is a C library that provides a subset of NumPy and SciPy functionality for MicroPython and CircuitPython on microcontrollers. It implements a multi-dimensional ndarray type with broadcasting, universal functions, linear algebra (Cholesky, eig, inv, QR), FFT, signal processing (sosfilt), numerical integration, optimization, random number generation, and file I/O. The library is designed for performance and memory frugality, using compile-time feature flags (ulab.h) to trim flash usage. Key entry points include ulab.numpy (array creation, math, stats, linalg, fft, io), ulab.scipy (integrate, linalg, optimize, signal, special), and utils (buffer conversion, spectrogram). The architecture is modular with separate C modules for each functional area, a reusable user module for custom extensions, and extensive test coverage for 1Dā4D arrays and complex numbers. The library is actively maintained with frequent releases, but some SciPy functions remain incomplete and the codebase has repetitive dtype-dispatch macros that increase maintenance burden.
This repository contains the hardware design files, documentation, and support materials for the SIM7000 LTE Shield, an Arduino-compatible shield that adds LTE CAT-M1/NB-IoT connectivity and GNSS capabilities. The repository does not contain the actual software library (which resides in a separate Botletics-SIM7000 repo), but focuses on the hardware implementation, including PCB design files, schematics, AT command documentation, and firmware update tools. The hardware design features the SIM7000 series module from SIMCom, integrated with a uFL antenna connector for LTE, a separate uFL for GNSS (GPS/GLONASS/BDS/Galileo), a SIM card holder, USB interface for debugging/firmware updates, level shifting circuitry (TXB0104) for 3.3V/5V compatibility, status LEDs, and an MCP9808 I2C temperature sensor. The power supply design includes appropriate filtering and regulation for the cellular module. The PCB layout demonstrates attention to RF considerations with proper component placement and routing. Documentation includes comprehensive AT command logs showing how to configure the module for various network operations (registration, TCP/IP, SSL/TLS, MQTT), GNSS functionality, and sensor interfacing. These logs serve as practical examples for developers looking to implement cellular IoT applications. The repository also provides firmware update procedures using Qualcomm's QPST tool, though this is specific to the module manufacturer's update process. While the actual firmware/software for running applications on the shield is in a separate repository, this hardware repository provides a complete, validated reference design that enables developers to create IoT applications requiring cellular connectivity and location tracking. The design appears to be current, well-executed, and suitable for reuse as a starting point for similar LTE/GNSS shield projects.
This repository contains firmware for a programmable e-ink badge using the Pimoroni Badger2040 hardware. It provides multiple applications (badge display, QR code viewer, fortune quote viewer) that can be launched via physical buttons, with a launcher managing state persistence between runs. The system is built in MicroPython and saves application state to JSON files in a /state directory. While designed as a fun project to showcase personality and retro technology affection, it demonstrates solid embedded systems practices with modular app design and persistent state management.
This repository is a curated list (awesome list) of embedded systems resources, including tutorials, books, tools, and links for various microcontrollers, RTOS, Linux kernel development, and more. It contains no executable code, libraries, or applications. The sole source file is a README.md that aggregates external references. As a static index, it serves as a reference for embedded engineers but offers no software architecture, reusable components, or functional logic.