receive and transmit help

[radiohound]

I am sure I am doing something wrong. But I was wondering if someone could help me figure out why receive mode seems to lock up after transmitting. I tried to combine the interrupt driven TX and RX examples for the STM32WLxx chips. The code successfully receives a LoRa APRS position packet, and successfully digipeats the APRS LoRa packet. However, it is then locked up and does not hear any other packets.

Thanks for any help you can offer.

The output on the serial port during rx and tx is:

[STM32WL] Received packet!
[STM32WL] Data:         <�K6ATV-1>APLETK,WIDE1-1:!/;hpM/fWN>=sQ4.03V
sourceCall= K6ATV-1
destCall as received= APLETK,WIDE1-1

APLETK,WIDE1-1
digiPath= WIDE1-1
destCall= APLETK
outgoing= <�K6ATV-1>APLETK,K6ATV-9,WIDE1*:!/;hpM/fWN>=sQ4.03V
[STM32WL] Sending first packet ... [STM32WL] RSSI:              -40.00 dBm
[STM32WL] SNR:          4.50 dB

Original station:
20:02:29 K6ATV-1>APLETK,WIDE1-1:!/;hpM/fWN>=sQ4.03V -99 4

digipeated transmission:
20:02:32 K6ATV-1>APLETK,K6ATV-9,WIDE1*:!/;hpM/fWN>=sQ4.03V -60 7

code:

#include <Arduino.h>
#include <RadioLib.h>
#include <SPI.h>
#include <SubGhz.h>
#include <Wire.h> //Needed for I2C to GPS
#include "STM32RTC.h"
#include "STM32LowPower.h"

float loraFrequency = 433.775;
float loraBandWith = 125.0f;
uint8_t spreadingFactor = 12;
uint8_t codingRate = 5;
String myCall = "K6ATV-9";

// no need to configure pins, signals are routed to the radio internally
STM32WLx radio = new STM32WLx_Module();

APRSClient aprs(&radio);

// set RF switch configuration for EBytes E77 dev board
// PB3 is an LED - activates while transmitting
// NOTE: other boards may be different!
//       Some boards may not have either LP or HP.
//       For those, do not set the LP/HP entry in the table.
static const uint32_t rfswitch_pins[] = {PA6,  PA7,  PB3, RADIOLIB_NC, RADIOLIB_NC};
static const Module::RfSwitchMode_t rfswitch_table[] = {
{STM32WLx::MODE_IDLE,  {LOW,  LOW,  LOW}},
{STM32WLx::MODE_RX,    {LOW, HIGH, LOW}},
{STM32WLx::MODE_TX_LP, {HIGH, LOW, HIGH}},
{STM32WLx::MODE_TX_HP, {HIGH, LOW, HIGH}},
END_OF_MODE_TABLE,
};

// flag to indicate that a packet was received
volatile bool receivedFlag = false;

// this function is called when a complete packet
// is received by the module
// IMPORTANT: this function MUST be 'void' type
//            and MUST NOT have any arguments!
void setFlag(void) {
 // we got a packet, set the flag
 receivedFlag = true;
}

// save transmission state between loops
int transmissionState = RADIOLIB_ERR_NONE;

// flag to indicate that a packet was sent
volatile bool transmittedFlag = false;

// this function is called when a complete packet
// is transmitted by the module
// IMPORTANT: this function MUST be 'void' type
//            and MUST NOT have any arguments!
void setTransmissionFlag(void) {
 // we sent a packet, set the flag
 transmittedFlag = true;
}


void setup() {
 Serial.begin(115200);

 // set RF switch control configuration
 // this has to be done prior to calling begin()
 radio.setRfSwitchTable(rfswitch_pins, rfswitch_table);

 // initialize STM32WL with default settings, except frequency
 Serial.print(F("[STM32WL] Initializing ... "));
 //int state = radio.begin(868.0);
 int state = radio.begin(loraFrequency, loraBandWith, spreadingFactor, codingRate);
 if (state == RADIOLIB_ERR_NONE) {
   Serial.println(F("success!"));
 } else {
   Serial.print(F("failed, code "));
   Serial.println(state);
   while (true) { delay(10); }
 }

 // set appropriate TCXO voltage for STM32WLE
 state = radio.setTCXO(1.7);
 if (state == RADIOLIB_ERR_NONE) {
   Serial.println(F("success!"));
 } else {
   Serial.print(F("failed, code "));
   Serial.println(state);
   while (true) { delay(10); }
 }

 // set the function that will be called
 // when new packet transmission is finnished
 radio.setDio1Action(setFlag);

 // start listening for LoRa packets
 Serial.print(F("[STM32WL] Starting to listen ... "));
 state = radio.startReceive();
 if (state == RADIOLIB_ERR_NONE) {
   Serial.println(F("success!"));
 } else {
   Serial.print(F("failed, code "));
   Serial.println(state);
   while (true) { delay(10); }
 }

 // if needed, 'listen' mode can be disabled by calling
 // any of the following methods:
 //
 // radio.standby()
 // radio.sleep()
 // radio.transmit();
 // radio.receive();
 // radio.readData();
 // radio.scanChannel();

 // set output power to 22 dBm (accepted range is -17 - 22 dBm)
 if (radio.setOutputPower(22) == RADIOLIB_ERR_INVALID_OUTPUT_POWER) {
   Serial.println(F("Selected output power is invalid for this module!"));
   while (true) { delay(10); }
 }

 // set over current protection limit to 140 mA (accepted range is 45 - 240 mA) 
 if (radio.setCurrentLimit(140) == RADIOLIB_ERR_INVALID_CURRENT_LIMIT) {
   Serial.println(F("Selected current limit is invalid for this module!"));
   while (true);
 }  
}


void loop() {
 // check if the flag is set
 if(receivedFlag) {
   // reset flag
   receivedFlag = false;

   // you can read received data as an Arduino String
   String str;
   String LoRa_incoming_Data;
   String LoRa_outgoing_Data;
   int state = radio.readData(str);

   // you can also read received data as byte array
   /*
     byte byteArr[8];
     int numBytes = radio.getPacketLength();
     int state = radio.readData(byteArr, numBytes);
   */


   if (state == RADIOLIB_ERR_NONE) {
     // packet was successfully received
     Serial.println(F("[STM32WL] Received packet!"));

     // print data of the packet
     Serial.print(F("[STM32WL] Data:\t\t"));
     Serial.println(str);

     //state = radio.setTCXO(1.7);

     String LoRaHeader;
     String sourceCall;
     String destCall;
     String message;
     String digiPath;
     String digis[8];

       LoRa_incoming_Data = str;

       if (LoRa_incoming_Data.length() < 5)
         loop(); // bad packet start over
       int pos1, pos2;
       LoRaHeader = LoRa_incoming_Data.substring(0, 3);
       //Serial.println(LoRaHeader);
       pos1 = LoRa_incoming_Data.indexOf('>');
       if (pos1 < 5)
         loop(); // bad packet start over
       sourceCall = LoRa_incoming_Data.substring(3, pos1);
       Serial.print("sourceCall= ");
       Serial.println(sourceCall);
       pos2 = LoRa_incoming_Data.indexOf(':');
       if (pos2 < pos1)
         loop(); // bad packet start over
       destCall = LoRa_incoming_Data.substring(pos1 + 1, pos2);
       Serial.print("destCall as received= ");
       Serial.println(destCall);
       Serial.println(destCall.substring(pos2 + 1));
       Serial.println(destCall.substring(0, pos2));

     
       message = LoRa_incoming_Data.substring(pos2 + 1);
       digiPath = "";
       pos2 = destCall.indexOf(',');
       if (pos2 > 0) {
         digiPath = destCall.substring(pos2 + 1);
         destCall = destCall.substring(0, pos2);
       }
       if (destCall == "")
         loop();  // bad packet start over
       Serial.print("digiPath= ");
       Serial.println(digiPath);
       Serial.print("destCall= ");
       Serial.println(destCall);

       if (digiPath != ("WIDE1-1")){
        Serial.println("do not repeat"); 
        loop();  //do not digipeat if not WIDE1-1
       }
       //Change digiPath prior to digipeating
       digiPath = myCall + ",WIDE1*";
       LoRa_outgoing_Data = LoRaHeader + sourceCall + ">" + destCall + "," + digiPath + ":" + message;
       Serial.print("outgoing= ");
       Serial.println(LoRa_outgoing_Data);

       // set the function that will be called
       // when packet transmission is finished
       //radio.setDio1Action(setTransmissionFlag);
       radio.setDio1Action(setTransmissionFlag); //was setFlag - bad

       // start transmitting the first packet
       Serial.print(F("[STM32WL] Sending first packet ... "));

       // you can transmit C-string or Arduino string up to
       // 256 characters long
       transmissionState = radio.startTransmit(LoRa_outgoing_Data);
       delay(2000);
       // check if the previous transmission finished
       if(transmittedFlag) {
         // reset flag
         transmittedFlag = false;
    

         if (transmissionState == RADIOLIB_ERR_NONE) {
           // packet was successfully sent
           Serial.println(F("transmission finished!"));

           // NOTE: when using interrupt-driven transmit method,
           //       it is not possible to automatically measure
           //       transmission data rate using getDataRate()
         
           // clean up after transmission is finished
           // this will ensure transmitter is disabled,
           // RF switch is powered down etc.
           radio.finishTransmit();
           //radio.setDio1Action(setTransmissionFlag); //was setFlag - bad
           delay(1000);

         } else {
           Serial.print(F("failed, code "));
           Serial.println(transmissionState);

         }
       }
     // print RSSI (Received Signal Strength Indicator)
     Serial.print(F("[STM32WL] RSSI:\t\t"));
     Serial.print(radio.getRSSI());
     Serial.println(F(" dBm"));

     // print SNR (Signal-to-Noise Ratio)
     Serial.print(F("[STM32WL] SNR:\t\t"));
     Serial.print(radio.getSNR());
     Serial.println(F(" dB"));

   } else if (state == RADIOLIB_ERR_CRC_MISMATCH) {
     // packet was received, but is malformed
     Serial.println(F("CRC error!"));

   } else {
     // some other error occurred
     Serial.print(F("failed, code "));
     Serial.println(state);
   }

 } 

}

[StevenCellist]

I don't know many details, but one thing that comes to mind is that STM32WL with its SubGhz implementation doesn't handle subsequent interrupts very well. The STM32 contributor did implement a workaround but it may be the case that something fails there.
I cannot provide much more help, but it's my one cent.

[jgromes]

I also don't have the context, but there are some suspicious things in the posted code:

1. Why are you recursively calling loop? I get that it's an attempt to stop the decoding, but why not decode in a different function and then return from it?
2. There are some rather suspicious delays after startTransmit and finishTransmit.

[radiohound]

Thank you for your response Jan. I’ll try sectioning out into separate functions, and review/remove the delays. Walter

…

On Tue, Feb 18, 2025 at 9:12 AM Jan Gromeš ***@***.***> wrote: I also don't have the context, but there are some suspicious things in the posted code: 1. Why are you recursively calling loop? I get that it's an attempt to stop the decoding, but why not decode in a different function and then return from it? 2. There are some rather suspicious delays after startTransmit and finishTransmit. — Reply to this email directly, view it on GitHub <#1427 (comment)>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AAOA5OPHTAQ4HR5DKFEFFY32QNSWXAVCNFSM6AAAAABXKDLDR2VHI2DSMVQWIX3LMV43URDJONRXK43TNFXW4Q3PNVWWK3TUHMYTEMRTHE3TGOA> . You are receiving this because you authored the thread.Message ID: ***@***.***>

[radiohound]

Thank you for your suggestions. I ended up revising the code, using the Ping Pong example as a guide, and removed my delays. Also divided rx and tx into separate functions to clean it up a little. If anyone is interested, the working code is here: LoRa APRS digipeater The Ping Pong example does a good job of showing how to figure out if the interrupt is a received packet, or a TX finished interrupt. I appreciate the help.