Part 2 which was more interesting than expected!!!

This is experimental and shouldn't be used in production. Don't transmit random stuff on ISM bands without understanding local duty cycle limits, ERP restrictions and other regulations!

In this cute post :3

• Understanding the sub-GHz radio's SPI interface
• Implementing low-level SPI communication with the radio
• Sending a LoRa packet from scratch!

Introduction

Yesterday I struggled with a simple blinky example, so I was sure the next part, which is getting the subGHz radio to work properly, would be even harder. But nope! It got all easy and comfy :>

The first thing I did was to compile and flash lora-rs example that sends LoRa packets. It was straightforward, worked well, and I was honestly kinda sad that it did. It's what I'm trying to achieve, I looked at commit amount in the repo, it was over 800! But such a small, insignificant trifle had NO POWER to bother me, so I started working!

How to talk to radio FREE tutorial OwO

First of all, I looked at the official STM32WLE5JC datasheet. I already knew that the radio is embedded in the MCU itself and it uses internal SPI lines to talk with the main Cortex-M4 core. The thing I missed was how to actually talk to it in code - I couldn't use a normal SpiDevice trait, since it was not connected via normal SPI. I decided to look at the RM0461 reference manual and found a chapter describing how the sub-GHz radio should be used. I also looked at the lora-rs repo to seek inspiration - seems like they're using a wrapper for SPI comms, so that it's treated like a regular SPI device.

The key was to create a struct for the sub-GHz device and provide an impl of the SpiDevice trait, so that the custom, internal SPI bus was exposed as a normal SPI in other places of the program. That was an important first step!

11/// Wrapper for the sub-GHz SPI device
12struct SubGhzSpiDevice<T>(T);
13
14impl<T: SpiBus> ErrorType for SubGhzSpiDevice<T> {
15    type Error = T::Error;
16}
17
18/// This works as a translation layer between normal SPI transactions and sub-GHz device SPI
19/// transactions. Everything above this layer sees it like a normal SPI device!
20impl<T: SpiBus> SpiDevice for SubGhzSpiDevice<T> {
21    /// Perform a transaction on the sub-GHz device
22    async fn transaction(&mut self, operations: &mut [Operation<'_, u8>]) -> Result<(), Self::Error> {
23        // Pull NSS low to allow SPI comms
24        pac::PWR.subghzspicr().modify(|w| w.set_nss(false));
25        trace!("NSS low");
26        for operation in operations {
27            match operation {
28                Operation::Read(buf) => {
29                    self.0.read(buf).await?;
30                    trace!("Read {:x}", buf);
31                },
32                Operation::Write(buf) => {
33                    self.0.write(buf).await?;
34                    trace!("Wrote {:x}", buf);
35                },
36                Operation::Transfer(read, write) => {
37                    self.0.transfer(read, write).await?;
38                    trace!("Read {:x} wrote {:x}", read, write);
39                },
40                Operation::TransferInPlace(buf) => {
41                    self.0.transfer_in_place(buf).await?;
42                    trace!("Read+wrote {:x}", buf);
43                },
44                Operation::DelayNs(_) => {}
45            }
46        }
47        // Pull NSS high
48        pac::PWR.subghzspicr().modify(|w| w.set_nss(true));
49        trace!("NSS high");
50        // Poll BUSY flag until it's done
51        while pac::PWR.sr2().read().rfbusys() {}
52        trace!("BUSY flag clear");
53        Ok(())
54    }
55}

After that was done, I consulted the RM0461 reference manual again, to see how to prepare the radio after the MCU boots. In section 4.7 it was explained in detail how should I wake up this lazy ass! The key was to use a Set_Standby() command over SPI bus, which I did simply by writing [0x80, 0x00] over the bus. Before that happens though, it was necessary to also restart the radio, so that it was in a known state before trying to communicate with it. I found the necessary information in section 6.1.4 - the way to do it was to simply pull the RFRST to high for a short while and then poll the RFBUSY signal until it was clear. The minimal code worked well (didn't hang on any operation lol) and I felt I was ready to go to the next phase.

57async fn reset_radio() {
58    debug!("Resetting the radio");
59    pac::RCC.csr().modify(|w| w.set_rfrst(true));
60    trace!("RFRST high");
61    Timer::after_millis(1).await;
62    pac::RCC.csr().modify(|w| w.set_rfrst(false));
63    trace!("RFRST low");
64    Timer::after_millis(1).await;
65    while pac::PWR.sr2().read().rfbusys() {}
66    debug!("Radio reset finished");
67}
68
69#[embassy_executor::main]
70async fn main(_spawner: Spawner) {
71    let mut config = Config::default();
72    {
73        config.rcc.msi = Some(MSIRange::RANGE48M);
74        config.rcc.sys = Sysclk::MSI;
75        config.rcc.mux.rngsel = mux::Rngsel::MSI;
76        config.enable_debug_during_sleep = true;
77    }
78    let p = embassy_stm32::init(config);
79
80    reset_radio().await;
81
82    let mut spi = SubGhzSpiDevice(Spi::new_subghz(p.SUBGHZSPI, p.DMA1_CH1, p.DMA1_CH2));
83    debug!("Writing SetStandby");
84    let _ = spi.write(&[0x80, 0x00]).await;
85    debug!("Radio in standby!");
86
87    loop {
88        Timer::after(Duration::from_secs(1)).await;
89    }
90}

Lo(l)Ra(wr) :3

The next part was TEDIOUS and KINDA BORING, but SO NICE IN THE END!

In the beloved RM0461 reference manual, in section 4.9.1, there's almost everything you need to know how to get started and send your first packet! The sequence looks like this:

The sub-GHz radio can be set in LoRa, (G)MSK or (G)FSK transmit operation mode with the following steps:

1. Define the location of the transmit payload data in the data buffer, with Set_BufferBaseAddress().
2. Write the payload data to the transmit data buffer with Write_Buffer().
3. Select the packet type (generic or LoRa) with Set_PacketType().
4. Define the frame format with Set_PacketParams().
5. Define synchronization word in the associated packet type SUBGHZ_xSYNCR(n) with Write_Register().
6. Define the RF frequency with Set_RfFrequency().
7. Define the PA configuration with Set_PaConfig().
8. Define the PA output power and ramping with Set_TxParams().
9. Define the modulation parameters with Set_ModulationParams().
10. Enable TxDone and timeout interrupts by configuring IRQ with Cfg_DioIrq().
11. Start the transmission by setting the sub-GHz radio in TX mode with Set_Tx(). After the transmission is finished, the sub-GHz radio enters automatically the Standby mode.
12. Wait for sub-GHz radio IRQ interrupt and read interrupt status with Get_IrqStatus():

• On a TxDone interrupt, the packet is successfully sent
• On a timeout interrupt, the transmission is timeout.

13. Clear interrupt with Clr_IrqStatus().
14. Optionally, send a Set_Sleep() command to force the sub-GHz radio in Sleep mode.

It seemed like a big scary list at first, but I thought I might just as well start and stop worrying about it. I went instruction by instruction, typing it manually like so:

    // SetBufferBaseAddress
    let _ = spi.write(&[0x8f, 0x00, 0x00]).await;
    // WriteBuffer (max 255 bytes, wraps around after that)
    let _ = spi.write(&[0x0e, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05]).await;
    // SetPacketType to LoRa
    let _ = spi.write(&[0x8a, 0x01]).await;

And so on, until I was finished. Some instructions were really straightforward to understand, others were a bit more confusing (like the Set_PaConfig() one), but in the end I spent like an hour going from the list, to function descriptions (though for some reason I used the SX1262 datasheet, even though the RM0461 actually HAS all the functions explained well, and it does NOT lack the additional stuff, like BPSK!). I fired up the finished program with all of the functions set up, and... nothing! I double-checked everything, but everything seemed correct, including the frequency calculation (which looks stupid wtffff).

(868_100_000 * 33_554_432) / 32_000_000 = 910_268_825
hex(910_268_825) = 0x36419999

It turns out, everything was MOSTLY correct, except for two things. First of all, I missed additional necessary instructions that should happen right after the radio is in Standby mode! The functions in question were SetDIO3AsTCXOCtrl, Calibrate and CalibrateImage. They're used (in order) for the following things:

1. Send power to the temperature-compensated crystal oscillator - without it the radio has no clock reference
2. Calibrate all the radio's internal analog blocks, including the oscillators or PLL
3. Calibrate image rejection for a specific frequency band the radio is supposed to be working with

This though was not enough! The last thing I was missing was something to actually let the signals go outside of the radio. To do that, I just had to set the RF switch to a proper TX mode (I found the necessary code in lora-rs repo, it seems to match my LoRa E5-mini board so that's nice):

    // Enable RF switch before tx
    let _ctrl1 = Output::new(p.PC4, Level::High, Speed::High); // TX
    let _ctrl2 = Output::new(p.PC5, Level::Low, Speed::High);  // RX
    let _ctrl3 = Output::new(p.PC3, Level::High, Speed::High); // EN

Wormks UwU

This was the last change I needed for the program to work! I saw a pretty LoRa signal on the SDR waterfall, beautifully centered on the exact frequency I wanted :3

I was SOOOO happy and really surprised it was this easy. I gained a lot of knowledge today and made a nice foundation which I'll refractor soon, to make base for all the other cool modulation types, all the possible configs, everything!

The working code is available here.

Byeeee :>

References

• STM32WLE5JC datasheet
• RM0461 reference manual - suuuuper helpful!!!
• SX1262 datasheet
• lora-rs repo