The LiquidCrystal library is an Arduino library for interfacing with HD44780-compatible LCD displays. It provides a hardware abstraction layer that handles the timing-sensitive communication with the display in either 4-bit or 8-bit mode. The library includes methods for initializing the display, printing text, controlling the cursor and blink, scrolling the display, and creating custom characters. The implementation demonstrates a solid understanding of the LCD controller's datasheet and timing requirements, making it a reliable and reusable component for Arduino projects.
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.
This is the Adafruit GPS Library, an Arduino library for reading NMEA sentences from GPS/GNSS modules via UART, I2C, or SPI. It provides a high-level API (`Adafruit_GPS`) that exposes parsed position, time, speed, and other navigation data as simple member variables. The library also includes a newer, hardware-independent NMEA framing and decoding layer (`Adafruit_NMEA` and `Adafruit_GNSS`) that can be reused outside the Arduino context. Example sketches demonstrate wiring, parsing, LOCUS logging, and SD card data logging. The codebase is well-structured with clear separation between transport, framing, and position decoding. Extensive regression tests run on Linux using a mocking layer, with AddressSanitizer and UndefinedBehaviorSanitizer enabled. The architecture is a traditional Arduino library: users instantiate an `Adafruit_GPS` object with a `Stream` (hardware serial, software serial, I2C, or SPI), call `read()` frequently to consume bytes, then check `newNMEAreceived()` and call `parse()` to update fields. A newer `lastPosition()` getter provides exact coordinate components without modifying legacy state. The low-level `Adafruit_NMEA` class handles byte-by-byte framing with bounded buffers, checksum validation, and field iteration. `Adafruit_GNSS` adds static coordinate, time, and date parsing functions plus sentence validation for GGA, RMC, and GLL. Both classes are free of heap allocation and floating-point arithmetic where possible. The library is actively maintained with recent commits, a CI pipeline, and a single open issue. Technical drift is low: dependencies are limited to the Arduino core and standard libraries. The code demonstrates strong software engineering practices, including test-driven development, bounded buffers to prevent overflow, and a clean public API. The newer GNSS/NMEA components are reusable in other embedded or host projects with minimal adaptation.
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 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.
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.
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 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 provides a WiFi configuration manager for ESP32 and ESP8266 microcontrollers using the Arduino framework. It enables devices to create a captive portal for WiFi setup, store credentials in the filesystem, and optionally define additional configuration parameters (strings, integers, booleans) via a simple API. The library operates as a singleton, handling WiFi connection attempts, portal management, and runtime language selection for the configuration interface. Key features include automatic password generation, support for OTA updates via the same credentials, and callback hooks for custom behavior during connection events. The architecture centers around the WiFiSettings class, which manages state through filesystem storage (SPIFFS for ESP32, LittleFS for ESP8266) and a dynamic parameter system. The configuration portal is implemented as a blocking web server with DNS redirect, serving a localized HTML form that saves user input to files. Language support is handled via a separate header using flash-stored strings and runtime selection, minimizing memory usage. The design prioritizes ease of use over advanced features, making it suitable for simple IoT devices requiring straightforward WiFi provisioning.
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.
SPIMemory is an Arduino library providing a high-level interface for SPI Flash and FRAM memory chips. It supports reading, writing, and erasing data of various types (byte, char, word, long, float, string, arrays, structs) across a wide range of microcontrollers (AVR, SAM, SAMD, ESP8266, ESP32, STM32, nRF52, etc.) and memory chip manufacturers. The library automatically identifies chips via JEDEC IDs and the SFDP standard (JESD216B), manages address allocation, and offers optional error checking and high-speed modes. It is not a standalone application but a reusable component for embedded firmware projects requiring external non-volatile storage. The codebase demonstrates solid engineering with template-based I/O, conditional compilation for platform support, and a consistent error-reporting pattern. However, it shows signs of technical drift: dual documentation systems (Sphinx and MkDocs) with stale build artifacts, outdated jQuery in docs, beta features (FRAM, ESP32 custom SPI), and some commented-out debug prints. The library is actively maintained (recent commits, version 3.4.0) but has 71 open issues, indicating ongoing development and community use.
This is an Arduino library for parsing serial data packets from NeuroSky-based EEG headsets (Star Wars Force Trainer, Mattel MindFlex). The Brain class implements a complete packet protocol parser with sync byte detection (0xAA, 0xAA), length validation, checksum verification, and data extraction. It exposes signal quality, attention, meditation values, and 8 EEG power bands through getter methods and CSV output. The library is designed for embedded systems with limited memory, using fixed-size buffers and Stream-based interfaces compatible with both HardwareSerial and SoftwareSerial. The architecture is a single monolithic class with no external dependencies beyond the Arduino framework. Data flows from serial input through packet parsing to either CSV string output or individual getter methods. The code demonstrates solid embedded engineering practices for its domain, including proper state management, error handling, and protocol compliance. However, it uses dated C++ patterns (char* instead of std::string, boolean instead of bool) and fixed buffers that could overflow with malformed input. This library is well-suited for hobbyist brain-computer interface projects using legacy NeuroSky hardware. It's not suitable for modern Arduino versions without modification, and the hardware it targets is aging. The code is clean and reusable but lacks tests and modern safety features.