This is a bare-metal (no_std) hardware abstraction layer (HAL) for Espressif ESP32 microcontrollers, supporting RISC-V and Xtensa cores. It provides low-level drivers for GPIO, SPI, I2C, UART, ADC, DAC, PWM, timer, USB, Ethernet, Wi-Fi, BLE, IEEE 802.15.4, and many other peripherals across a dozen+ chip families (ESP32, ESP32-C2/C3/C5/C6/C61, ESP32-H2/H4, ESP32-P4, ESP32-S2/S3/S31). The repository is a monorepo containing multiple independently versioned crates: esp-hal (core HAL), esp-radio (wireless radio stacks), esp-alloc (heap allocator), esp-storage (flash storage), esp-backtrace, esp-println, esp-sync (synchronization primitives), esp-rom-sys (ROM function bindings), esp-rtos (lightweight RTOS with async/embassy integration), esp-lp-hal (low-power core HAL), esp-config (build-time configuration), esp-metadata (chip property code generation), xtask (build/release tooling), and bootloader/OTA support. The architecture is built on extensive use of compile-time chip selection via macros (cfg_select!, for_each_*), versioned low-level driver modules per peripheral, and type-erased patterns for unified APIs across chip variants. Async support is first-class via embassy executor integration. The codebase demonstrates high engineering quality with clear abstractions, comprehensive hardware-in-the-loop testing (hil-test, hil-test-radio), and mature CI/CD workflows.
This repository is a comprehensive, production-oriented algorithmic trading framework implemented in TypeScript. It is organized as a monorepo with six interdependent packages: `trading-signals` (100+ technical indicator implementations with streaming `add`/`replace` semantics, each verified against external reference data like Tulip Indicators and Skender.Stock.Indicators), `trading-strategies` (strategy base classes, concrete strategies such as SMA crossover, scalp, trailing stop, and a multi-indicator confluence strategy, plus a backtesting engine and report generators), `exchange` (abstract broker interface with real implementations for Alpaca and Trading212, including mock broker for backtesting, candle batching, WebSocket streaming, and a CLI tool), `messaging` (a Telegram bot for managing accounts, strategies, watches, and reports via multi-step wizards), `candles` (labeled historical candle datasets for testing), and `trading-signals-docs` (a Next.js documentation site with interactive indicator demos and a visual backtester). The architecture emphasizes clean separation between signal generation, strategy logic, broker execution, and user interface. The indicator library is the core asset, providing a consistent contract (`IndicatorSeries`, `TechnicalIndicator`, `TrendIndicator`) with rich signal detection and state rollback. The strategy framework supports live trading and backtesting via the same advice-execution pipeline. The project is actively maintained with CI/CD, mutation testing, and a well-defined broker integration template. While the codebase shows high craftsmanship in its indicator implementations and test patterns, the large number of indicators and hand-derived test fixtures introduce maintenance overhead, and the tight coupling to Telegram limits platform portability.
The openwifi repository provides a full-stack IEEE 802.11 (Wi-Fi) implementation for Software Defined Radio (SDR) hardware, specifically targeting Xilinx Zynq/ZynqMP SoCs with AD9361/AD9364 RF transceivers. It consists of a Linux kernel driver (split into multiple modules for OFDM, TX/RX interfaces, and side-channel processing) and user-space tools for hardware configuration, FPGA bitstream loading, and Wi-Fi interface management. The system supports standard Wi-Fi modes (AP, STA, ad-hoc, monitor) and experimental features like Channel State Information (CSI) extraction, packet injection/fuzzing, and radar sensing. The build system uses Buildroot to generate bootable SD card images, and the project includes extensive documentation for experimentation and hardware bring-up.
This repository provides Hardware Abstraction Layers (HAL) for Raspberry Pi RP2040 and RP235x microcontrollers. It consists of separate HAL crates for each microcontroller family (rp2040-hal, rp235x-hal), a shared common library (rp-hal-common), binary info generation for picotool (rp-binary-info), examples demonstrating peripheral usage, and on-target tests. The HALs expose peripherals like GPIO, UART, SPI, I2C, PWM, PIO, USB, and more through safe Rust abstractions using the typestate pattern and embedded-hal traits. The architecture follows embedded Rust best practices with clear separation of concerns. Each HAL crate can be used as a dependency in embedded projects. Key innovations include a bidirectional DMA abstraction for full-duplex communication, split UART reader/writer peripherals preventing data races, a glitchless clock configuration system with typestate safety, and a comprehensive PIO driver for programmable I/O. The project is actively maintained with regular commits, CI workflows for multiple platforms, and issue triage. While some code duplication exists between the HALs due to architectural differences, ongoing efforts rationalize shared code into rp-hal-common. The HALs are suitable for production use in embedded applications targeting these microcontrollers. Examples demonstrate real-world usage patterns like ADC with DMA, USB device implementation, multicore FIFO communication, and low-power dormant mode. Dependencies are current with the embedded Rust ecosystem (embedded-hal 1.0.0-beta, fugit, etc.), and the project avoids deprecated patterns. The binary info generation utility is a reusable component that could apply to any embedded Rust project requiring picotool compatibility.
lockfree is a header-only C++11 library providing lock-free data structures for concurrent programming. It offers both single-producer single-consumer (SPSC) and multi-producer multi-consumer (MPMC) variants of queues, ring buffers, bipartite buffers, and priority queues. The library is designed for use across a wide spectrum of systems from deeply embedded to HPC, featuring no dynamic allocation and optimized for high performance. Architecture-wise, it's organized into spsc/ and mpmc/ namespaces with each data structure having separate header and implementation files, aggregated through lockfree.hpp. The implementation uses atomic operations and clever algorithms to achieve lock-free behavior without mutexes.
This repository provides a userspace C library for controlling WS2812/SK6812 RGB(RGBW) LEDs on Raspberry Pi single-board computers. The core architecture uses Raspberry Pi's DMA (Direct Memory Access) controller to feed data to the PWM, PCM, or SPI peripheral, generating the precise timing signals required by the LED protocol without burdening the CPU. The library is structured as a static/shared C library with a clean API (ws2811_init, ws2811_render, ws2811_fini) that abstracts hardware details such as GPIO configuration, clock setup, and memory allocation via the VideoCore mailbox interface. The code is well-documented with register-level header files (pwm.h, pcm.h, dma.h, clk.h, gpio.h) that could be reused in other Pi projects. Building is supported via both SCons and CMake, and Debian packaging files are included. The library is the foundational component for numerous language bindings (Python, Rust, Java, etc.) and is widely used in LED projects like unicorn-hat and pixel-art displays.