This repository contains the K3NG Arduino CW Keyer, a highly configurable firmware for generating Morse code (CW) in amateur radio operations. The system runs on a wide range of Arduino-compatible microcontrollers (AVR, SAM, STM32, ESP32, Raspberry Pi Pico) and supports multiple input methods including paddles, straight keys, PS2 keyboards, USB keyboards (via MAX3421E USB host shield), and game controllers. It emulates the Winkey protocol for integration with logging software like N1MM+ and provides advanced features such as a CW decoder (using Goertzel algorithm), a built-in web server for remote control, beacon mode, practice/training modes, and SO2R (single operator two radio) support. The architecture is a monolithic Arduino sketch with extensive conditional compilation: over 20 hardware-specific configuration files (keyer_features_and_options_*.h, keyer_pin_settings_*.h, keyer_settings_*.h) allow tailoring the firmware to specific boards and feature sets. The main entry points are the standard Arduino setup() and loop() functions, with the web server module (k3ng_keyer_webserver.ino) providing HTTP-based control. External dependencies include the USB Host Shield library (for USB keyboard/controller input), Adafruit LiquidCrystal and TwiLiquidCrystal libraries (for LCD displays), and a PS2 keyboard library. The codebase is well-structured for its domain but carries significant complexity due to the sheer number of configuration combinations and bundled third-party libraries.
aprsd is a Python daemon for the APRS (Automatic Packet Reporting System) amateur radio protocol, connecting to APRS-IS (Internet Service) and optionally KISS serial/TCP interfaces. It receives and processes APRS packets through a pipeline of duplicate detection, type filtering, and a plugin-based message handler. The system also supports sending messages, beacons, and weather reports, with persistent storage of watch lists and tracked packets. The architecture is modular: client drivers abstract the network connection, a packet factory deserializes raw APRS frames into typed dataclasses, and a threading model handles RX processing, TX scheduling, and keepalive monitoring. Configuration is managed via oslo_config with a sample config generation command. The project is production-grade for its niche, with Docker support, CI/CD, and a documented plugin API for third-party extensions.
Dire Wolf is a software Terminal Node Controller (TNC) for amateur radio packet radio, specifically AX.25 and APRS. It replaces hardware TNCs by demodulating audio from sound cards or SDR receivers, decoding AX.25 frames, and providing network interfaces (KISS, AGW) for client applications like Xastir, APRSIS32, and UI-View. The codebase is a monolithic C application with threaded audio capture, multiple modem demodulators (AFSK, PSK, G3RUH, 9600bps), forward error correction (FX.25, IL2P), digipeating, IGate (internet gateway), GPS integration, DTMF/APRStt gateway, and telemetry decoding. It runs on Linux, Windows, and macOS. The architecture is single-process with multiple threads, using a global event queue for inter-module communication. Key entry points include the main `direwolf` daemon and several standalone utilities (`decode_aprs`, `kissutil`, `gen_packets`, `atest`, etc.). The implementation is production-grade, with extensive protocol handling and real-world tuning, but exhibits some monolithic design patterns and legacy code (vendored regex, geotranz).
Ham Dashboard is a browser-based web application that displays configurable content in a grid layout. It supports images (with rotation), videos, iframes (web pages), and RSS feeds. The application is built with vanilla JavaScript, HTML, and CSS, requiring no backend or build process. Configuration can be loaded from localStorage, config.js, config.json, or other JS/JSON files via URL parameters or file picker. Key features include a settings UI for configuration, full-screen viewing, right-click to rotate content, double-click to zoom, automatic content refresh, and breadcrumb-aware navigation between different dashboard configurations. The application is designed to be lightweight and easily hostable on static platforms like GitHub Pages or Cloudflare Pages.
This repository contains custom open-source firmware for Quansheng UV-K1/K5 V3 handheld ham radios, built around the PY32F071 MCU. It is a fork in the lineage DualTachyon → Egzumer → F4HWN → this project, adding features gated by compile-time flags (ENABLE_FEAT_F4HWN_*, ENABLE_NOAA, ENABLE_DTMF_CALLING, etc.). The firmware is bare-metal C (no RTOS in the application code despite CMSIS-RTOS2 RTX5 being vendored), with a main-loop architecture and an overlay app system using an app_api_t struct of function pointers. The build system uses CMake presets, per-app build.sh scripts, and a Docker wrapper (compile-firmware.sh) producing .elf/.bin/.hex artifacts. A pack_app.py script packs raw binaries into .app blobs. The repository vendors a large CMSIS_5 tree (~20k+ files), most of which is unused DSP/RTOS/validation code, bloating the repo. The README explicitly warns that flashing can brick radios, and overlay apps run with full privileges (no MPU). Notable engineering patterns include the overlay app API (function-pointer-based, placed in .text.entry section), an LL I2C driver mirroring STM32 LL conventions, and extensive conditional compilation. However, the codebase shows drift: deprecated compile-with-docker.sh retained as a forwarding shim, repetitive per-app build scripts, vendored CMSIS that may be outdated, and a license placeholder in the CMSIS bundle. Maintenance is active with recent commits, but the fork lineage and vendored dependencies create ongoing merge/upstream complexity. This is purely an embedded application repository - no datasets, ML models, or research artifacts are present.
This repository provides the firmware for a LoRa-based APRS iGate/digipeater station running on ESP32 microcontrollers. It bridges amateur radio APRS packets between LoRa RF and the internet (APRS-IS), and can also operate as a digipeater, TNC (KISS), weather station, and GPS tracker. The firmware includes a full web-based configuration UI, live map, MQTT integration, syslog, OTA updates, and support for dozens of hardware variants (Heltec, TTGO, etc.). The code is organized into modular C++ namespaces (LoRa_Utils, DIGI_Utils, APRS_IS_Utils, etc.) and uses a JSON-based configuration store. While the project is actively maintained, it shows some technical drift through vendored esptool binaries, dependency on older libraries (ElegantOTA), and heavy use of compile-time conditionals across board variants. The architecture is a classic embedded monolith targeting a single firmware binary, with strong hardware abstraction via pinout headers and a common configuration object. Several components—such as the KISS protocol encoder/decoder, the NetworkManager abstraction, and the Configuration class—are well-isolated and potentially reusable in other ESP32/ham radio projects.
This repository is an open-source hardware collection of RF front-end modules for low-cost RTL-SDR receivers, not a software application or data research pipeline. It is classified as application because its primary deliverable is a set of manufacturable PCB designs, schematics, and assembly documentation for discrete SDR building blocks. The repo contains complete design packages for an HF upconverter, multiple low-noise amplifiers with bias-tee powering, an SPDT antenna switch, a Mini-Whip active antenna, a balun, a PI attenuator, an RF power limiter, and fixed-voltage coax power supplies. Each module follows a consistent directory pattern: EasyEDA source files, Gerber exports, PDF schematics, component lists, datasheets, assembly guides, and enclosure model files. The RF signal flow runs from antenna through Mini-Whip, upconverter, filters, LNA, and protection stages into an RTL2832U-based SDR, with power injected over coax via bias-tee circuits. The real value of this repo is its modular, reproducible hardware architecture: well-documented bias-tee/power-over-coax designs, Mini-Circuits-based LNA and limiter circuits, and reusable RF layout techniques such as via stitching, ground pours, and controlled-impedance traces. The EasyEDA JSON files are tool-specific but self-contained and importable, and the Gerbers are ready for fabrication. Markdown guides cover component sourcing from LCSC, PCB ordering from JLCPCB/PCBWay, and Linux RTL-SDR setup, including known pitfalls like rtl_biast breakage after sudo make install. The project is explicitly described by the author as a final stable release with support ended, though recent commits in 2026 added new balun and RF power limiter designs, so the repository remains active. Limitations: this is hardware design data, not executable software, so there is no code to run, test, or integrate. The EasyEDA JSON format and .ftr filter design files are proprietary, some component choices (BF998, J310, ADE-1+, DF782, TC9-1+) are at risk of obsolescence, and the repository mixes EasyEDA editor versions from 2020 and 2026. For an engineer, the most reusable assets are the bias-tee power supply schematics, the balun and LNA reference designs, and the consistent module packaging pattern that makes each board a drop-in SDR building block.
The LoRa_APRS_Tracker is an embedded firmware application for ESP32-based hardware designed to function as an APRS (Automatic Packet Reporting System) tracker and transceiver. It integrates GPS tracking, LoRa radio communication, Bluetooth (Classic and BLE) for smartphone TNC connectivity, WiFi for wireless configuration, and support for various environmental sensors to telemetry data. The application features a menu-driven interface via OLED/TFT display and physical controls (buttons, joystick, touch, or keyboard), allowing users to configure beacon settings, view received packets, and manage messages. The architecture follows a modular utility pattern where distinct hardware and software components (e.g., GPS, LoRa, display, power management) are encapsulated in separate namespaced modules, each with setup and loop functions called from the main firmware loop. Configuration is managed through a hierarchical JSON-based system stored in SPIFFS, enabling persistent storage of user settings such as beacon profiles, LoRa parameters, and WiFi credentials. A built-in web server serves a responsive configuration portal (using Bootstrap) for initial setup and advanced settings via WiFi AP. Key capabilities include APRS beaconing with MIC-E encoding, two-way messaging, Winlink email integration over radio, digipeating, weather telemetry encoding, and power-saving features like GPS and LoRa module shutdown. The firmware supports numerous hardware variants through conditional compilation and variant-specific pin definitions, allowing the same codebase to compile for different ESP32 boards with various LoRa modules and sensors.
This repository contains a C-based frequency scanner for Gqrx, a software-defined radio (SDR) application. The scanner controls Gqrx via its remote TCP protocol to perform sweep or bookmark-based scanning, with integrated voice activity detection (VAD) for distinguishing speech from noise. The system supports interactive controls (skip, ban, pause frequencies) and automatic recording of detected signals. The architecture is a standalone CLI executable built with CMake, featuring two scanning modes: adaptive sweep (fast, with fine-tuning) and bookmark-based (reading Gqrx's bookmarks CSV). VAD is implemented using a G.729B-style pitch-based algorithm with LPC analysis, running on Linux via PipeWire audio capture. The codebase includes a comprehensive test suite using cmocka, with mock socket infrastructure for simulating Gqrx responses. Notable strengths include self-contained VAD modules and a reusable mock Gqrx protocol implementation. However, the code exhibits heavy use of global variables, some known bugs (e.g., unsigned underflow in frequency saving), and platform-specific limitations (VOX and sweep tests are Linux-only).