LVGL (Light and Versatile Graphics Library) is an embedded GUI library written in C, providing a comprehensive widget toolkit (30+ widgets), style system, layout managers (flex, grid, split), animation framework, and multiple rendering backends (software, GPU-accelerated via VG-Lite, NanoVG, OpenGL ES, and hardware-specific backends for various MCU/MPU platforms). It is designed for resource-constrained devices with a small memory footprint (~100kB RAM for typical UIs) and supports a wide range of display drivers (SDL, Wayland, DRM, UEFI, Windows, and many embedded display controllers) and input devices (touch, keypad, mouse, gestures). The library features a public/private header pattern for encapsulation, a configurable build system via Kconfig, extensive Unity-based test suites with screenshot comparison, and a GDB plugin for runtime introspection. It is actively maintained with frequent commits, comprehensive CI/CD, and a large ecosystem of examples and demos.
OpenFFBoard is an open-source force feedback interface board designed for simulation devices like steering wheels and joysticks. The firmware provides force feedback effects via USB HID to gaming/simulation software while processing inputs from encoders, analog sources, buttons, and CAN bus. It features a modular architecture based on FreeRTOS with TinyUSB USB stack, supporting multiple motor drivers (PWM, TMC4671, ODrive, VESC, RMD) and a command interface for runtime configuration. Settings persist to flash/EEPROM via an abstraction layer with automatic registration. The project targets STM32 microcontrollers (F407VG, F407VG_DISCO, F411RE) and includes extensive hardware abstraction layers, plugin architecture for extensibility, and clean C++ wrappers for FreeRTOS primitives.
Trice is an embedded logging and tracing toolchain consisting of a lightweight C instrumentation library for microcontrollers and a Go-based host CLI tool. The C library provides variadic macros that emit compact binary records (ID + values) instead of format strings, drastically reducing flash and bandwidth usage. The Go tool manages Trice IDs (insert, clean, bind), decodes incoming binary streams from targets over UART, RTT, TCP/UDP, or file, and displays formatted logs with timestamps, colors, and filtering. It supports multiple buffer strategies (stack, static, double, ring), framing protocols (COBS, TCOBS), optional XTEA encryption, and local logging on the target itself. The architecture is a classic host-target split: the target runs the C library, the host runs the Go CLI. The codebase is well-tested with a large matrix of CGO test configurations and CI pipelines for multiple STM32 example projects. It is actively maintained with frequent releases and a responsive issue tracker.
IronOS is embedded firmware for a family of portable soldering irons (TS100, TS80/P, TS101, Pinecil, Pinecil V2, MHP30, Sequre S60/S60P/T55/S99). The firmware runs on three distinct SoC architectures — STM32F103 (Cortex-M3), GD32VF103 (RISC-V), and Bouffalo BL702 (RISC-V) — behind a single board-support abstraction. It implements PID temperature control of the soldering tip via PWM, thermocouple uV-to-temperature conversion with cold-junction compensation, USB-PD (FUSB302/FUSB302B/HUB238/FS2711) and Quick Charge 3.0 power negotiation, accelerometer/hall-effect-based motion detection for sleep, an OLED menu UI, and a full BLE GATT stack on Pinecil V2. The core control loop is: ADC samples tip thermocouple voltage (with PWM holdoff timing) -> gain/op-amp compensation and lookup-table interpolation to Celsius -> PID controller -> PWM duty to the heating element, with input voltage/current monitoring for wattage budgeting and thermal runaway protection.
EmuFlight is a real-time embedded flight controller firmware for multirotor drones, forked from Betaflight/Cleanflight. It runs on STM32F4/F7/H7 microcontrollers, providing sensor fusion (gyro, accelerometer, barometer, GPS), PID control, motor mixing, telemetry, and on-screen display. The architecture is bare-metal with a cooperative scheduler, modular driver abstraction (vtable patterns for serial ports, displays, VTX, sensors), and a persistent parameter group (PG) configuration system. Key data flows: sensor inputs → Kalman/dynamic notch filters → PID → mixer → motor outputs; RC input via various protocols; telemetry/blackbox logging output. External dependencies include STM32 HAL, CMSIS DSP, and MAVLink libraries. The codebase is well-structured with unit tests (Google Test) and CI, though it retains some legacy drivers and conditional complexity from the Betaflight lineage.
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.
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.
EIDE (Embedded IDE) is a VS Code extension for embedded microcontroller development, supporting a wide range of architectures (8051, STM8, Cortex-M, RISC-V, MIPS) and toolchains (GCC, Arm Compiler, IAR, SDCC, COSMIC, LLVM). It provides project management (create, import from Keil/IAR/Eclipse), build system integration, flash programming (JLink, STLink, OpenOCD, pyOCD, probe-rs), and analysis tools (callgraph visualization, stack usage, memory map, CMSIS pack management). The extension includes a web-based configuration UI, a Model Context Protocol (MCP) server for headless tool access, and custom language support for embedded assembly/linker scripts. The architecture is a VS Code extension with TypeScript core, Vue.js webviews, and platform-specific .NET binaries for build/flash operations. While deeply functional and feature-rich, the codebase exhibits some monolithic files, vendored outdated dependencies (Bootstrap 4.3.1, Vue 2.6), and a high degree of coupling between project management and UI logic.
This repository contains the firmware for FreeJoy, a highly configurable USB game controller (joystick, HOTAS, steering wheel) based on the STM32F103 (Blue Pill). The firmware implements a composite USB device with joystick HID, custom HID (for configuration), and CDC (for SimHub telemetry). It supports a wide variety of input sensors (ADC, magnetic encoders via SPI/I2C), buttons (GPIO, shift registers), encoders, LEDs (matrix and addressable RGB), and PWM outputs. Configuration is stored in flash and managed via a companion PC tool. A separate USB HID bootloader enables firmware updates. The code is bare-metal, leveraging the deprecated STM32 Standard Peripheral Library and CMSIS 3.5.0, with SEGGER RTT/SysView for debugging. The architecture is monolithic but modular within the firmware, with clear separation between bootloader and application.
This repository is a large collection of bare-metal firmware projects for STM32 microcontrollers (F0, F1, F3, G0, G4 families), authored by Edward V. Emelianov. It contains dozens of independent example and application projects covering USB CDC virtual serial ports, CAN bus gateways, sensor drivers (BMP280, MLX90640, DHT22, DS18B20, etc.), stepper motor control, servo control, LED displays, and more. The code is written in C with direct register access (no HAL) and uses a custom USB stack with ring-buffer-based I/O. Each project is self-contained with its own main.c, hardware initialization, and command parser, typically communicating over USB or UART with a simple text-based protocol. The architecture is monolithic per project: a main loop processes periodic tasks (ADC sampling, sensor reads, CAN message handling) and responds to commands received via USB or UART. Key entry points are the main.c files in each project directory. Data flows involve sensor acquisition (ADC, I2C, SPI), optional processing (median filtering, dew point calculation), and output via USB CDC, CAN, or UART. External dependencies are minimal: only an ARM GCC toolchain and the STM32 CMSIS-like headers provided in the inc/ folder. The repository also includes KiCad PCB designs and gerber files for many projects, indicating a full hardware+software development cycle. While the code is functional and covers a wide range of embedded use cases, it suffers from significant code duplication (ringbuffer.c, usb.c, strfunc.c are copy-pasted across many projects) and lacks a centralized library or build system. Deprecated folders and multiple versions of similar projects (e.g., chronometer_v2, chronometer_v3) add clutter. The repository is best viewed as a personal collection of working examples and prototypes rather than a polished framework. However, several components (ring buffer, string utilities, USB stack) are well-implemented and could be extracted for reuse in other STM32 projects.
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.