Simple Open EtherCAT Master (SOEM) is a lightweight, portable C library that implements the EtherCAT master protocol stack. It provides full support for CoE (CANopen over EtherCAT), FoE (File over EtherCAT), SoE (Servo over EtherCAT), EoE (Ethernet over EtherCAT), Distributed Clocks (DC), SII (Slave Information Interface), and network redundancy (dual NIC). The architecture is modular: an OS abstraction layer (osal) encapsulates platform-specific threading, timing, and memory operations, while a hardware abstraction layer (oshw) handles raw network access via sockets (Linux, Windows, RTEMS, VxWorks, etc.). The core library functions (ecx_*) operate on a context structure, enabling multiple master instances. Key implementation patterns include an indexed buffer management system for out-of-order frame handling, a thread-safe mailbox pool and queue, and a circular error ring buffer. The library is not a standalone application; it is designed to be embedded into industrial real-time control systems. Sample applications demonstrate cyclic process data exchange, SDO access, EEPROM manipulation, and firmware updates. The codebase is mature (2005ā2025) and under active development, with a dual GPLv3/commercial license. Some technical drift exists due to bundled third-party WinPcap headers and several platform-specific contributor directories that may lag behind core updates. Overall, the library demonstrates strong engineering with clear separation of concerns and portability, making it a solid foundation for EtherCAT master development.
Adafruit_ILI9341 is an Arduino library providing a driver for ILI9341-based TFT displays. It supports SPI (both hardware and software) and parallel interface modes, inheriting from the Adafruit_SPITFT base class for low-level communication. The core functionality includes display initialization via a PROGMEM command table, rotation, color inversion, scrolling, and address window setting with caching optimization. The library ships with a comprehensive set of examples covering graphics benchmarks, touch painting, Mandelbrot rendering, and embedded bitmaps. It is the de facto standard driver for Adafruit's 2.8" and 2.4" TFT displays.
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.
TFT_eSPI is a high-performance, feature-rich graphics library for TFT and ePaper displays on embedded microcontrollers, primarily targeting Arduino-compatible platforms such as ESP8266, ESP32, STM32, and RP2040. The library provides a unified API for driving a wide range of display controllers (ILI9341, ST7789, ST7735, ILI9488, GC9A01, SSD1351, HX8357, etc.) over SPI, 8-bit parallel, or 16-bit parallel interfaces. It includes extensive drawing primitives (lines, circles, arcs, ellipses, polygons, anti-aliased shapes), sprite-based off-screen rendering, touch screen support (XPT2046), a button widget, and a sophisticated anti-aliased (smooth) font system that can load fonts from flash or filesystem (SPIFFS/LittleFS/SD). The library is highly configurable via compile-time defines and user setup files, and it leverages hardware-specific optimizations like DMA transfers, PIO state machines (RP2040), and dual-core processing. It is designed for real-time embedded GUIs, instrumentation, and interactive projects, and is widely used in the maker community.
ObjectBox Java is an open-source, embedded NoSQL database library for Java and Kotlin, targeting Android, JVM, and desktop platforms. It provides a high-performance, native-backed object persistence engine with type-safe querying, reactive data observation, object relations (ToMany/ToOne), vector search via HNSW indexes, and optional client-server or mesh peer-to-peer synchronization. The code is organized into multiple Gradle modules including a core `objectbox-java` module with JNI bindings, an annotation API (`objectbox-java-api`), Kotlin extensions, RxJava 2/3 adapters, Android-specific integrations (LiveData, Admin web UI, Paging DataSource), and a mesh sync module using Google Nearby Connections. The architecture is library-centric with a clear separation between Java-facing API, internal serialization (vendored FlatBuffers), and native runtime. Extensive unit and integration tests cover core CRUD, transactions, queries, relations, sync, and error handling. The repository is actively maintained with a version 6.0.0-beta, publishes to Maven Central, and uses multi-platform CI (GitLab, Jenkins). While the codebase includes some legacy APIs and generated FlatBuffers code, the core abstractions exhibit solid software engineering practices with reusable patterns for reactive subscriptions, property converters, and cross-platform native library loading.
This repository is a Yocto/OpenEmbedded meta-layer that builds **balenaOS**, a container-optimized embedded Linux distribution for IoT devices. It is not a runnable application but a build system consuming board support packages (BSPs), kernel patches, systemd services, and configuration recipes to produce a complete OS image with balenaEngine, balena-supervisor, OTA updates (hostapp-update), rollback, secure boot (UEFI, TPM2), disk encryption, and extensive networking (NetworkManager, ModemManager, OpenVPN, redsocks). The architecture separates common recipes (`meta-balena-common`) from Yocto-version-specific overrides (kirkstone, scarthgap, dunfell, etc.), enabling support for a wide hardware matrix (Raspberry Pi, Jetson, Intel NUC, BeagleBone, etc.). Despite being a build system, the code exhibits many software engineering best practices: modular shell libraries (os-helpers), bbclass abstractions for signing, kernel config injection, and container extension runtime. Maintenance is active with frequent version bumps, CVE backports, and CI workflows for 30+ board targets. The primary data flows are from source recipes ā bitbake ā OS image artifacts, with OTA updates using A/B partitions and health-check rollback. External dependencies include Yocto/Poky, various open-source components (busybox, systemd, NetworkManager, wpa_supplicant, grub, efitools, etc.), and Rust/Go cross-compilation toolchains.
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.
This is the U-Boot bootloader fork for NXP i.MX SoCs, providing hardware initialization, boot loading, and driver support for a vast range of ARM, RISC-V, and other embedded boards. It implements the U-Boot driver model, SPL/TPL boot stages, verified boot, and extensive command-line interface for embedded development and debugging. The codebase is a mature, production-grade firmware project with support for hundreds of SoCs and boards, particularly NXP i.MX, TI K3, Rockchip, and Renesas platforms. It features a modular driver model, device tree support, secure boot capabilities, comprehensive testing infrastructure, and image generation tools like binman. While the repository is well-maintained, it contains legacy code and significant duplication across board-specific files.
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.
EmuTOS is a complete, GPL-licensed replacement operating system for Atari ST/TT/Falcon, ColdFire, and Amiga computers. It reimplements the entire TOS stack: BIOS (hardware drivers, boot), GEMDOS (file system, process management), VDI (graphics primitives), AES (windowing and event management), a desktop environment (EmuDesk), and a command-line interpreter (EmuCON2). The codebase is highly modular with clear layer separation, extensive conditional compilation for over a dozen hardware variants, and a build system that generates ROM images for each target. It is not a traditional application but a firmware ROM; however, from a software engineering perspective, it exhibits application-like structure with entry points (startup.S, biosmain, gem_main), a GUI, and a CLI. The system is actively maintained, with a rich history of reverse-engineering Atari TOS behavior and fixing emulator quirks. It relies on a 68k/ColdFire cross-compiler toolchain and GNU Make.
This is a high-level C++ library for building LoRaWAN end-devices on Arduino-compatible platforms. It wraps the MCCI LMIC stack and provides a structured API for OTAA/ABP provisioning, sending uplinks, receiving downlinks, link-check management, and persistent session-state save/restore. The library supports nine network operators (TTN, Actility, Helium, ChirpStack, Generic, machineQ, Senet, Senra, Swisscom) across eight LoRaWAN regions, selected at compile time via preprocessor macros. The architecture uses a two-level inheritance hierarchy: an abstract `Arduino_LoRaWAN` base class, network-specific base classes, and region-specific concrete classes. The LMIC C callback `onEvent()` is routed through a singleton to `DispatchEvent()`, which drives a standard event processor and up to four registered listeners. Application code subclasses a concrete network/region class and overrides virtual methods for provisioning and persistence. Key entry points are `begin()`, `loop()`, `SendBuffer()`, `RegisterListener()`, and `SetLinkCheckMode()`. The session-state subsystem is notably sophisticated: it serializes frame counters, channel masks, band duty-cycle state, and MAC parameters into versioned, tagged structures that can be stored in arbitrary non-volatile memory and restored after reboot. The code is generally well-structured and professional, with clean separation of concerns and careful handling of LMIC internals. However, the repository contains many near-empty per-network/per-region boilerplate files, and the CI pipeline still relies on Travis CI with an old Arduino IDE version. There are no unit tests; regression coverage comes from compile-testing example sketches across multiple boards and regions. The library is actively maintained, but release metadata (library.properties vs. header version) and CI infrastructure lag behind the code itself.
This repository is the RISC-V GNU Compiler Toolchain build system. It provides the infrastructure to build cross-compilation toolchains targeting RISC-V architectures (RV32/RV64) with various C libraries (newlib, picolibc, glibc, musl, uClibc). The codebase consists of autotools-based configure scripts, Makefile templates, vendored Linux kernel UAPI headers for RISC-V, CI workflows, and test infrastructure including DejaGnu board configurations and regression test allowlists. It is not an end-user application but a build orchestration project that compiles GCC, binutils, and associated libraries from source. The architecture is a classic GNU autotools build system with submodule dependencies. Key entry points are the top-level `configure` script and `Makefile.in`, which drive the build of all toolchain components. The repository also includes scripts for running tests on QEMU and Spike simulators, and CI pipelines for continuous integration and nightly releases.
This repository provides a comprehensive, production-grade Field-Oriented Control (FOC) library for Permanent Magnet Synchronous Motors (PMSM) targeting embedded microcontrollers (STM32G4, CH32V3). It is written in C and organized into modular algorithm files covering coordinate transforms (Clarke, Park), PWM modulation (SVPWM, SPWM), multiple control strategies (PID, LADRC, SMC, STA), sensor feedback (encoder, Hall, sensorless observers like HFI, SMO, NLFO), and advanced features (MTPA, field weakening, harmonic suppression, cogging calibration, dead-time compensation, feedforward, disturbance observer, parameter identification). The architecture is driven by interrupt-based control loops (high-frequency current loop, low-frequency state machine, and serial communication loop) with compile-time configuration via macro switches and user-supplied hardware abstraction layers. The repository also includes open-source hardware designs (schematic and PCB for a robot-joint motor driver), a QT-based host computer application, Simulink simulation models, and a complete STM32G4 example project. Although the library contains multiple coexisting versions and v4.0.0 is partially incomplete, the core modules are well-crafted, independently reusable, and demonstrate advanced control theory implementation suitable for robotics, drones, industrial servos, and electric tools.
This repository provides ESPHome firmware configurations and custom components to control LoctekMotion/FlexiSpot standing desks via Home Assistant. The core functionality is implemented as two custom ESPHome sensor components: `loctekmotion_desk_height` for reading desk height from a 7-segment display protocol over UART, and `loctekmotion_desk_command` for detecting keypad button presses. The primary entry points are the YAML package files (`packages/office-desk-esp32.yaml` and `packages/office-desk-esp32-passthrough.yaml`) which wire up UART communication, GPIO control for the screen wake pin (PIN20), and expose cover, button, switch, and number entities to Home Assistant. The architecture is a typical ESPHome device: a single microcontroller (ESP32/ESP8266) running the ESPHome firmware, communicating with the desk controller via a 9600 baud UART serial link. The repo also contains archived Arduino and Raspberry Pi implementations, but the active development is focused on the ESPHome components. It is a well-structured IoT integration project with CI/CD, linting, and test compilation for multiple board variants.
ESP3D is a feature-rich embedded firmware for ESP8266/ESP32 microcontrollers, designed to serve as a Wi-Fi/Ethernet bridge and full-featured controller for 3D printers, CNCs, and similar equipment. The firmware provides a modular architecture with support for multiple network protocols (HTTP, WebDAV, FTP, Telnet, WebSocket, Bluetooth), a web-based user interface, file system management (SD card, flash filesystems like LittleFS/SPIFFS), sensor integration (DHT, BMP280), Lua scripting, and graphical displays via LVGL or TFT_eSPI. It includes a comprehensive command system (ESPxxx commands) for configuration and control, with authentication levels and persistent settings. The codebase demonstrates solid engineering for an embedded Arduino project, with clear separation of concerns between core services (serial, network, display, filesystem) and a message-passing inter-module communication pattern. It bundles many well-known third-party libraries (LVGL 8.2.0, TFT_eSPI 2.5.43, SdFat 2.2.3, EspLuaEngine, arduinoWebSockets) directly in the repository, ensuring reproducible builds but also creating a maintenance burden. The firmware is actively maintained with a responsive issue tracker and regular commits, though the reliance on pinned library versions and heavy conditional compilation introduces some technical drift.
This repository provides a userspace C library for controlling WS2812/SK6812 RGB(RGBW) LEDs on Raspberry Pi single-board computers. The core architecture uses Raspberry Pi's DMA (Direct Memory Access) controller to feed data to the PWM, PCM, or SPI peripheral, generating the precise timing signals required by the LED protocol without burdening the CPU. The library is structured as a static/shared C library with a clean API (ws2811_init, ws2811_render, ws2811_fini) that abstracts hardware details such as GPIO configuration, clock setup, and memory allocation via the VideoCore mailbox interface. The code is well-documented with register-level header files (pwm.h, pcm.h, dma.h, clk.h, gpio.h) that could be reused in other Pi projects. Building is supported via both SCons and CMake, and Debian packaging files are included. The library is the foundational component for numerous language bindings (Python, Rust, Java, etc.) and is widely used in LED projects like unicorn-hat and pixel-art displays.
flutter-pi is an embedded Flutter engine for Linux systems that enables running Flutter applications on hardware like the Raspberry Pi without an X11 or Wayland display server. It leverages DRM/KMS for display management, GBM for buffer allocation, and supports both OpenGL ES and Vulkan rendering backends. The application initializes the Flutter engine via its embedder API, sets up input handling (via libinput/evdev), and runs a main event loop (using systemd sd-event) to process vsync, input, and platform messages. The architecture is modular, separating concerns into core components: windowing, rendering (OpenGL/Vulkan), compositor, input, and a plugin system for extending functionality (e.g., audio, video, text input). Utilities for reference counting, logging, collections, and geometry are used throughout the codebase. The plugin system allows dynamic registration of Flutter platform channel handlers, enabling communication between Flutter Dart code and native plugins. While the codebase demonstrates solid engineering practices with reusable patterns (such as thread-safe reference counting and an event loop abstraction), it maintains tight coupling to the Flutter embedder API and Linux-specific graphics stack. Ongoing maintenance is evident through active CI/CD workflows and recent commits, though the presence of TODOs and conditional compilation flags indicates areas of technical debt and ongoing work.
This is an Arduino library for the USB Host Shield Rev. 2.0 (MAX3421E chip), providing a comprehensive USB host stack for embedded systems. It supports a wide range of USB and Bluetooth devices including game controllers (PS3/4/5, Xbox 360/One, Switch Pro, Wii), HID keyboards/mice, Bluetooth dongles (HID, SPP), MIDI devices, CDC serial adapters, mass storage, and USB hubs. The library implements state-machine-driven USB enumeration, control/bulk/interrupt transfers, a custom Bluetooth HCI/L2CAP stack, and HID report descriptor parsing. It is modular with device-specific drivers in separate files, event-driven callbacks, and PROGMEM string tables for RAM efficiency. The codebase is well-structured but shows signs of platform-specific workarounds, code duplication in examples, and reliance on reverse-engineered protocols that may drift with firmware updates.
This repository is a binary distribution packaging project for OpenOCD (Open On-Chip Debugger), an embedded debugger tool. It does not contain the OpenOCD source code itself but provides build scripts, CI workflows, and a documentation website to produce cross-platform binaries (Windows, macOS, Linux) and publish them as xpm/npm packages and GitHub releases. The architecture is a build automation system: shell scripts orchestrate compilation with Docker (for Linux/Windows) and native builds (macOS), GitHub Actions handle testing and release, and a Docusaurus website provides user and maintainer documentation. Key entry points include the top-level package.json (defining xpm actions), build-assets/scripts/build.sh, and the CI workflows. External dependencies include OpenOCD upstream source, libusb, libftdi, hidapi, Docker images, and the xbb-helper-xpack project. The project is actively maintained with frequent releases and extensive documentation, though some CI workflows use outdated action versions and rely on specific Docker images that may become stale.