This repository provides ESPHome components for integrating the Xiaomi Mijia Bedside Lamp 2 with Home Assistant. It enables full control of the lamp's RGBWW LEDs, front panel touch interface (buttons and slider), and illumination through custom ESPHome components. The firmware replaces the original Xiaomi firmware to eliminate cloud dependencies and enable local-only control. The architecture follows ESPHome's component model with hardware abstraction layers (HAL) for light control and front panel I2C communication. Key features include individually controllable front panel LEDs, light presets with group support, disco mode for immediate updates, night light calibration, and smooth color transitions with hardware-aware handling of low-brightness limitations. The design emphasizes separation of concerns, with distinct modules for color handling, state management, and event processing. Notable technical implementations include a Chain of Responsibility pattern for handling different light modes (off, night, RGB, white), a flexible preset system with group-based activation, and specialized transition handling that avoids attempting smooth color changes at very low brightness levels where the hardware cannot perform them reliably. The firmware maintains compatibility with modern ESPHome versions through active maintenance and timely adaptation to API changes.
This repository provides the complete design and firmware for the Smart Plant, an ESP32-S2 based IoT device for monitoring soil moisture, ambient temperature, humidity, and illuminance. The firmware, built on the ESPHome framework, publishes sensor data to Home Assistant via MQTT and displays it on a 2.9-inch ePaper screen. It employs a sophisticated deep-sleep architecture to achieve 40-50 days of battery life, with careful power management of sensors and MQTT connections. The architecture is centered around a highly modular ESPHome YAML configuration. The `examples/multi-device/packages/smart_plant_base.yaml` file serves as a reusable base package, enabling fleet management through YAML substitutions and overrides. This pattern allows users to deploy multiple devices with a shared core configuration, customizing only device-specific parameters like MQTT topics and sensor calibrations. The data flow is strictly sensor-to-cloud, with retained MQTT messages ensuring Home Assistant entities remain available during the device's deep sleep cycles. Beyond firmware, the repository encompasses the full hardware design. The PCB is designed in Autodesk Eagle, and the 3D-printable enclosure is provided in both FDM (STL) and SLA (STEP) formats, originating from CATIA. The project is accompanied by professional Sphinx documentation hosted on ReadTheDocs, including assembly guides, safety information, and programming instructions. Overall, this is a high-quality, production-ready IoT project. The ESPHome base package is a standout reusable component for anyone building battery-powered ESPHome sensors. The hardware designs are complete and manufacturable. While the documentation contains minor copy-paste errors (e.g., referencing 'Smart Powermeter') and mixed-language comments in the YAML configs, the core firmware architecture and hardware design are exceptionally well-executed.
This repository is an ESPHome custom component and configuration pack that turns an ESP32 into a BLE bridge for controlling Tesla vehicles. It implements a `tesla_ble_listener` component that connects to the car's BLE advertisement/command channel, encrypts/decrypts Tesla's proprietary BLE messages using a forked `tesla-ble` library, and exposes ESPHome services, buttons, sensors, and selectors for actions like lock/unlock, frunk/trunk, climate, and cabin overheat protection. The repo is primarily YAML package definitions and C++ component code, with a Makefile and CI workflow for building board-specific firmware.
ESPHome Designer is a Home Assistant custom component that provides a visual drag-and-drop editor for designing display layouts on ESP32/ESP8266 devices running ESPHome. It supports multiple rendering protocols including native ESPHome C++ lambdas, LVGL, OpenEPaperLink (OEPL), and OpenDisplay (ODP). The editor features a canvas with zoom/pan, snap-to-grid, drag-and-drop, lasso selection, and a property panel for configuring widget attributes. Widgets are organized as plugins, each providing render, export, and lifecycle hooks for all supported output formats. The system can generate complete ESPHome YAML configurations including hardware definitions, sensor registrations, font loading, and display lambdas. The architecture is split between a Python backend (Home Assistant integration) and a JavaScript frontend (Vite-built SPA). The backend provides REST APIs for layout CRUD, entity history proxying, image/RSS proxying, hardware profile management, and PNG rendering. The frontend manages state via an AppState singleton with undo/redo, communicates with the backend through a bridge, and supports offline YAML parsing. An AI integration allows generating layouts from natural language prompts using multiple providers (Gemini, OpenAI, OpenRouter). The codebase demonstrates strong engineering practices with a plugin-based architecture, adapter pattern for multi-format export, schema-driven property panels, and extensive test coverage (200+ Vitest tests plus Python tests). It is actively maintained with CI/CD pipelines, quality gates, and regular releases. While the widget plugin surface is large and some legacy modules coexist with newer code, the overall design is modular and extensible.
This repository implements a Linux-based voice satellite for Home Assistant, acting as a local voice assistant that connects to Home Assistant via the ESPHome protocol (aioesphomeapi). The application runs as a Python asyncio service, handling wake word detection using TensorFlow Lite models (MicroWakeWord and OpenWakeWord), audio input via the soundcard library, audio output via libmpv, and optional WebRTC noise suppression/gain. It also provides a WebSocket-based Peripheral API (port 6055) that allows external hardware controllers (LED rings, buttons, HAT boards) to register entities and receive real-time state events. The system is deployed via Docker with docker-compose and includes example peripheral implementations for devices like the ReSpeaker HATs, Jabra Speak 410, and Satellite1 HAT. The architecture is modular, with separate modules for the ESPHome API server (api_server.py), core voice pipeline protocol (satellite.py), entity management (entity.py), wake word loading (wake_word.py), audio playback (player/libmpv.py), and peripheral integration (peripheral_api.py). The application is configured via environment variables and command-line arguments, with preferences persisted to a JSON file. The codebase includes unit tests for most modules, CI/CD workflows, and a Docker build pipeline. External dependencies include aioesphomeapi, websockets, soundcard, python-mpv, webrtc-noise-gain, pymicro-wakeword, pyopen-wakeword, and zeroconf. Key data flows: Microphone audio is captured, optionally processed by WebRTC for noise suppression and gain, then fed into wake word detection. Upon wake word detection, the voice pipeline sends audio to Home Assistant for speech recognition and intent handling. Responses (TTS, media) are received and played via MPV. The Peripheral API allows external hardware to send button events and receive state changes (e.g., listening, thinking, muted). The system supports multiple wake words, stop word detection, timers, and media playback with playlist support.
This repository provides a complete custom firmware solution for the Sonoff NSPanel smart home touch panel, tightly integrated with Home Assistant via ESPHome and a Home Assistant Blueprint. The firmware is built on ESPHome, a platform for ESP32-based devices, and uses a Nextion display for the user interface. The architecture is modular: a core set of YAML configuration files defines hardware drivers (Wi-Fi, display, relays, buttons, temperature sensor) and page definitions (home, weather, climate, light, cover, alarm, media player, utilities, etc.). Optional add-on YAML packages extend functionality for cover control, climate thermostat, TFT upload, and Bluetooth proxy. The companion C++ component library (in `components/nspanel_ha_blueprint/`) implements the communication protocol between the ESP32 and the Nextion display, handles page logic, and fires Home Assistant events via the ESPHome API. The Blueprint (`nspanel_blueprint.yaml`) allows users to configure all entities and customizations without writing code. Prebuilt firmware binaries are provided for quick flashing. The project is actively maintained, with a large community and frequent releases, though it has significant duplication across HMI variants and some deprecated add-ons.
This repository provides an ESPHome component that implements a UART-to-TCP bridge, creating a serial-to-network gateway. The component listens for TCP connections on a configurable port (default 6638) and relays data bidirectionally between connected clients and a UART serial port. It handles multiple simultaneous clients using non-blocking I/O, manages a ring buffer for efficient UART-to-TCP transmission, and provides optional binary sensors for connection status and a sensor for active connection count. The implementation adapts to various ESPHome version APIs through conditional compilation and follows ESPHome's component architecture patterns.
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.