Two \$17 Raspberry Pi Zero 2 W units exchange encrypted poems over Reticulum using Bluetooth only. Here’s a high precision re-enactment of the real time communications.
Reticulum is a protocol that encrypts content and destination providing one of the most secure way communicating currently available.
It is the brainchild of Mark Qvist (GitHub) who has devoted much of his adult life and savings to this project. Mark’s presentation Reticulum: Unstoppable Networks for The People (43 minutes) is available at the Chaos Computer Club‘s media site and on YouTube.
The main differentiation between Reticulum and Meshtastic or Meshcore is that:
- Reticulum is a protocol, it is not married to a specific transmission method, e.g. LoRa radio
- Reticulum has encryption all through the stack, so any prying eyes see nothing but garbage.
- Reticulum is based on Python
I became fascinated with this concept, especially in light of reading about the U.S. government using operation Stingray and trying to manipulate public protests by controlling the cellular service. Communication outside conventional carrier-controlled infrastructure matters in emergencies, remote areas, field work, and situations where centralized networks are unavailable, unreliable, or intentionally disrupted. My thought was that if participants could communicate outside of a government-controlled carriers, e.g. cell phone providers, the playing field would be a little more even. Especially if a government decides to shut down communication hoping to disrupt the protest. So I started investigating Reticulum and a popular device, the LilyGO T-Beam SUPREME – a \$42 communicator packing a wallop of electronic features. Its processor is an ESP32-S and the unit has 0.5 MB of RAM memory.
For the T-Beam, the practice is to run a Reticulum instance on a hand held device, e.g. Android phone, and then the Reticulum instance on the device connects to the T-Beam via Bluetooth and uses the T-Beam’s ability to send packets over Lora radio. The T-Beam is used as a modem. The more I learned about the T-Beam, the more I began to wonder: why not just run Reticulum on the T-Beam and have it communicate with the hand-held device via a Bluetooth interface. The problem is Reticulum is based on Python and Python requires a large infrastructure, so running Python on an ESP32, the processor used for the T-Beam, is problematic, if possible. Development on the ESP32 is traditionally C++, though Rust is starting to make inroad (hurrah! — see YouTuber The Rusty Bits video From Zero to ESP32 Bootloader in Embedded Rust). Well, it turned out there did not seem to be much in practice using that paradigm. So, a developer named Torlando developed a Bluetooth protocol but then diverted his attention to building a Reticulum client for hand-held devices: Columba. I believe having the link between the hand-held device and the T-Beam would be superior if each were its own instance of Reticulum, so I took the reins and with ChatGPT & Codex undertook to build a Bluetooth interface for Reticulum. I succeeded in getting the T-Beams to communicate with each other via Bluetooth, and then wondered… why not have Raspberry Pis communicate via Reticulum through Bluetooth. Granted, Bluetooth has a very limited range; however, Bluetooth is already built into most Pis, even the \$17 Pi Zero 2 W, so with no capital outlay, you can have a demonstration of Reticulum running between two \$17 units. Total cost \$54 (adding \$20 for two power plugs).
But what about the Raspberry Pi? While Reticulum can run on a Raspberry Pi, the avenues of sending packets is limited. You can use the Ethernet (TCP/IP) if your Pi has network connectivity or purchase a Lora Radio hat and grapple with getting the hat to work with a Reticulum instance on the Pi. The concept of having two inexpensive Rapsberry Pi Zero 2 W exchange text over a fully encrypted Reticulum network with no additional hardware was seductive. Reticulum was built in Python, aka “the snake language”. I’m a Perl enthusiast and have become fond of Rust. So, a compromise is Reticulum built on C++. I found a project by Chad Attermann where he implemented the Reticulum protocol using C++, the project is called microReticulum. The ESP32-S3 chip has 512 KB on-chip SRAM [Static Random Access Memory], per Espressif’s official ESP32-S3 datasheet.1 Since microReticulum is written in C++, it occupies a much smaller footprint making it ideal for running inside an ESP32.2 So, a new Bluetooth interface for Reticulum would need to be written in C++, not Python. Building such is what I undertook and succeeded in. (See the C++_migration branch my fork of Torlando’s project ble-reticulum.)
I had tested Torlando’s Python based ble-reticulum project using Reticulum based on Python on two Raspberry Pi Zero 2Ws as a proof that the interface worked. Now that I had a C++ version of the Bluetooth interface, I mused: why not run Chad Attermann’s C++ version of Reticulum and integrate my C++ BLE Bluetooth interface so I have two inexpensive Raspberry Pi units running a Reticulum link? Well, that’s just what I did.
In my T-Beam development, I have been creating a variety of exercises to test and prove components of the T-Beam, so in Exercise 306_microReticulum_ble_file_transfer_oled, I branched off and created programs that could run on the Pi Zero and send each other fixed texts, e.g. poems. In preparation for this post, I thought the reader might want to see a real-time rendition of two Raspberry Pis using Reticulum over Bluetooth, and that, in turn, ended up being a detour to create a scrolling side-by-side window, the subject of another post.
At the top of this post are logs from a 60 second run. Note that it takes several seconds, e.g. 12 seconds, for the two units to negotiate their roles and finally start transmitting their payloads to each other. This significant delay is especially why I felt a user should see a real time connection — this sets expectations that a Bluetooth connection does not immediately start working. The demonstration also shows in real time the transmission speed.
I have compiled binaries identified by what poem3 they sent available as follows. Here’s an install and requirements page (HTML Markdown). All you need are two Raspberry Pis running Raspbian Trixie.
- Little Boy Blue (644k)
- The Children’s Hour (644k)
I have the code staged in my own Forgejo; however, access is restricted only to registered users since AI bots were merciless in hitting the server. Submit a moderated comment (it will not be published) with your email address and preferred username if you would like access. With it, you can build your own binaries, e.g. sending what’s left of the United States Constitution.
- The LILYGO T-Beam Supreme board uses an ESP32-S3FN8 and adds/lists 8 MB PSRAM [Pseudo-Static Random Access Memory] and 8 MB flash, which are separate from the 512 KB internal SRAM. SRAM is the chip’s fast workbench. PSRAM is a larger side table. Flash is the filing cabinet. ↩
- See discussion at https://github.com/attermann/microReticulum/discussions/16↩
- Eugene Field, Little Boy Blue (1888). Henry Wadsworth Longfellow, The Children’s Hour (1860)
Leave a Reply