LinHT picking up M17 signal from a CC1200 hotspot.Close-up on the display. For direct M17 RF links, only one (upper) line is displayed, for Internet traffic over RF (hotspots transmitting ECD) two lines are shown.
By the way – we have some news from Vlastimil, OK5VAS.
PCBs (and stencils) are in Czech Republic, ready for assembly! Photo courtesy of Vlastimil SlintΓ‘k, OK5VAS.
While many people already know what LinHT is, not many are aware how it works. Yes, it’s an SDR radio – but what’s inside?
The core of the device is a System on Module running carefully crafted Yocto Linux image. It offers all the Linux things, including a file system, GPIO/ADC ports, beloved ALSA, and many other higher-level goodies, such as Python3 and gcc with make/cmake. The SoM uses the NXP i.MX9352: dual-core ARM Cortex-A55, clocked at 1.7GHz. There is also a quite powerful Neural Processing Unit available, but we are going to pretend it;s not there for now π
The system can run GNU Radio. Along with ssh/scp, it creates a powerful tool for amateur radio enthusiasts and RF engineers. This is definitely the best part, as the combination basically gives you a pocket computer with a full-blown SDR. It is no longer a black-box FM-only radio. This is actually a true, user-defined SDR. And it comes with a battery! Obsolescence is not an issue anymore. If a new protocol shows up in 5 years, it will most likely be possible to implement it on the LinHT. As GNU Radio blocks. It is that simple.
Let’s take a look at the internal structure of the device.
LinHT’s simplified block diagram (Rev A)
The GNU Radio flowgraph (as defined by a .grc file) can not do much on its own. The flowgraph has to be translated into Python code first. This is what the GR built-in grcccompiler does. So: after the flowgraph is prepared, it can be turned into an executable Python file (.py). The python code can be spawned by the Interface Daemon.
What the hell is that daemon for? Well – as a user, you need a way to tell the radio what to do. It is also good to know what the radio is actually doing, and if it’s aligned with the user’s intentions π You can not just turn the radio on (by turning the volume knob) and expect the OS to know what you want. This is what the daemon handles – your intent (by reading the keypad, PTT, etc.). It also uses the display to tell you want the radio is up to. But its function is not limited to that – it also controls the SX1255 RF front end chip and selects which flowgraph to run. It pre-configures the front end based on whatever settings are in the YML configuration file.
The daemon also communicates with the flowgraph and ALSA. The flowgraph is a mere state machine – it needs to know what to do and when (state transitions). Which mode are we using? Are we transmitting? Are we receiving? Has an M17 packet with a text message arrived? Or are we going to reply to it? The daemon tells the flowgraph what and when to do it. The flowgraph can not just simply stay free-running all the time.
Linux makes things easy here – the daemon works as a system service.
Now the ZeroMQ Proxy. Since ALSA can be a pain in the rear to configure and work with, we decided to put a very simple additional layer between the SX1255 (again – disguised as ALSA sound device) and the GNU Radio flowgraph. There is a simple C code doing the proxy work: bi-directional ALSA-ZMQ bridge for baseband samples. Now, instead of using Audio Source/Sink blocks to access baseband (that did not work) we can now do the same task with ZMQ PUB/SUB Sink/Sources, connected to a pair of IPC sockets using very little CPU resources. Clever, right?
The flowgraph can notify the daemon that it received something – this can be anything – in our case it’s an M17 packet reception. The flowgraph uses ZeroMQ with an IPC socket (again) to announce RF events. This path is used for non-audio streams (data). Audio streams are routed directly to ALSA through an Audio Sink.
Microphone signal is handled by ALSA as well. It is sampled by the flowgraph directly.
PTT signal handler is simple as well – we use the daemon here again. In an infinite loop, we read the keypad state (and the PTT). PTT press and release events trigger a ZeroMQ message transmission from the daemon to the flowgraph. The state machine in the flowgraph (M17 Coder/Decoder blocks have appropriate handlers built-in) reacts to the message and either starts reception or transmission. SX1255 (and the rest of the RF front end) is configured in the same way – by the daemon, upon user input.
I hope this article is understandable and clarifies how LinHT works under the hood. It is not very detailed, as I did not want it to be too long. I just wanted to cover the core idea.
Today, I decided to stress-test my LinHT Rev A prototype. The aim was to assess the battery life in the following conditions: minimal transmission time – mostly reception. I used a CC1200 hotspot connected to M17-KCW A as a solid M17 RF source (with stable traffic). The handheld’s backlight (including keypad) was kept on for the whole test duration. Stock Retevis C62 2S Li-ion battery was used, fully charged on the previous day (in the evening). A modified charger was used – I replaced the 0.47ohm resistor with a 0.33ohm one* (a stack of three 1ohm resistors) for increased charge current. Silicon thermal pads were used to allow the SoC to dissipate heat through the aluminum part of the chassis (see this entry for details).
I started the test by switching the volume knob at 9:17 LT. The starting battery voltage was 8.05V.
CPU slightly below 41 deg. C after 10 hours of continuous DSP work? I think this is a very good result. This would definitely not be possible without some DSP tweaks we introduced in the M17 GNU Radio flowgraph. I had to quickly reset the flowgraph in the first 30 minutes due to an unexpected segfault π The cause is yet to be found.
Last but not least – big shout out to the rest of our team – Andreas OE3ANC and Vlastimil OK5VAS, and every financial contributor out there. Let’s keep this up π
*the values are taken off the top of my head – I believe they are correct. The idea is to slightly reduce the resistance to increase the current.
Hell yeah! Vlastimil, OK5VAS, managed to prepare an example LinHT SoapySDR driver for the SX1255. This allows OpenWebRX to be ran on the device, fetching IQ baseband samples directly from the ZMQ proxy (described a few posts back).
OpenWebRX decodes M17, along with other digi modes.
Successful APRS decode. Courtesy of Vlastimil, OK5VAS
Astonishing work! This is the innovation amateur radio world needs. Can your radio do this? π
Note: please do not order anything yet – the design is not production ready.
The design requires a review – we encourage everyone to take a look at it. The GitHub repository holds a complete KiCAD project (we love KiCAD!). The full schematic is here.
We’ve just got LinHT to work as a complete M17 transceiver – able to transmit and receive RF signals without the need to use SSH to issue any commands. This was not as easy as we expected, due to ALSA-related problems (Linux users probably know what I mean).
The issue was GNU Radio not allowing us to use SX1255 baseband source and sink within a single flowgraph. Just to remind you – the SX1255 is seen by the OS as a sound device. I and Q baseband branches are disguised as Left and Right audio channels π Andreas OE3ANC proposed a simple workaround – daemonized ZeroMQ publisher/subscriber proxy for both directions. Then, instead of using GNU Radio’s Audio Sink/Source blocks, the baseband is accessed through ZMQ PUB/SUB blocks. PTT signal is handled as GNU Radio’s native “Message PMT”.
Right now, using LinHT for M17 is as simple as turning the device on and a PTT press. The GUI daemon loads all the RF front-end and M17 settings from a YAML file. There is still a lot of work to do, especially to improve the receiver path, as the SX1255 is really sensitive and gets saturated easily. This is why we added a variable RF attenuator in Rev B.
None of the achievements or work mentioned above would be possible without our core contributors: Andreas OE3ANC and Vlastimil OK5VAS. Working on LinHT with you is an amazing journey!
A demo video will be shared later, while LinHT’s Revision B is still being prepared, so stay tuned!
Edit: this is how our M17 transceiver looks like, defined with a GNU Radio flowgraph. Two upper signal paths define the receiver, the last one (bottom) is the transmitter. Big shout out to Jean-Michel Friedt for all the help with gr-m17 development.
This is how the Rev B board looks like (WIP). PCB designed by Vlastimil OK5VAS.
There is still some more work to do, so stay tuned. Big shout out to everyone who donated to our Foundation. Every dollar counts: your donations help us do magnificent things.