Transmit and Receive Text via Interrupt Method and Byte Array

[Dems1984]

I am trying to send a mix of numbers and text via the radio.startTransmit byte array method. Here is the basic ping pong code I am testing with. I added to the union a char* variable (dataBuffChar) and set it to some text (variable char* text) for transmission and reception. Code compiles but I do not receive any text from the other SX126X board. I am using a SEEED Wio-LoRa-E5 Mini. Very little documentation on this so it has taken me some time to get to where I am with this project. It is similar to an STM32WLE5xx board. I am using the Arduino IDE. I am very new to this and have come to a road block on trying to figure out how to send text and numbers via the byte array method. I guess, first off, is it possible to do that with RadioLib and mix the two types of data or does one need to use the string method and parse out data from the transmitted string (radio.transmit(string))? Secondly, does the subroutine for radio.startTransmit not handle char variables? Does the text need to be converted to something else like a byte array and how would I add that to the union code defining the new field, dataBuffChar? If it involves a for next loop to pull each character out, how does one build such an array and feed it properly to RadioLib for transmit and for reception? It's been a frustrating week of lost hours on this. LOL. Any help is greatly appreciated. Below is a sample of the code being used. Note dataBuffChar in the union and adding that to the dataBuff8 array for sending and receiving: Thanks so much, everyone!

// BSP : STM32 boards groups by STMicroelectronics 2.7.1
// Borad select : STM Boards groups / LoRa boars
// Board part number : LoRa-E5 mini (Board to be selected from Tools submenu 'Board part number)

// 1. transmit data 12 bytes(Slave UID, mills(), Vbatt)
// 2. wait for response from Master
// 3. receive  data 12 bytes(Master UID, rssi, snr, reserved)
// 4. shutdown and wakeup

// 2024/02/11

#include <RadioLib.h>           // 6.4.2  https://github.com/jgromes/RadioLib
#include <STM32LowPower.h>      // 1.2.5  https://github.com/stm32duino/STM32LowPower
#include <STM32RTC.h>           // 1.4.0  https://github.com/stm32duino/STM32RTC

// RM0461 Reference manual Rev 8  37.1.4 IEEE 64-bit unique device ID register (UID64)
#define SLAVE_UID   *((uint32_t*)0x1FFF7580)    // use uid64 dor Slave device UID

// \Arduino15\packages\STMicroelectronics\hardware\stm32\2.7.1
// \variants\STM32WLxx\WL54JCI_WL55JCI_WLE4J(8-B-C)I_WLE5J(8-B-C)I\variant_LORA_E5_MINI.h : 173
STM32WLx radio = new STM32WLx_Module();
static const uint32_t rfswitch_pins[] =
                         {PA4,  PA5,  RADIOLIB_NC};
static const Module::RfSwitchMode_t rfswitch_table[] = {
  {STM32WLx::MODE_IDLE,  {LOW,  LOW}},
  {STM32WLx::MODE_RX,    {HIGH, LOW}},
//  {STM32WLx::MODE_TX_HP, {LOW, HIGH}},  // for LoRa-E5 mini
  {STM32WLx::MODE_TX_LP, {HIGH, HIGH}},   // for LoRa-E5-LE mini  
  END_OF_MODE_TABLE,
};

#define dataNum   24                // data bytes
union unionData {                   // for data type conversion
  uint32_t  dataBuff32[dataNum/8];
  float     dataBuff32F[dataNum/8];
  int16_t   dataBuff16[dataNum/4];
  char*     dataBuffChar[dataNum/4];
  uint8_t   dataBuff8[dataNum];
};
union unionData ud;

int rssi;               // signal RSSI [dBm]
int snr;                // signal SN ratio [dB]
uint32_t slaveuid = SLAVE_UID;    // Slave device UID
uint32_t masteruid;     // Master device UID
uint32_t ms;            // timer [mS]
uint32_t us;            // timer [uS]
char* text;
char printBuff[4];      // for sprintf()
String  txdata = "";    // transmission data packet string
String  rxdata = "";    // received data packet string
bool receivedFlag = false;     // flag that a packet was received
bool transmittedFlag = false;  // flag that a packet was transmitted

// *******************************************************************************************************
void setup() {
  Serial.begin(115200);
  while(!Serial);
  delay(1000);
  Serial.println("**** Wakeup ****");

  // Pin initialization
  pinMode(LED_RED, OUTPUT);         // built-in LED
  digitalWrite(LED_RED, HIGH);      // LED off

  // Radio initialization
  radio.setRfSwitchTable(rfswitch_pins, rfswitch_table);

  // int16_t begin(float freq = 434.0, float bw = 125.0, uint8_t sf = 9, uint8_t cr = 7, \
  // uint8_t syncWord = RADIOLIB_SX126X_SYNC_WORD_PRIVATE, int8_t power = 10, \
  // uint16_t preambleLength = 8, float tcxoVoltage = 1.6, bool useRegulatorLDO = false);
  int state = radio.begin(922.6, 125.0, 7, 5, 0x12, 13, 8, 1.7, 0);

  if (state == RADIOLIB_ERR_NONE) {
    Serial.println("radio.begin() success!");
  }
  else {
    Serial.print("failed, code ");
    Serial.println(state);
    while(true) {
      digitalWrite(LED_RED, LOW);
      delay(100);
      digitalWrite(LED_RED, HIGH);
      delay(100);      
    }
  }

  // callback function when received or transmitted a packet
  radio.setDio1Action(setFlag);

  // Configure low power
  LowPower.begin();
}


// this function is called when a complete packet is received or transmitted
void setFlag(void) 
{
  uint16_t irqstatus = radio.getIrqStatus();
  if(irqstatus == RADIOLIB_SX126X_IRQ_RX_DONE) {
    receivedFlag = true;
  }
  else if(irqstatus == RADIOLIB_SX126X_IRQ_TX_DONE) {
    transmittedFlag = true;
  }
  else {
    receivedFlag = false;
    transmittedFlag = false;
  }
}

// ***********************************************************************************************************
void loop() 
{
  // Slave transmits  data to Master *************************************************************************
  Serial.println("Transmitting packet ... ");

  // Slave transmits data
  ms = millis();
  us = micros();
  ud.dataBuff32[0] = slaveuid;    // Slave device UID
  ud.dataBuff32[1] = ms;          // mS timer
  ud.dataBuff32[2] = us;          // uS timer
  text = "BAM";
  ud.dataBuffChar[0] = text;


  digitalWrite(LED_RED, LOW);
  transmittedFlag = false;
  int state = radio.startTransmit(ud.dataBuff8, dataNum);
  digitalWrite(LED_RED, HIGH);

  txdata = "";
  for(int i = 0; i < dataNum; i++) {
    sprintf(printBuff, "%02x", ud.dataBuff8[i]);
    txdata += printBuff;
  }
  txdata.toUpperCase();
  Serial.println(txdata);

  Serial.printf("Slave UID:\t%08x\n", slaveuid);
  Serial.print("Time:\t\t"); Serial.print(ms); Serial.println(" mS");
  Serial.print("Time:\t\t"); Serial.print(us); Serial.println(" uS");
  Serial.print("Text:\t\t"); Serial.println(text);

  // wait for transmittion completion
  while(!transmittedFlag) {
    while(SubGhz.isBusy());
  }

  // error status check
  if (state == RADIOLIB_ERR_NONE) {
    // packet was successfully sent
    Serial.println("transmission finished!");
    Serial.println();
  } 
  else {
    // some other error occurred
    Serial.print("failed, code ");
    Serial.println(state);
  }


  // Slave receives response data from Master *********************************************************
  Serial.println("Waiting for incoming Masster response ... ");

  // start listening for LoRa packets
  state = radio.startReceive();
  if (state != RADIOLIB_ERR_NONE) {
    Serial.print("failed code ");
    Serial.println(state);
    while (true) {
      digitalWrite(LED_RED, LOW);
      delay(100);
      digitalWrite(LED_RED, HIGH);
      delay(100);
    }
  }

  // check if the flag is set
  while(!receivedFlag) {
    while(SubGhz.isBusy());
  }
  receivedFlag = false;

  // read a packet 
  state = radio.readData(ud.dataBuff8, dataNum);

  if (state == RADIOLIB_ERR_NONE) {
    // packet from Master was successfully received
    rxdata = "";
    for(int i = 0; i < dataNum; i++) {
      sprintf(printBuff, "%02x", ud.dataBuff8[i]);
      rxdata += printBuff;
    }
    rxdata.toUpperCase();
    Serial.println(rxdata);

    // restoration of received data
    masteruid = ud.dataBuff32[0];   // Maste device UID
    us = ud.dataBuff32[1];          // uS timer
    rssi = ud.dataBuff16[4];        // RSSI
    snr = ud.dataBuff16[5];         // SNR
    text = ud.dataBuffChar[0];

    Serial.printf("Master UID:\t%08x\n", masteruid);
    Serial.print("Time:\t\t"); Serial.print(us); Serial.println(" us");
    Serial.print("RSSI:\t\t"); Serial.print(rssi); Serial.println(" dBm");
    Serial.print("SNR:\t\t"); Serial.print(snr); Serial.println(" dB");
    Serial.print("Text:\t\t"); Serial.println(text);  
  }
  // error status check
  else {
    // some other error occurred
    Serial.print("failed, code ");
    Serial.println(state);
  }  

  // Sleep
  Serial.println("**** Sleep ****");
  Serial.println();
  Serial.flush();

  LowPower.shutdown(5000);
//  delay(5000);  
}

[jgromes]

I guess, first off, is it possible to do that with RadioLib and mix the two types of data

There are no "two types of data", there's just bytes. Regardless of whether the characters you are sending are printable or not, it's always bytes.

I tried to follow your code and I have failed completely, I have no idea what's going on there. So I suggest you take a step back. Try with a simple example sending strings. Then change those strings to a byte array that contains unprintable characters. Then move onto structs and unions. And only then introduce high-level logic such as the concept of a master or slave node.

PS: In your union you have an array of character pointers char* dataBuffChar[dataNum/4];, while I suspect what you wanted to do is an array of characters. Also on STM32, sizeof(char*) == sizeof(void*) == sizeof(uint32_t), so the size of your union is most likely not what you expect.

PPS: You seem to have tried to re-implement blocking transmission/reception, and have done it incorrectly. You are waiting for BUSY pin instead of DIO1. Why are you trying to re-implement something that is already done in the library?

[Dems1984]

Thank you so much for the prompt reply. Thank you for this library also. Lots of work for something nice for many to use. I will work on the suggestions you have put forth. I do get characters but they are incomprehensible on the receiving side. It's like the conversion from text to hex doesn't translate well. The dataBuff8 array has something but the hex values make no sense for characters. The numbers transmit and translate from hex well. I will look at size and pointers in the data stream and see if that fixes things but I also see nothing in the data stream that looks anything like the character I am sending even when trying to convert the hex values back over to ASCII. Good or bad... More to come after I work on your suggestions provided. Appreciate the help.

[Dems1984]

O.K. Nothing wrong with RadioLib as you said. It was all me. :-)

After your suggestion to review UNION and STRUCT, I came up with the following code that allows me to send and receive text and numbers. This is functioning for me but the code mentioned above is no longer valid and the below code is only presented as an example for others. It may be helpful for some:

typedef struct TransmitData { //Do not user wildcards like char*. Size of struct can't be determined reliably

uint32_t     slaveuid;                    //slave device UID
uint32_t     time_ms;                    //time in milliseconds
uint32_t      time_us;                    //time in microseconds
char       DispText[4];                  //Text of 4 characters

};

#define BytesToSend 16 //sizeof[TransmitData] //number of data bytes to transmit from struct TransmitData. Anaylze struct to determine value.

typedef union TransmitArray {

TransmitData  td;                         // include struct TransmitData, shortname alias of td
byte          dataByteArray[BytesToSend]; // byte array to be sent with all items of struct TransmitArray.

};

TransmitArray TA; //shortname alias for TransmitArray

The array, dataByteArray, from above now transmits properly with the following code:

state = radio.startTransmit(TA.dataByteArray, BytesToSend);

The code submitted originally used a UNION and when trying to assign values to the referenced variables in the union, using its logic, did not work for me when it came to text (i.e. dataBuffChar[0] in Slave transmits data section.... Even with the correction from char* to char for that variable definition in the UNION and changing the order to dataBuffChar[3]).

Thanks so much for the help and direction. It's helped a lot.