How to make receive function return value

[agat114]

Hello,
I am testing capabilities of SX126x-Arduino after using Lora.h in previous projects.
My question is how to a) put radio into reception mode to b) return received data for further comparison.
As the logic suggests received data may not always match test value. Also, it would be nice to break the loop after timeout.
I am looking for something like
for (RadioRx(30s)) {
data=OnRxDone();
if (data = testvalue) {
do something
Radio.Standby
break;
}
else {
keep on listening until timeout;
}

[beegee-tokyo]

Your code makes no sense. Why would you call RadioRX(30) in a loop? RadioRX is none blocking, it will return immediately.
There is no OnRxDone function, it is a callback when data has been received.

(1) setup the callbacks for RX and TX ==> // Initialize the Radio callbacks
(2) call RadioRX(30); // Sets radio in RX mode for 30 seconds, goes to sleep automatically after 30 seconds
(3) wait for RX callback called (if a packet was received) Function to be executed on Radio Rx Done event
(4) Handle received data in your loop(). To do this, you can set a flag in the callback and wait in the loop for that flag

Untested code snippet for RX only:

// Define LoRa parameters
#define RF_FREQUENCY 868000000	// Hz
#define TX_OUTPUT_POWER 22		// dBm
#define LORA_BANDWIDTH 0		// [0: 125 kHz, 1: 250 kHz, 2: 500 kHz, 3: Reserved]
#define LORA_SPREADING_FACTOR 7 // [SF7..SF12]
#define LORA_CODINGRATE 1		// [1: 4/5, 2: 4/6,  3: 4/7,  4: 4/8]
#define LORA_PREAMBLE_LENGTH 8	// Same for Tx and Rx
#define LORA_SYMBOL_TIMEOUT 0	// Symbols
#define LORA_FIX_LENGTH_PAYLOAD_ON false
#define LORA_IQ_INVERSION_ON false

static RadioEvents_t RadioEvents;

bool has_data = false;
uint8_t received_data[256];
uint16_t received_data_size = 0;

void OnRxDone(uint8_t *payload, uint16_t size, int16_t rssi, int8_t snr)
{
	Serial.println("OnRxDone");
	// Save received data
	memcpy(received_data, payload, size);
	received_data_size = size;
	// Set flag
	has_data = true;
}

void setup(void)
{
	// Initialize Serial for debug output
	Serial.begin(115200);

	// Initialize the Radio callbacks (only RX here)
	RadioEvents.RxDone = OnRxDone;

	// Initialize the Radio
	Radio.Init(&RadioEvents);

	// Set Radio channel
	Radio.SetChannel(RF_FREQUENCY);

	// Set Radio TX configuration
	Radio.SetTxConfig(MODEM_LORA, TX_OUTPUT_POWER, 0, LORA_BANDWIDTH,
					  LORA_SPREADING_FACTOR, LORA_CODINGRATE,
					  LORA_PREAMBLE_LENGTH, LORA_FIX_LENGTH_PAYLOAD_ON,
					  true, 0, 0, LORA_IQ_INVERSION_ON, TX_TIMEOUT_VALUE);

	// Set Radio RX configuration
	Radio.SetRxConfig(MODEM_LORA, LORA_BANDWIDTH, LORA_SPREADING_FACTOR,
					  LORA_CODINGRATE, 0, LORA_PREAMBLE_LENGTH,
					  LORA_SYMBOL_TIMEOUT, LORA_FIX_LENGTH_PAYLOAD_ON,
					  0, true, 0, 0, LORA_IQ_INVERSION_ON, true);
}

void loop(void)
{
	// Set LoRa transceiver to 30 seconds RX mode
	RadioRx(30);

	// Get start time of wait for RX
	time_t rx_start = millis();

	while (!has_data)
	{
		if ((millis() - rx_start) > 30000)
		{
			Serial.println("No data received in 30 seconds");
			break;
		}
	}

	if (has_data)
	{
		Serial.println("Received payload:");
		for (int idx = 0; idx < received_data_size; idx++)
		{
			Serial.printf("%02X ", received_data[idx]);
		}
		Serial.println("");
		has_data = false;
	}
}

[agat114]

Thank you @beegee-tokyo
Now I understand the logic - this is exactly how it could be constructed.
Also is there any bool timer/feature to control reception on? Like "while (radio_rx(1m)) do-something"
Does the radio go to stanby mode after Radio.Rx(30) expiration?
Thanks for the explanation. It's much more clear now.

[beegee-tokyo]

RadioRx is none blocking. It start the RX on the LoRa transceiver, then returns to your code. So you can do whatever you need to do while the radio is in RX mode.

In my examples and applications, I do not use the loop() function to wait for events. I am using timers, LoRa events and external interrupts to wake up the device by releasing a semaphore and setting an event flag. In the loop() I am using the xSemaphoreTake(g_task_sem, portMAX_DELAY); function. This will put the device into "sleep" until the semaphore is released by an event.

After RX timed out or after a packet was received, the LoRa transceiver goes into sleep mode, which is lower consumption than stand-by.

[agat114]

First conversion from Lora.h to SX126x.h is over. In my project I have to call receiver node several times. OnRxDone callback returns call received by node.

// initialization stage, listen for specific call for 50000ms
   Radio.Rx(50000);
    for (startSendTime = millis(); (millis() - startSendTime < 50000) && (lot != lot_nr); millis()) {
        lot=call;    
  } 
// listening is over or terminated
    if ((lot != lot) || (millis() - startSendTime >= 50000)) {
      Serial.println("No correct lot received");
      exit(0);
  }
  else {
  // Correct lot received, moving on to next part
  }

Later device is both listening and responding with status message.
...

  response = "I'm up and running"
  long startSendTime = millis();
  Radio.Rx(1200000);
  for (startSendTime; (millis() - startSendTime < 1200000) && (call != callsign); millis()) {
    if (call == callsign){
      for (int repeatCount=0; repeatCount < 5; repeatCount++) {
        Radio.Send((uint8_t *) &response, response.length());
        delay(100);
      }
    }

...

// Getting Lora status
Serial.println("This is radio status: " + Radio.GetStatus());

The code works in present form, but I'd like to understand logic of SX126x. What happens when I start Radio.Send, while radio is set to receive with Radio.Rx(1200000)? Does it interrupt Radio.Rx(some time) timer? When sending the response is over, would Radio state be back to RX o stay in TX or go to Idle? Should I interrupt radio states with RadioStandby()? Am I properly handling state transitioning?
I tried checking radio state with this statement, "Serial.println("This is radio status: " + Radio.GetStatus());" but it returns empty.

[agat114]

Would appreciate your critique.

[beegee-tokyo]

If the SX1262 is in RX mode and you call Radio.Send(), it will stop RX mode and send the packet. Then the transceiver is set to sleep.
To go back to RX mode you have to call Radio.Rx() again.

There are callbacks for both RX and TX available. You can go back to RX within the TX callback function if you wish to do so.