A small group has pocket LoRa radios and a shared channel. Someone sends “meet at the north gate at 14:00” and gets silence back. Did everyone get it? Did anyone? This post is me thinking through how you would find out, and what it would take to do better than hoping. Nothing here is built yet. Some of it I have checked against documentation and some is arithmetic or guesswork, and I have tried to say which is which.
The setting I have in mind: ten to thirty people, each with a small LoRa node paired to a phone over Bluetooth, perhaps a few fixed repeaters on rooftops, and no dependence on the internet or the mobile network.
What “guaranteed” can mean
No radio system can promise that a message arrives. The honest version of the promise is: the message is delivered, or the sender finds out that it wasn’t. Even that splits into three levels, and they are worth keeping apart because each one costs more than the last.
flowchart LR
S["Sent"] --> N["1. Reached their radio"]
N --> P["2. Reached their phone"]
P --> H["3. A person saw it"]- Reached their radio. The node in their pocket or on their shelf decoded it. The radio can acknowledge this by itself.
- Reached their phone. The app was connected and has the message. Only the app can acknowledge this.
- A person saw it. Someone tapped something. Only a human can acknowledge this, and for anything that matters it is the one you want.
There is a fourth thing, which is not a level but a different property: catch-up. If a radio was switched off when the message went out, does it get the message when it comes back? Acknowledgements and retries don’t give you that. Something has to hold the message and offer it again later.
What MeshCore gives you today
I’m starting from MeshCore because it is what the group already has, it runs licence-free in the UK on 869 MHz, and a private channel is encrypted with a shared key.
| Message type | Routing | Acknowledged? | Catch-up? |
|---|---|---|---|
| Channel message | Flood | No | No |
| Direct message | Learned path, flood as fallback | Yes, by the recipient’s radio | No |
| Room server post | To the server, then pushed to members | To the server only | Partly |
- Channel messages always flood, because a group has no single path. I can find no acknowledgement for them in the FAQ or the companion protocol. The private channel a group naturally uses is therefore the one message type with no receipt.
- Direct messages are acknowledged. If the path is broken the sender retries up to three times, the last attempt as a flood. That is level 1 above, and only if the recipient is on the air at the time.
- Room servers keep history and push the last 32 unseen messages to a client when it logs in. That is the nearest thing to catch-up, but the poster gets no list of who has collected what.
So the pieces exist, but not joined up: receipts without groups, groups without receipts, and catch-up without either.
Approach 1: fan out direct messages
The cheapest thing that works. One app, at one place, holds a roster. To send a group message it sends the same text as a direct message to each person in turn, and watches the acknowledgements come back.
sequenceDiagram
participant C as Control app
participant M as Mesh
participant A as Radio A
participant B as Radio B
C->>M: DM to A, "north gate 14:00"
M->>A: deliver
A-->>C: ack
C->>M: DM to B, "north gate 14:00"
M--xB: lost
Note over C: timeout, retry
C->>M: DM to B (retry)
M->>B: deliver
B-->>C: ack
Note over C: roster shows A and B deliveredThe companion protocol already supports this. Sending a message returns an expected acknowledgement tag and a suggested timeout, and the acknowledgement arrives later as its own frame. The control app is bookkeeping: a queue, a table of who has acknowledged, and a retry policy more patient than three attempts.
What I like about it:
- Everyone else carries on using the stock app. Only the sender needs anything new.
- After the first exchange, direct messages follow a learned path, so the airtime is far lower than flooding.
- There is no new on-air protocol to design or get wrong.
What it doesn’t do:
- The acknowledgement comes from the radio, so it is level 1. A node on a shelf at home will cheerfully acknowledge on behalf of someone who is out.
- It isn’t a group conversation. Replies come back one to one, and nobody else sees them.
- N recipients means N transmissions, one after another. With thirty people and a slow channel, the last person hears a minute or more after the first.
- No catch-up, unless the control app keeps retrying for hours.
Approach 2: a receipt protocol on a private channel
The more interesting one. The companion protocol has a command for sending a typed binary datagram on a channel, with a data type value set aside for developers, and a payload of up to 165 bytes. A purpose-built app could speak its own small protocol inside a dedicated private channel, with no firmware changes. Radios without the app would ignore it.
A message would carry a sender id and a sequence number, because channel frames arrive without either. Each receiving app sends back a short acknowledgement. Then, every so often, each app broadcasts a digest: the highest sequence number it has seen from each sender.
sequenceDiagram
participant S as Sender app
participant A as App A
participant B as App B (off air)
S->>A: MSG s=17 "north gate 14:00"
S--xB: MSG s=17
A-->>S: ACK 17, delivered
Note over A: a person taps
A-->>S: ACK 17, seen
Note over B: back on air later
B->>S: DIGEST, last seen from S is 16
S->>B: MSG s=17 (resend)
B-->>S: ACK 17, deliveredThe digest is the part I find most promising. It is the idea behind gossip protocols and behind NNTP, and it turns “retry until I give up” into “eventually everyone converges”. A node that has been off for a day announces what it has, and anyone holding what it is missing can fill the gap. The sender does not even need to be the one who resends.
What it could do that nothing else here can:
- All three levels of receipt, including a human tap.
- Catch-up, from any peer that has the message.
- A real group conversation, with receipts shown per message: “seen by 14 of 19”.
What it costs:
- Everyone needs the app. And because a phone holds one Bluetooth connection to the radio, the app has to replace the stock one, which means doing ordinary chat as well. Either that, or a second radio.
- Background Bluetooth. To acknowledge without being opened, the app has to stay connected in the background. That is possible on both platforms and fiddly on both.
- Acknowledgement storms. Twenty apps each flooding an acknowledgement at the same moment will collide. They need random delay, and probably a smarter shape: one node collecting acknowledgements and flooding a single bitmap of who has confirmed.
- Spoofing. Everyone in the channel has the key, so anyone can claim to be anyone. A signature fixes that and eats 64 of the 165 bytes.
- Things I have not verified. I’d expect repeaters to drop a byte-identical resend as a duplicate, so each retry would need something changed in it. I don’t know how many datagrams the radio queues while the phone is away. The companion protocol document describes itself as still in development.
Approach 3: LoRa APRS
Amateur radio solved the first half of this in the 1990s. An APRS message is addressed to a callsign, carries a message id, and is acknowledged by the recipient with an explicit ack. The sender retries at a growing interval until it hears one. Duplicates are dropped by id. That is approach 1, standardised, with thirty years of clients behind it.
LoRa APRS puts the same frames on LoRa, in the UK on 439.9125 MHz. Ricardo CA2RXU’s tracker firmware does messaging on the device and also behaves as a Bluetooth TNC, so APRSdroid on Android or the aprs.fi app on an iPhone can be the messenger. There are newer apps too, such as TrackBridge.
And it bridges. This is the part MeshCore can’t match:
flowchart LR
T["LoRa tracker<br/>70 cm"] <--> I["LoRa iGate"]
I <--> IS(("APRS-IS"))
IS <--> V["VHF iGate"]
V <--> H["2 m handheld<br/>144.800"]
I <-. "cross-band digipeat,<br/>no internet" .-> D["VHF digipeater"]
D <-.-> HA message from a LoRa tracker can reach someone with an ordinary 2 m APRS handheld, and the acknowledgement finds its way back. Through APRS-IS that is routine, and depends on the internet at the gateways. Without the internet it needs a cross-band digipeater, which people have built.
The catches:
- Licensed operators only, with callsigns, in the clear. For some groups that rules it out at once. For a group of amateurs it is no obstacle, but privacy is gone.
- No group message with receipts. Bulletins go to everyone and are not acknowledged. A control app would fan out individual messages, exactly as in approach 1.
- No catch-up. Retries end. A gateway only passes a message to radio for a station it has heard recently.
- It is slow. The UK settings are spreading factor 12 in 125 kHz. See the airtime table below.
- A second radio. The boards are 433 MHz parts, not the 868 MHz ones MeshCore uses here.
Approach 4: let something else hold the message
Catch-up needs a store. Three places it could live:
- A MeshCore room server, as above. It exists today and needs no code. It gives catch-up of a sort and no receipts.
- A packet BBS. Connected-mode AX.25 is a reliable link by design, and a BBS is the original store-and-forward. With a NinoTNC and a handheld it is portable, just. It is the most proven option here and the least pocketable.
- DAPPS. This is my own store-and-forward layer for packet networks. It queues, forwards hop by hop, retries and acknowledges, and it can already use a MeshCore radio as a bearer. It was built for applications talking to applications through fixed nodes, not for phones in pockets, so I don’t yet know how well it fits. But the hard parts of approach 2 (queues, retries, deduplication, acknowledgement) are exactly what it exists to do once, below the application. It may be that the right answer is a thin phone app on top of DAPPS, not a new protocol.
Side by side
| DM fan-out | Channel receipts | LoRa APRS | Room server | Packet BBS | |
|---|---|---|---|---|---|
| Reached radio | Yes | Yes | Yes | Server only | Yes |
| Reached phone | No | Yes | Depends on client | No | Yes |
| Seen by a person | No | Yes | No | No | No |
| Catch-up | No | Yes | No | Last 32 | Yes |
| Group conversation | No | Yes | No | Yes | Bulletins |
| Custom software | Sender only | Everyone | Sender only | None | None |
| Licence needed | No | No | Yes | No | Yes |
| Private | Yes | Yes | No | Yes | No |
| Bridges elsewhere | No | No | APRS-IS, VHF | No | Packet network |
| Exists today | Nearly | No | Yes | Yes | Yes |
The same thing as a picture. Up is how much you learn about delivery; right is how much has to be built and installed.
quadrantChart
title Assurance against effort
x-axis Little to build --> Lots to build
y-axis Weak assurance --> Strong assurance
quadrant-1 Worth it if it matters
quadrant-2 Take these first
quadrant-3 Fine for chatter
quadrant-4 Avoid
Plain channel: [0.05, 0.05]
Room server: [0.12, 0.3]
LoRa APRS: [0.2, 0.5]
Packet BBS: [0.3, 0.68]
DM fan-out: [0.4, 0.55]
App on DAPPS: [0.7, 0.8]
Channel receipts: [0.9, 0.92]The placements are my judgement, not measurement. Move them and see whether your conclusion changes.
Airtime
Every scheme above spends airtime on acknowledgements, so it is worth knowing what a frame costs. These are calculated from the standard LoRa time-on-air formula, not measured, and I have assumed a 16-symbol preamble for MeshCore.
| Mode | Frame | Time on air |
|---|---|---|
| MeshCore UK (869.618 MHz, 62.5 kHz, SF8, CR 4/8) | 20 bytes, an acknowledgement | 0.3 s |
| 40 bytes | 0.5 s | |
| 120 bytes | 1.1 s | |
| 180 bytes, a full datagram with overhead | 1.6 s | |
| LoRa APRS UK (439.9125 MHz, 125 kHz, SF12, CR 4/5) | 30 bytes, an acknowledgement | 1.7 s |
| 60 bytes | 2.6 s | |
| 100 bytes | 3.9 s |
Each repeater that relays a flooded frame spends that time again. MeshCore in the UK sits in a band limited to a 10% duty cycle, which is 360 seconds an hour per transmitter. Twenty flooded acknowledgements through one repeater is about six seconds, so duty cycle is not the first limit. Collisions are: twenty radios answering the same message within the same second or two will mostly destroy each other. Whatever the protocol, the acknowledgements have to be spread out or folded together.
What I’d try, in order
- A room server, today, for anything that must not be missed. No code, and it tells me how far catch-up alone gets.
- DM fan-out from one control app. The smallest thing to build against the companion protocol, and it answers the main question: are radio-level receipts enough in practice?
- A human “seen” reply by convention. Before building level 3, try it socially: number the messages, and people reply with the number. If that works, the app is automating a habit and not inventing one.
- Only then the channel receipt protocol, or a phone app on DAPPS, whichever the first three steps point at.
Questions I can’t answer yet
- Is a radio-level receipt worth much when the radio is on a shelf and the person is in the garden?
- Does a group want receipts on everything, or only on the rare message that asks for one?
- How big can the group get before acknowledgements cost more airtime than the messages?
- Should the digest idea live in an app, in DAPPS, or in the radio firmware?
- Is there any point bridging a private MeshCore channel to APRS, given one is encrypted and the other must not be?
- If everyone needs a custom app anyway, is LoRa still the right bearer, or is this an argument for a better packet handheld?
If you have built any of this, or tried it and found out why it doesn’t work, I would like to hear about it.