This repository is the deployment system for Internet-in-a-Box (IIAB): an offline-first learning server for schools and communities without reliable Internet. It is an Ansible configuration-management application that installs and configures a complete local network stack — nginx reverse proxy, PHP-FPM, MySQL/PostgreSQL, hostapd WiFi access point, dnsmasq DNS/DHCP, Squid proxy, captive portal, Samba, CUPS — alongside a catalog of educational services such as Kiwix (offline Wikipedia/ZIM), Kolibri, WordPress, MediaWiki, Nextcloud, Gitea, JupyterHub, Moodle, Calibre-Web, and an offline OpenStreetMap/vector-tile mapping system with geocoding. Python, PHP, and Jinja2 templates generate systemd units, nginx virtual hosts, and app configs for every deployed service. Architecture is a staged Ansible pipeline: eleven role groups (0-init through 9-local-addons, then network) are driven from top-level playbooks (iiab-stages.yml, iiab-from-cmdline.yml) invoked by shell entry points (iiab-install, iiab-configure, iiab-network). Every role follows consistent conventions: defaults in defaults/main.yml, an install.yml and enable-or-disable.yml, boolean *_install/*_enabled flags validated up front with Ansible assert tasks, install state recorded in /etc/iiab/iiab_state.yml, and disk usage audited into iiab.ini. A custom Ansible module (get_curl) performs resumable/atomic downloads used across roles. Content provisioning is data-driven: maps and ZIM catalogs are generated (roles/maps/generate-catalog.py) and fetched at install time; offline search and geometry utilities (FQR, static_search.js) are bundled into the served front end. The project is actively developed (Ubuntu 24.04 and Raspberry Pi OS CI matrices, expected-state integration tests) but carries heavy legacy baggage: a large 0-DEPRECATED-ROLES tree, numerous .unused files, Python 2 support scripts, hardcoded versions/vendor URLs, plaintext default secrets, and fragile per-distro workarounds. The reusable gems — the custom download module, the tested geographic FQR geometry utility, the client-side static geocoder, the Ansible facts script, and the pdsm proot service manager — are isolated enough to extract into new projects. Overall it is a solid, professional infrastructure-as-code project with a few genuinely reusable components, tempered by significant accumulated technical debt.
not-os is a minimal, embedded-focused Linux distribution built entirely as a Nixpkgs overlay, demonstrating how to construct a bootable OS from scratch (kernel, initrd, squashfs root) using NixOS modules while replacing systemd with runit. The repository provides configurations for x86_64 QEMU, Raspberry Pi (ARM), and Xilinx Zynq targets, along with an iPXE boot chain featuring cryptographic signature verification for secure boot. It illustrates advanced Nix techniques for building custom initrds, integrating firmware, and creating reproducible embedded system images, though some components (like the dummy stage-2 init script placeholder) indicate a focus on flexibility over polish. The codebase is well-structured with clear module boundaries and includes Hydra CI integration for automatic testing.
PiLiDAR is a DIY 360° 3D panorama scanner application for Raspberry Pi. It integrates a LiDAR (LD06/STL27L), stepper motor, IMU, and Raspberry Pi camera to capture 2D scans and photos, then processes them into colored 3D point clouds and 360° panoramas. The system is orchestrated by a main Python script (PiLiDAR.py) that controls hardware, captures data, and runs post-processing pipelines. The codebase is modular with a library of device drivers, calibration utilities, and 3D processing functions. It supports hardware PWM via curve-fitted speed control, automatic exposure and white balance calibration, Hugin-based panorama stitching, and Open3D-based point cloud registration, meshing, and visualization. The architecture is monolithic but well-organized, with clear separation of concerns. Key strengths include robust LiDAR protocol handling, reusable stepper motor control, and a comprehensive point cloud processing pipeline. The project is actively maintained with recent commits and low technical drift, though it requires specific hardware and external tools (Hugin, rpicam-still) to function.
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.
Trainbot (Onlytrains) is a computer vision application that automatically detects trains passing a fixed camera, stitches the train's frames into a single composite image, and logs sightings to a SQLite database. It is designed to run on a Raspberry Pi with a camera (USB, Pi Cam 3, or video file) and can optionally upload results via FTP to a web server. The project is unmaintained as stated in the README. Architecturally, it is a monolith Go backend with three CLI binaries: `trainbot` (main detection loop), `confighelper` (interactive crop selection), and `cleanup` (orphaned blob removal). The backend captures frames using `pkg/vid` (abstraction over V4L2, libcamera-vid, ffmpeg), processes them through a stitch pipeline that detects motion, computes frame offsets via patch matching, fits a constant-acceleration model using RANSAC, and then blends frames into a single JPEG and an animated GIF. Results are stored in a SQLite database and served by a built-in HTTP server. The frontend is a Vue 3 static SPA that loads the SQLite database client-side to display train sightings, stats, and images with no server-side rendering. Key highlights include highly optimized image processing: the `pkg/pmatch` package offers four implementations of cosine-similarity patch search (slow Go, optimized Go, Cgo, Vulkan compute), and the `pkg/ransac` package provides a generic RANSAC fitter for the speed model. The codebase demonstrates strong engineering craftsmanship with a clear package structure, extensive tests, test data sets, and a CI pipeline. However, heavy reliance on Cgo and Vulkan, plus the explicit unmaintained status, introduce cross-compilation complexity and potential drift from modern tooling.
This repository contains a build system for FullPageOS, a Raspberry Pi distribution that boots directly into a full-screen Chromium browser kiosk displaying a configurable webpage. The build process uses CustomPiOS to modify a Raspbian base image, installing Chromium, lighttpd (with FullPageDashboard), x11vnc for VNC access, and a set of scripts that manage the browser startup, URL resolution (with serial number substitution), page refresh, and crash recovery. The resulting OS image is designed for digital signage or single-purpose web displays. The repo includes a comprehensive testing framework with end-to-end tests that run in QEMU, verifying Chromium launch, lighttpd service, emoji rendering, and translation disabling via screenshot pixel analysis. The CI pipeline builds images for armhf and arm64 and runs the e2e tests automatically. While the core build scripts are functional and well-structured, they are tightly coupled to the CustomPiOS ecosystem and not independently reusable. The testing components, particularly the screenshot analysis and headless Chromium rendering tests, exhibit higher craftsmanship and could be adapted for other kiosk image validation efforts.
flutter-pi is an embedded Flutter engine for Linux systems that enables running Flutter applications on hardware like the Raspberry Pi without an X11 or Wayland display server. It leverages DRM/KMS for display management, GBM for buffer allocation, and supports both OpenGL ES and Vulkan rendering backends. The application initializes the Flutter engine via its embedder API, sets up input handling (via libinput/evdev), and runs a main event loop (using systemd sd-event) to process vsync, input, and platform messages. The architecture is modular, separating concerns into core components: windowing, rendering (OpenGL/Vulkan), compositor, input, and a plugin system for extending functionality (e.g., audio, video, text input). Utilities for reference counting, logging, collections, and geometry are used throughout the codebase. The plugin system allows dynamic registration of Flutter platform channel handlers, enabling communication between Flutter Dart code and native plugins. While the codebase demonstrates solid engineering practices with reusable patterns (such as thread-safe reference counting and an event loop abstraction), it maintains tight coupling to the Flutter embedder API and Linux-specific graphics stack. Ongoing maintenance is evident through active CI/CD workflows and recent commits, though the presence of TODOs and conditional compilation flags indicates areas of technical debt and ongoing work.
This repository is the deCONZ REST plugin, a C++/Qt plugin that turns a ConBee/RaspBee Zigbee USB gateway into a full-featured IoT controller. It exposes a REST API (emulating Philips Hue) to manage lights, sensors, groups, scenes, rules, schedules, alarms, and devices over Zigbee (ZCL, ZDP, Green Power). The architecture is a monolithic Qt plugin running inside the deCONZ application, with a dedicated event loop, WebSocket server, and persistent SQLite database. Key entry points include `DeRestPlugin` (plugin interface), `DeRestPluginPrivate` (core logic), and REST handlers in files like `rest_lights.cpp`, `rest_sensors.cpp`, `rest_groups.cpp`. Device support is largely externalized via JSON Device Description Files (DDF) and embedded JavaScript (Duktape) for vendor-specific parsing. External dependencies include Qt 5/6, OpenSSL (dynamically loaded), Duktape, and system utilities (tar, gzip). The codebase is actively maintained with frequent commits, but contains technical debt from legacy device quirk handling and dual (DDF vs. legacy) initialization paths.
This repository is a collection of shell scripts for installing, upgrading, and managing MagicMirror², an open-source smart mirror platform. The scripts automate the setup of Node.js, npm, pm2, and the MagicMirror application on Raspberry Pi and other Linux systems, as well as macOS. They handle tasks such as initial installation, version upgrades, pm2 process management, screensaver disabling, disk cleanup, and switching to browser-over-server mode. The scripts are designed to be executed via curl pipe to bash, ensuring users always run the latest version. While primarily operational, the cleanup.sh script stands out as a well-structured, reusable utility for reclaiming disk space on any system.
This repository is a data collection and presentation project for single-board computer (SBC) benchmarks maintained by Jeff Geerling. It consists of a set of automated benchmarking scripts written in Python using the pyinfra orchestration tool, which can be run against any SSH-accessible SBC to gather standardized performance metrics including Geekbench, HPL (LINPACK), power consumption, memory bandwidth, disk I/O, GPU benchmarks, and AI inference performance. A secondary set of Ansible playbooks provides a simpler but less comprehensive alternative. All collected results are manually curated into a YAML file (web/data/results.yml) and rendered into a static Hugo website with a sortable comparison table. The repository serves as a public reference for SBC performance comparisons. While primarily a data research project focused on benchmarking hardware, it also provides reusable infrastructure for running benchmarks on any Linux or macOS system.
The PiSight project transforms a Raspberry Pi Zero with a camera module into a plug-and-play USB webcam by implementing the USB Video Class (UVC) standard via the Linux Gadget API. The hardware setup involves mounting the Raspberry Pi and camera inside an Apple iSight enclosure. Software-wise, the project provides scripts to configure the USB controller in OTG mode, build and install the UVC gadget framework, and activate the gadget as a systemd service. When connected to a host computer, the device appears as a standard webcam requiring no additional drivers. The core functionality resides in `rpi-uvc-gadget.sh`, which uses configfs to define a UVC device with multiple resolutions (640x480, 1280x720, 1920x1080) and formats (uncompressed and MJPEG) at various frame rates. The `setup.sh` automates dependency installation, compilation of the UVC gadget tools from freedesktop.org, and deployment of the service. A systemd unit ensures the gadget persists across reboots. This approach leverages kernel USB gadget infrastructure to create a seamless webcam experience.
This repository is a Jekyll-based static website that serves as a comprehensive database of PCI Express device compatibility with Raspberry Pi Compute Module 4 and Pi 5. It contains hundreds of markdown files documenting individual PCIe cards, carrier boards, and HATs, along with their functionality status, driver requirements, and community testing notes. The site is automatically built and deployed to GitHub Pages via GitHub Actions. While primarily a content site, it includes useful extras like a cross-compilation Docker environment for building custom Pi kernels, which is the most technically sophisticated component. The codebase is straightforward Jekyll with some custom plugins for thumbnail generation and YouTube embeds. The project is actively maintained with frequent additions of new hardware listings.
Tina is a header-only library providing lightweight user-space threading through coroutines and fibers, along with a fiber-based job system for task scheduling. The core library (tina.h) implements symmetric and asymmetric coroutine APIs with platform-specific assembly for context switching. Tina Jobs (tina_jobs.h) builds on this to create a job scheduler featuring work-stealing via queue chaining, memory pooling, and fiber-based job execution to avoid OS thread overhead. The repository includes examples (e.g., Mandelbrot renderer using Sokol graphics) and tests demonstrating usage, but the project has migrated to Codeberg due to philosophical opposition to AI training, indicating the GitHub repository is no longer actively maintained. While the Sokol dependencies in extras are third-party, the Tina core showcases strong craftsmanship in low-level concurrency primitives.
IBM TJBot is a Raspberry Pi-based robotics application that interacts with IBM Watson AI services through various 'recipes'. Each recipe demonstrates a different AI capability: conversation (chatbot using Watson Assistant, Speech to Text, and Text to Speech), sentiment analysis (monitoring Twitter tone and changing LED color), speech to text (voice-controlled LED), and translation (speech-to-speech language translation). The architecture consists of a core TJBot library that abstracts hardware and service interactions, with each recipe being a standalone Node.js application. Key entry points are the recipe-specific JavaScript files (conversation.js, sentiment.js, stt.js, translator.js) and the bootstrap script for Raspberry Pi setup. Data flows involve capturing input (audio, Twitter stream), processing through Watson services, and triggering hardware actions (LED, servo, speaker) based on results.
This repository provides the firmware and desktop tools for Petoi's quadruped robots (Bittle, Nybble, Chero). The core is an Arduino-based firmware (OpenCat.ino) running on ATmega328P (NyBoard) that handles servo control, gait generation, IMU integration, sensor processing (IR, ultrasonic, gesture, voice), and skill execution via pre-programmed motion sequences. A Python desktop application (pyUI) offers firmware upload, joint calibration, skill composition, and debugging. A Python serial API (serialMaster, OpenCatPythonAPI) enables scripting robot behaviors. The architecture is monolithic firmware with conditional compilation for multiple hardware variants and sensor options. While the project has a large user base and extensive documentation, the codebase shows signs of technical drift: it is explicitly legacy (development moved to OpenCatESP32), relies on outdated libraries, has duplicated code (e.g., three copies of IRremote), and uses global state and hardcoded paths. The skill system and serial protocol are well-defined patterns, but overall reusability is limited by tight coupling to specific hardware and board versions.
sysmon is a system monitoring and task management application that provides real-time visualization of system metrics through a web interface. It consists of a backend driver service built with Python/Falcon that exposes API endpoints for system data, and a frontend service available in both Python/Flask and Go implementations that serves an interactive dashboard. The application collects CPU, memory, disk, network, sensor, and process information using the psutil library, displays it via real-time charts (using SmoothieCharts) and tables, and allows process management operations (terminate, kill, suspend, resume) through a passcode-protected interface. The architecture features a clean separation between data gathering (hard.py), API endpoints (falc.py), and presentation layer (frontend templates and static assets).
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.
This repository is a curated list (awesome list) of embedded systems resources, including tutorials, books, tools, and links for various microcontrollers, RTOS, Linux kernel development, and more. It contains no executable code, libraries, or applications. The sole source file is a README.md that aggregates external references. As a static index, it serves as a reference for embedded engineers but offers no software architecture, reusable components, or functional logic.