Embassy is a next-generation embedded framework for Rust that enables asynchronous programming on microcontrollers using async/await syntax. It provides Hardware Abstraction Layers (HALs) for multiple MCU families (STM32, Nordic nRF, Raspberry Pi RP2040/RP23xx, TI MSPM0, NXP MCX-A, etc.), an async executor for cooperative multitasking, timekeeping utilities, networking stack, USB device/host stack, Bluetooth support, bootloader/DFU capabilities, cryptographic primitives, and synchronization primitives. The framework emphasizes safety, correctness, and energy efficiency through Rust's compile-time guarantees, with an executor that automatically enters low-power sleep when idle. Applications are structured around peripheral initialization, async task spawning via #[embassy_executor::task], and event-driven communication using Embassy's synchronization primitives.
Home Assistant Core is the open-source home automation platform that powers millions of smart homes. It provides a unified event-driven architecture for integrating, controlling, and automating IoT devices, services, and voice assistants. The system runs as a Python async application with a modular component system: each integration (e.g., lights, sensors, climate, locks) is a self-contained Python package under `homeassistant/components/`, following a consistent pattern of config entries, data update coordinators, and entity platforms. Key entry points include the CLI (`hass`), the web-based frontend (served via aiohttp), WebSocket API, and REST API. Data flows are event-driven: state changes, service calls, and automation triggers propagate through a central bus. External dependencies include hundreds of third-party libraries for device communication (BLE, Zigbee, Z-Wave, MQTT, HTTP), cloud services (Nabu Casa, Google Assistant, Alexa), and media playback (Cast, DLNA). The architecture is a monolith with a plugin system, not microservices, but supports horizontal scaling via separate instances and the 'recorder' component for persistent state history.
BiTchat is a native Swift messaging application for iOS and macOS that provides secure, decentralized communication over Bluetooth Low Energy (BLE) mesh, with optional Nostr and Tor transport. The codebase implements end-to-end encryption using the Noise protocol (XChaCha20-Poly1305), Ed25519 signatures, prekey forward secrecy, and a vouching trust model. It includes rotating peer IDs, fingerprint verification, recognition tags that avoid leaking social graphs, and panic-wipe capabilities. The app is structured around SwiftUI views, view models, and coordinators, with a central ChatTransportEventCoordinator routing inbound transport events (messages, noise payloads, delivery status, verification, peer lifecycle) to the UI layer.
Stats is a native macOS menu bar system monitor that provides real-time hardware and software metrics for CPU, GPU, RAM, Disk, Network, Battery, Sensors (temperature/voltage/fan), Bluetooth, and Clock. Built entirely in Swift with AppKit, it uses private IOKit, SMC, and IOReport APIs to collect system data, and offers highly customizable widgets (mini, line/bar/pie charts, tachometer, text, etc.) drawn directly in the menu bar. The architecture is modular: each monitored subsystem lives in its own 'Module' directory with a consistent structure (main.swift, readers, popup, settings, notifications, portal). A shared 'Kit' framework provides reusable components including a reader base class with interval management and history persistence via bundled LevelDB, a thread-safe key-value store wrapper, and a set of custom drawing chart widgets. The app also supports remote monitoring via an optional cloud service (System Stats), privileged helper for fan control, macOS widget extensions, and extensive localization (40+ languages). The codebase demonstrates strong engineering practices with clean abstractions, encapsulation, and reusability, though some modules exhibit boilerplate duplication and the project relies on several deprecated or private APIs that may require updates for future macOS releases.
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.
AsyncBluetooth is a Swift Package Manager library that brings Swift Concurrency to CoreBluetooth. It wraps the central manager and peripheral delegate APIs into async/await methods and AsyncStreams, so clients can scan, connect, discover services and characteristics, read/write values, and subscribe to notifications without nested delegate callbacks. It is not a standalone application; it is a dependency library for Apple-platform apps performing Bluetooth Low Energy central-role work. Architecturally, the code is split into CentralManager and Peripheral layers, with supporting types for scan data, services, characteristics, and events. A notable internal component is CentralManagerContext, a serialized async work queue that guarantees per-key operation ordering and supports cancellation. CoreBluetooth callbacks are translated into typed event enums such as CentralManagerEvent and exposed as AsyncStreams. The library uses os.log for diagnostics and ships a privacy manifest, indicating modern Apple platform practices. Maintenance is active: the repository has recent commits and a 6.2.2 tag. The code uses current Swift concurrency features, has no third-party dependencies, and includes tests. Technical drift is low.
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.
BlueALSA is a Bluetooth audio ALSA backend for Linux systems that integrates with BlueZ to provide A2DP, HFP/HSP, ASHA, and BLE-MIDI profiles. It operates as a daemon (bluealsad) managing Bluetooth connections and exposing audio streams via ALSA PCM plugins and D-Bus interfaces. The architecture is modular, separating transport management, codec handling, D-Bus communication, and ALSA plugin layers. Key entry points include the daemon (src/main.c), ALSA PCM plugin (src/asound/bluealsa-pcm.c), ALSA mixer plugin (src/asound/bluealsa-ctl.c), and control utility (src/bluealsactl/main.c). Data flows from ALSA applications through the PCM plugin to Bluetooth transports, with control signaling via D-Bus. External dependencies include BlueZ, ALSA, GLib, and various codec libraries (SBC, aptX, LDAC, etc.).
BatMON is a Home Assistant add-on and standalone Docker application for monitoring battery management systems (BMS) over Bluetooth Low Energy (BLE) and serial connections. It decodes telemetry from ~25 BMS families (Daly, JK, ANT, Renogy, Seplos, etc.) and publishes normalized data to MQTT for Home Assistant, or directly to InfluxDB. The architecture is a Python asyncio application with a BMS abstraction layer (`bmslib`) that defines a common interface (`fetch()`, `fetch_voltages()`) and model-specific decoders. The main entry point is `main.py`, which dispatches to HA add-on or standalone mode via `entrypoint.sh`/`addon_main.sh`. Data flows from BMS hardware through BLE/serial adapters into decoder classes, then to MQTT/InfluxDB via a GUI wire format (`bmslib/wire/model.py`). External dependencies include bleak (BLE), paho-mqtt, influxdb, and Home Assistant add-on infrastructure (bashio, supervisor). The project includes a Helm chart, Docker multi-arch builds, and a test suite with known-answer vectors for CRC/AES and protocol decoders.
The 32feet.NET repository provides a comprehensive Bluetooth and OBEX protocol implementation for .NET, supporting multiple platforms and Bluetooth stacks.
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 is a Homebridge plugin (`@switchbot/homebridge-switchbot`) that bridges SwitchBot IoT devices (lights, curtains, locks, sensors, vacuums, etc.) into Apple HomeKit using both HAP and Matter protocols. It communicates via Bluetooth Low Energy (BLE) and the SwitchBot OpenAPI cloud API, with configurable fallback and rate-limiting. The plugin provides a rich configuration UI served through Homebridge Config UI X, including device discovery, credential management, and advanced polling settings. The architecture follows a platform plugin pattern with two platform classes (HAP and Matter), a resilient client layer (debounce, circuit breaker, daily budget tracking), a device factory and abstract base class for device-specific implementations, and extensive Matter cluster mappings. While the codebase is well-structured and actively maintained, it suffers from a large monolithic platform file (~2800 lines), low test coverage (~1.36%), and a dependency conflict requiring `--legacy-peer-deps` during installation. ESLint configuration also fails in CI. Nonetheless, the plugin is feature-rich, handles edge cases like BLE encryption and OpenAPI rate limits, and includes a polished custom UI.
This repository provides two Windows desktop applications (WiinUPro and WiinUSoft) that allow users to connect Nintendo controllers (Wiimote, Nunchuk, Classic Controller, Pro Controller, Joy-Con, GameCube) and PlayStation controllers (DS3, DS4) to a PC, emulating Xbox 360 controllers (XInput) or other outputs like keyboard/mouse and vJoy virtual joystick. The architecture is a hybrid of C# WPF applications, a C++ kernel-mode virtual bus driver (ScpVBus.sys), and a C++ XInput wrapper DLL. The core logic is split into several libraries: NintrollerLib for parsing Nintendo controller protocols, ScpControl for Bluetooth/USB communication with PS3/PS4 controllers, and a Shared project with common utilities. The applications feature interactive controller visualizations, calibration tools, profile management, and localization support. The codebase is functional but shows signs of organic growth and technical debt. There are two overlapping applications (WiinUPro and WiinUSoft) with similar functionality, suggesting an incomplete migration. The kernel driver is provided as a precompiled binary without source, and the project targets .NET Framework 4.0 with legacy dependencies like SharpDX. Hardcoded magic numbers, commented-out code, and TODO comments are prevalent. Despite these issues, the repository demonstrates deep knowledge of controller protocols and provides a working solution for a niche use case. It is maintained sporadically by a single developer, with the last commit dated 2026-05-07 (likely a placeholder).
Reggaeton Be Gone is a single-file Raspberry Pi application that continuously samples ambient audio and uses an Edge Impulse machine learning model to classify whether reggaeton music is playing. When the classification confidence exceeds a configurable threshold (default 0.95), the script triggers a Bluetooth test routine against a configured speaker address, using either repeated rfcomm connection attempts or l2ping packets. The system also displays status messages on a 128×32 OLED screen and logs events to a file. The code is a tightly coupled prototype with hardcoded paths, global state, and no error handling, reflecting its 'dirty and messy' design as acknowledged by the author. There are no reusable components beyond trivial display and logging helpers; the project's value lies in its novel concept and successful integration of audio ML with Bluetooth experimentation on physical hardware.