Tasmota is a monolithic firmware application for ESP8266/ESP32 microcontrollers that enables local control of IoT devices via MQTT, HTTP, Serial, or KNX protocols. It provides a web-based configuration interface, OTA update capabilities, automation features (timers/rules), and runtime extensibility through the Berry scripting language. The architecture integrates numerous hardware drivers, networking stacks, GUI components (LVGL), audio processing, and cryptographic implementations into a single firmware image built with PlatformIO. Key entry points include the web server for configuration, MQTT client for telemetry/control, serial command interface, OTA update mechanism, and hardware abstraction layer for peripherals. Data flows involve configuration persistence, sensor telemetry transmission, command reception for actuator control, and firmware update streams.
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.
ElegantOTA is an Arduino library that provides a polished web-based portal for over-the-air (OTA) firmware and filesystem updates on wireless microcontrollers (ESP8266, ESP32, RP2040+WiFi, RP2350+WiFi). The library exposes a minimal C++ API (begin, loop, callbacks) and serves a gzipped HTML/CSS/JS portal at /update. It handles the entire OTA workflow: capacity check before upload, MD5 integrity verification, chunked writing, progress reporting, and automatic reboot. The code is well-structured with platform-specific abstractions via preprocessor macros, supporting both synchronous (WebServer) and asynchronous (ESPAsyncWebServer) modes. The repository includes comprehensive CI testing across multiple boards and toolchains (Arduino CLI, PlatformIO), a CLA assistant, and stale issue management. The library is actively maintained with recent bug fixes (MD5 verification, RP2040 space calculation) and a clear upgrade path to a commercial Pro version.
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.
openHASP is an embedded firmware framework for home automation touch panels, built around LVGL for GUI rendering. It provides a configurable dashboard for controlling IoT devices via MQTT, with support for ESP32, STM32, and other microcontrollers. The system features hardware abstraction layers for displays and touch controllers, modular services (MQTT, HTTP, FTP, Telnet, WireGuard VPN), OTA updates, and a JSON-based configuration system. It integrates with home automation platforms like Home Assistant through auto-discovery and state topics, while offering local UI interaction via touchscreen. The architecture separates concerns into HAL, GUI, networking, storage, and services, enabling cross-platform deployment.
DIJI-NES is a high-performance NES (Nintendo Entertainment System) emulator designed to run on the ESP32-S3 microcontroller. It emulates the 6502 CPU, PPU graphics, and APU audio with cycle-level accuracy, supporting mappers 0-4 (NROM, MMC1, UxROM, CNROM, MMC3). The system renders 256x240 pixel frames at near-60 FPS to an ST7789 display via LovyanGFX and outputs audio through an I2S DAC (MAX98357A). It features a dual-core architecture: Core 0 handles audio generation and display DMA, while Core 1 runs the emulation loop. The firmware includes a ROM browser menu, save/load state support, volume control, and a particle boot animation. The codebase demonstrates deep NES hardware knowledge and aggressive optimization for embedded systems, including IRAM placement, lookup tables, bank caching, and frame-skip logic. While the main application is tightly coupled to the ESP32-S3 platform, the core emulation components (CPU, PPU, APU, cartridge) are well-isolated and could be extracted for reuse in other NES emulation projects.
Arduino CLI is a command-line tool and gRPC daemon for Arduino embedded development. It manages board platforms (cores), libraries, sketches, compilation, upload, monitoring, and debugging. The architecture is dual: a CLI frontend using the Cobra framework and a gRPC server (daemon mode) that exposes the same operations via protobuf-defined services. The core domain logic is organized under `internal/arduino/` with subsystems for building (preprocessor, compiler, linker, diagnostics), package management (index loading, install/uninstall, dependency resolution), sketch handling (profiles, YAML config), and hardware discovery/monitoring. External dependencies include gRPC, protobuf, Cobra/Viper for CLI, and Arduino-specific libraries for path handling, properties, serial communication, and pluggable discovery protocols. The system supports cross-platform operation (Linux, macOS, Windows) and includes extensive integration tests that exercise real CLI commands against isolated environments.
FastAccelStepper is a high-performance stepper motor control library for Arduino/ESP-IDF, supporting AVR, ESP32, SAM, SAMD51, and RP2040 platforms. It provides precise trapezoidal (optionally cubic) acceleration ramps with tick-exact step generation through a queue-based command execution model. The library abstracts hardware pulse generation behind a platform driver pattern (AVR timers, ESP32 RMT/MCPWM/PCNT/I2S, RP2040 PIO, SAM/SAMD51 timers) and avoids floating-point arithmetic by using a custom fixed-point log2 representation for speed calculations. It includes extensive automated testing (simulated AVR with VCD traces, PC-based unit tests, ESP32 hardware-in-the-loop) and CI matrices covering 50+ environment combinations. The library is production-ready, published on Arduino Library Manager and PlatformIO, with a detailed changelog from v0.8.0 to v1.3.3. It is used in real robotic and motion control systems, evidenced by issue reproductions for direction-change miscounts. Though the codebase is actively maintained, it suffers from conditional compilation proliferation across multiple ESP-IDF versions (4/5/6) and chip variants, and some platforms (SAM) have known bugs with no CI coverage. A major refactoring of direction-change handling is proposed but not yet merged. A companion web-based demo application (Esp32StepperDemo) is under design but incomplete. Highlights include the log2 fixed-point math component, a lock-free ring buffer queue, a portable platform abstraction layer, and an I2S mux driver capable of driving 32 steppers from one I2S transmitter. The extensive test harnesses and build-matrix generation scripts provide a solid foundation for regression testing across diverse hardware.
Arduino-IRremote is a comprehensive Arduino library for sending and receiving infrared remote control signals. It supports over 20 standard IR protocols (NEC, Sony, RC5, Samsung, LG, etc.) as well as exotic protocols like Bose Wave and Bang & Olufsen. The library is designed for embedded systems, handling the low-level timing generation and decoding required for IR communication. It provides both a full-featured receiver with a 50µs timer interrupt and a lightweight interrupt-based receiver (TinyIRReceiver) for resource-constrained boards. The sender uses software or hardware PWM to generate the 38kHz carrier, with bit-bang fallback for boards without PWM timers. Key entry points are the main include header (IRremote.hpp), static objects IrReceiver and IrSender, and a command dispatcher for mapping IR codes to callback functions.
This repository implements a DIY smart lock controller for ESP32 hardware, enabling Apple HomeKey NFC authentication, HomeKit integration, and MQTT connectivity for Home Assistant. The architecture is a hybrid embedded system: a C++ backend built on ESP-IDF (FreeRTOS) handles hardware interaction (NFC, GPIO, Ethernet) and protocol stacks (HomeSpan, mbedTLS), while a Svelte 5 frontend hosted on the device's LittleFS provides a web-based configuration and monitoring interface. The system manages configuration persistence in NVS using MessagePack/JSON serialization and streams real-time logs via WebSocket. Engineering quality is high, featuring RAII wrappers for memory safety in C++, template-based configuration management, and a decoupled event-loop architecture. However, the codebase carries significant security debt, explicitly acknowledging the lack of flash encryption and plain-text password storage in configuration. Hardware support is fragmented across ESP32 variants and NFC modules, requiring hardcoded pin presets that limit portability. Despite 52 open issues, the recent commit activity and modern tech stack (ESP-IDF 5.x, Svelte 5) indicate active development.
This repository provides an Arduino library that implements the Bluetooth Low Energy MIDI (BLE-MIDI) transport layer, enabling Arduino boards to send and receive MIDI data over BLE connections. The library works with the FortySevenEffects Arduino MIDI Library and supports multiple hardware platforms including ESP32 (with both standard BLE and NimBLE), ArduinoBLE (NANO 33 BLE), and nRF52. The architecture features a clean separation between the core BLE-MIDI protocol implementation and hardware-specific adaptations. The transport layer correctly handles timestamp generation per the BLE-MIDI specification, running status optimization, and buffer management. Hardware abstractions use C++ templates to provide a consistent interface across different BLE stacks while exposing platform-specific configuration options.
SensESP is an embedded firmware framework for ESP32 microcontrollers that enables building custom marine sensors that communicate via the Signal K protocol. It provides a complete pipeline from physical sensor reading (via Arduino libraries or built-in ADC/digital inputs) through data transformation (30+ composable transforms like linear scaling, moving average, hysteresis, curve interpolation) to publishing over WebSocket to a Signal K server. The framework includes a full web-based configuration UI (Preact/Bootstrap) served directly from the device, WiFi/Ethernet provisioning with captive portal, OTA updates, and a REST API for device management. Architecture follows a reactive dataflow pattern: sensors produce typed values that flow through transform chains to consumers (Signal K output, UI, logging). The core is built on ReactESP event loop, with observable/value producer/consumer abstractions enabling type-safe connections. Notable components include a TOFU certificate pinning system for secure Signal K connections, a circular log buffer with snapshot cursor for the web UI, and a smart switch controller supporting local and remote actuation with double-click sync. The codebase is well-structured with unit tests for transforms, metadata, and networking components, though some deprecated APIs and a large god object (SensESPApp) indicate areas for refactoring.
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.
Gobot is a Go framework for robotics, physical computing, and the Internet of Things. It provides a consistent hardware abstraction layer (HAL) over dozens of single-board computers (Raspberry Pi, BeagleBone, Intel Edison, Jetson, etc.), microcontrollers (Arduino via Firmata, Digispark), and communication protocols (GPIO, I2C, SPI, BLE, serial, MQTT, NATS, MAVLink). The architecture is modular: platform-specific adaptors implement core interfaces (DigitalPinner, PWMPinner, I2cBusAdaptor, etc.) and are composed from reusable building blocks in the `platforms/adaptors` package. Drivers for sensors, actuators, displays, and robots (Sphero, Parrot drones, DJI Tello, GoPiGo3) are organized by bus type (gpio, i2c, spi, ble, aio, onewire, serial) and share a common lifecycle pattern with event publishing and command registration. A built-in HTTP API server (with optional basic auth and CORS) exposes robot state and commands over REST and Server-Sent Events, and includes an embedded web UI (Robeaux). The framework supports both high-level orchestration via `Robot` and `Manager` and low-level 'metal' usage for direct hardware control. External dependencies include `periph.io` for GPIO, `tinygo.org/x/bluetooth` for BLE, `gocv.io/x/gocv` for computer vision, and `go.bug.st/serial` for serial communication. The codebase is extensively tested with mock filesystem and syscall infrastructure, and uses functional options for configuration throughout.
This repository contains the K3NG Arduino CW Keyer, a highly configurable firmware for generating Morse code (CW) in amateur radio operations. The system runs on a wide range of Arduino-compatible microcontrollers (AVR, SAM, STM32, ESP32, Raspberry Pi Pico) and supports multiple input methods including paddles, straight keys, PS2 keyboards, USB keyboards (via MAX3421E USB host shield), and game controllers. It emulates the Winkey protocol for integration with logging software like N1MM+ and provides advanced features such as a CW decoder (using Goertzel algorithm), a built-in web server for remote control, beacon mode, practice/training modes, and SO2R (single operator two radio) support. The architecture is a monolithic Arduino sketch with extensive conditional compilation: over 20 hardware-specific configuration files (keyer_features_and_options_*.h, keyer_pin_settings_*.h, keyer_settings_*.h) allow tailoring the firmware to specific boards and feature sets. The main entry points are the standard Arduino setup() and loop() functions, with the web server module (k3ng_keyer_webserver.ino) providing HTTP-based control. External dependencies include the USB Host Shield library (for USB keyboard/controller input), Adafruit LiquidCrystal and TwiLiquidCrystal libraries (for LCD displays), and a PS2 keyboard library. The codebase is well-structured for its domain but carries significant complexity due to the sheer number of configuration combinations and bundled third-party libraries.
Flix is an open-source ESP32-based quadcopter project built from scratch. The repository contains flight controller firmware, a Python control/telemetry library, C++ utilities for log conversion, simulation assets, and extensive documentation. It is primarily an application repo, though it also includes CAD models and data-conversion tools that serve as supporting assets. At runtime, the ESP32 firmware reads IMU data, estimates attitude, and drives motors, communicating via MAVLink and ESP-NOW for telemetry and control. The Python library (tools/pyflix/flix.py) provides an observable API for interacting with the vehicle, and CLI tools convert flight logs from CSV to MCAP and ULog formats for analysis in standard robotics tooling. A Gazebo simulation and a Python test harness validate behavior without hardware. Architecture is a multi-part monorepo: firmware, Python tools, C++ tools, docs, and 3D-printable mechanical parts. External dependencies include the Arduino ESP32 core, MAVLink, ESP-NOW, Gazebo, and custom math classes. The code is generally well-structured, but some data flow relies on global variables and hardware-specific assumptions, limiting reuse outside the ESP32 ecosystem. The project appears actively maintained with CI workflows, but dependency pinning and tight hardware coupling create moderate drift risk.
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.
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 the firmware for a LoRa-based APRS iGate/digipeater station running on ESP32 microcontrollers. It bridges amateur radio APRS packets between LoRa RF and the internet (APRS-IS), and can also operate as a digipeater, TNC (KISS), weather station, and GPS tracker. The firmware includes a full web-based configuration UI, live map, MQTT integration, syslog, OTA updates, and support for dozens of hardware variants (Heltec, TTGO, etc.). The code is organized into modular C++ namespaces (LoRa_Utils, DIGI_Utils, APRS_IS_Utils, etc.) and uses a JSON-based configuration store. While the project is actively maintained, it shows some technical drift through vendored esptool binaries, dependency on older libraries (ElegantOTA), and heavy use of compile-time conditionals across board variants. The architecture is a classic embedded monolith targeting a single firmware binary, with strong hardware abstraction via pinout headers and a common configuration object. Several components—such as the KISS protocol encoder/decoder, the NetworkManager abstraction, and the Configuration class—are well-isolated and potentially reusable in other ESP32/ham radio projects.
ESPAtherma is an embedded firmware application (PlatformIO/Arduino) for monitoring and basic control of Daikin Altherma heat pump systems via an ESP32 or ESP8266 microcontroller. In production, it connects to the heat pump's X10A serial port, queries specific register addresses (reverse-engineered Daikin I and S protocols), converts raw bytes into human-readable values using configurable label definitions, and publishes the data over MQTT to a Home Assistant instance. It also provides Home Assistant MQTT auto-discovery for seamless integration. The architecture is a single-threaded loop: setup reads model-specific definition files and MQTT/WiFi config, then repeatedly queries registers, converts data, and publishes to MQTT. Key entry points are `src/main.cpp`, `include/comm.h` (serial query), and `include/homeassistant.cpp` (discovery payload generation). External dependencies include PubSubClient, ArduinoJSON, and board-specific libraries (M5Unified for M5Stick). The project also includes reverse-engineering scripts, serial log dumps, and a heat pump emulator, making it a hybrid of embedded application and protocol research. However, the primary usage and codebase character are that of an IoT monitoring/control application.