PacketRF

PacketRF is firmware for building IP-capable radio nodes that behave like ordinary network interfaces from the host side and like proper amateur radio modems on the air side. It is open source, it runs on RP2350 hardware, and it is designed as a platform — meaning it does not stop at one protocol or one board.

The project currently focuses on New Packet Radio by Guillaume F4HDK, because NPR is the most interesting actively deployed data-radio system on the 70 cm band and because there is a real opportunity to move it forward without breaking what already works. Beyond NPR, PacketRF is intended to grow into a more general experimentation platform for packet networks over RF, including classic AX.25 audio packet radio, additional transceivers, and eventually delay-tolerant networking on top of all of that.

What it actually is

A PacketRF node connects two worlds. On one side it speaks standard IPv4 — the HW shows up to your operating system as a regular network interface, gets an address, takes part in routing, and carries any traffic you care to push through it. On the other side it speaks whatever air protocol the firmware is currently running, today NPR over an SI4463 transceiver. There is no proprietary modem in the middle, no special tool to capture and forward the data; once the node is up, the radio link is just an interface like any other, and the rest of the stack does not need to know it is there.

Configuration and status live on a separate management interface, reachable both locally over USB and remotely over IP, including over the radio itself. That management interface uses CoAP and CBOR, requires authenticated writes, and is designed to be safe to leave it reachable on a real an open network. More on it in Quick Start, the Management CLI, and the developer-side Control Module.

Why this project

Existing amateur data systems sit at two extremes. Traditional packet radio is universal but slow and hard to extend past the assumptions it was built on in the 1980s. WiFi-derived systems like HSMM/Hamnet are fast, but they need bands and conditions that not every operator has access to and that not every experiment fits inside.

Between those two points there is a useful middle: usable IP throughput on lower bands, narrower channels, modest hardware, and a clean network model. NPR already lives in that middle. PacketRF is an attempt to give it a modern, maintainable codebase, a proper management options, and room to grow into more than one protocol family.

There is also a more personal motivation. Building a packet radio platform turns out to be a very direct way to learn, in detail, how IP networks actually behave when the link underneath them is genuinely constrained — a shared TDMA channel, narrow bandwidth, real latency, occasional silence or noise. That kind of environment is exactly where most modern "Internet networks" stop working, and where amateur radio can experiment and be interesting to use.

Current state

The current firmware does, today, the following:

runs as both NPR master and NPR slave, fully interoperable with the original F4HDK NPR firmware and existing deployed NPR networks,
carries IPv4 over the radio link with proper segmentation and reassembly,
exposes the radio side as a normal np2 network interface,
presents one or more local interfaces on the host side: USB (us0, CDC-NCM), optional W5500 Ethernet (et1), optional PPP (disabled by default),
bridges local Ethernet-like interfaces to the NPR side via a Proxy ARP implementation, so a host on USB can simply talk to a remote NPR station without a complicated routing settings,
accepts cryptographically authenticated management over CoAP, including key bootstrap on a fresh device,

Other things are deliberately out of scope right now: confidentiality on the air (it is not legal in most amateur services, and PacketRF respects that), real-time voice transport, anything that needs real-time and jitter-free data.

Hardware

PacketRF runs on any RP2350 board with at least 1 MB of flash. There are two hardware paths today.

The simplest is a Raspberry Pi Pico 2 with one SI4463 module wired to SPI and one IRQ line. It is cheap, it can be assembled in an evening, and it is enough for a real on-air NPR node. Add a W5500 Ethernet module and you get a small, fully usable multi-interface node. This is the path most people should start on, even if they intend to move to dedicated hardware later.

Minimal PacketRF NPR node: Pico 2 plus SI4463.

The longer-term hardware direction is the custom RF Baseboard Rev A, designed around the RP2350B. It carries two radio module slots, USB-C, W5500 Ethernet, 16 MB flash and optional PSRAM. The board exists as a working prototype but is not yet a public product — treat it as an engineering target, not as something to order today.

RF Baseboard Rev A prototype with SI4463 and audio module.

The SI4463 module shown in the Pico 2 photographs is a uArt.cz design, but PacketRF is not tied to it. Any SI4463 module that exposes SPI and an IRQ line can be used. RF quality, on the other hand, is not a detail — hand-wired builds need real filtering and a real look at the spectrum before they go on air. A module that works on SPI is not automatically a module that should transmit.

Full hardware notes, wiring, and pinouts are in Supported Hardware.

Control and security

Every PacketRF node is configurable, but configuration is not a free-for-all.

The management interface is reachable two ways: locally over USB serial, and remotely over IP using CoAP, including over the radio link itself. The same inner protocol is used in both cases, so the same prf-mgmt tool talks to the same node regardless of how you reached it.

Encrypting traffic on amateur frequencies is generally not allowed, and PacketRF does not try to. Authentication, however, is allowed almost everywhere, and it is what actually matters for a remotely manageable device. Each node has its own Ed25519 key pair and a small store of trusted public keys; configuration writes have to be signed by a key with the admin flag, and signed responses let the host tool verify it is talking to the device it expects.

This same crypto core is intended to be used for an extension to NPR itself, so that a master can require a connecting slave to prove its identity before it is admitted to the network. That part is specified in NEP-0002, but is not yet implemented in the PacketRF firmware. This will be part of the future work.

The current firmware stores keys in flash, which means a determined attacker with physical access can extract them. Future hardware revisions are expected to include a secure element. This is important to mention it here, so the limitations and expectations are clear from the start.

Where to go next

If you have hardware on the bench right now and want a node on the air, follow Quick Start. It walks through clone, build, flash, first-boot bootstrap and basic management.

If you want to understand the radio side first — TDMA scheduling, modulation choices, why ping behaves the way it does — read New Packet Radio in PacketRF, Modulation Profiles, Managed TDMA in NPR, and Latency and Ping Expectations.

If you want to understand how the firmware is put together, Platform Architecture is the entry point, and the per-module documentation under Module Documentation goes from there.

If you are interested in the future of the NPR protocol — authenticated admission, wire-format extensions and similar work — see the NEP index.

Background reading and the broader context behind the project lives on the author's blog:

The original NPR project page by Guillaume F4HDK is on Hackaday: NPR — New Packet Radio. PacketRF would not exist without it, and a few words on that history are in Original NPR Firmware and PacketRF.