Full-Douplex interrupt driven communication using SX1278.

[HamzaHajeir]

Hi

Thanks @jgromes for your support, I've solved my issue, It was due to ordering/timing. The other node can easily read the response from my gateway (ESP8266).

Emplying getIRQFlags(), I can easily identify the interrupt source, It had a discussion and collaboration here within issues.

The code is using only one flag inside the ISR, Two global flags to identify TX from RX packets.

Here's the Code :

// include the library
#include <RadioLib.h>
#define D1 5
#define D0 16
#define D2 4

const int csPin = D0;    // LoRa radio chip select
const int resetPin = D2; // LoRa radio reset
const int irqPin = D1;   // change for your board; must be a hardware interrupt pin
const int DIO1 = 10;     // change for your board; must be a hardware interrupt pin
const int DIO0 = irqPin; // change for your board; must be a hardware interrupt pin

// SX1278 has the following connections:
// NSS pin:   5 D1
// DIO0 pin:  16 D0
// RESET pin: 4 :D2
// DIO1 pin:  10 SD3
SX1278 radio = new Module(csPin, DIO0, resetPin, DIO1);

// or using RadioShield
// https://github.com/jgromes/RadioShield
//SX1278 radio = RadioShield.ModuleA;

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

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

volatile bool aFlag = false;


ICACHE_RAM_ATTR void setFlag(void)
{
    aFlag=true;
}

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

    Serial.print(F("[SX1278] Initializing ... "));
    int state = radio.begin();
    if (state == ERR_NONE)
    {
        Serial.println(F("success!"));
    }
    else
    {
        Serial.print(F("failed, code "));
        Serial.println(state);
        while (true)
            ;
    }
    radio.setDio0Action(setFlag);

    Serial.printf("Start Receiving");
    radio.startReceive();
}

void loop()
{
    if(aFlag){
        uint8_t flags = (uint8_t)radio.getIRQFlags();
        bool rxFlag = flags >> 6 & 0x01; // SX127X_CLEAR_IRQ_FLAG_RX_DONE = 0b01000000
        bool txFlag = flags >> 3 & 0x01; // SX127X_CLEAR_IRQ_FLAG_TX_DONE = 0b00001000
        Serial.printf("flags=%u\n", flags);
        //    radio.clearIRQFlags();
        if (rxFlag)
        {
            Serial.printf("ReceivedData\n");
            receivedFlag = true;;
        }
        else if (txFlag)
        {
            Serial.printf("TransmittedData\n");
            transmittedFlag = true;
        }
        aFlag = false;
    }
    // check if the previous transmission finished
    if (transmittedFlag)
    {
        // reset flag
        transmittedFlag = false;

        if (transmissionState == ERR_NONE)
        {
            Serial.println(F("transmission finished!"));
        }
        else
        {
            Serial.print(F("failed, code "));
            Serial.println(transmissionState);
        }

        Serial.printf("Start Receiving\n");
        radio.startReceive();

    }

    static bool respond = false;

    if (respond)
    {
        // send another one
        static int count = 0;
        Serial.print(F("[SX1278] Sending another packet ... "));

        String data = "Hello World" + String(count);
        transmissionState = radio.startTransmit(data);
        enableInterrupt = true;
        respond = false;
        count++;
    }

    if (receivedFlag)
    {
        receivedFlag = false;

        Serial.println(F("ReceivedFlag, Reading"));
        // you can read received data as an Arduino String
        String str;
        int state = radio.readData(str);


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

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

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

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

            // print frequency error
            Serial.print(F("[SX1278] Frequency error:\t"));
            Serial.print(radio.getFrequencyError());
            Serial.println(F(" Hz"));
        }
        else if (state == ERR_CRC_MISMATCH)
        {
            // packet was received, but is malformed
            Serial.println(F("[SX1278] CRC error!"));
        }
        else
        {
            // some other error occurred
            Serial.print(F("[SX1278] Failed, code "));
            Serial.println(state);
        }
        respond = true;

    }
}

It 's a demo to respond to an incoming message. the routines which separate TX and RX flags can easily extracted from the code above.

Hope you all the best success
Hamza Hajeir

[jgromes]

A slightly nitpicky correction - this is not full duplex, it's a time division full duplex emulation.

Full duplex means having the ability to transmit while receiving. SX127x (and all the other radio modules supported here) are half-duplex devices, they can't transmit while they're receiving, so to really achieve true full duplex, you'd need two SX127x modules.

Regardless, thanks for sharing :)

[HamzaHajeir]

That's correct,

Thanks for your correction.

[cmthomlinson]

Using the same code as above, however instead of the respond feauture after the receive, I have mine constantly transmitting a string in the main loop. Doing this however seems to prevent it from receiving anything. below is my code main loop. How can make this happen without it having to receive then transmit. I want it constantly transmit until it receives something.

if(aFlag)
{
    uint8_t flags = (uint8_t)radio.getIRQFlags();
    bool rxFlag = flags >> 6 & 0x01; // SX127X_CLEAR_IRQ_FLAG_RX_DONE = 0b01000000
    bool txFlag = flags >> 3 & 0x01; // SX127X_CLEAR_IRQ_FLAG_TX_DONE = 0b00001000
    //Serial.printf("flags=%u\n", flags);
    //    radio.clearIRQFlags();
    if (rxFlag)
    {
        Serial.printf("ReceivedData\n");
        receivedFlag = true;;
    }
    else if (txFlag)
    {
        Serial.printf("TransmittedData\n");
        transmittedFlag = true;
    }
    aFlag= false;  
}
if (transmittedFlag)
{
    
    //Serial.println(F("[SX1278] Sending another packet ... "));
    radio.startReceive();
    transmittedFlag = false;
}
if (receivedFlag)
{
    receivedFlag = false;
    String str1;
    int state = radio.readData(str1);
    Serial.println(str1);
    count++;
    
   
}
transmissionState = radio.startTransmit("Hello World!");
transmittedFlag = true;

[HeadBoffin]

You can't transmit continuously AND have the radio receive at the same time - there is literally a switch that changes the antenna connection from Tx output to Rx input on the SX chips.

You will have to stop transmitting, receive with a short timeout for a few ms and then return to transmission.

You may also want to consider that there are very very few jurisdictions that would legally allow continuous Tx.

[jgromes]

How can make this happen without it having to receive then transmit. I want it constantly transmit until it receives something.

You cannot. SX127x is a half-duplex device, period. It cannot transmit while receiving and vice versa. If you really do need a full duplex communication channel (which I would like to point out is not actually needed in most cases where LoRa makes sense), you will need to have 2 SX1278, one transmitting and the other receiving.

Also if you really do continually transmit, you might get a knock on the door from the appropriate authorities in your region.

[jgromes]

@HeadBoffin perfect sync! :)

• "knock knock"
• "who's the-"
• "race condition"

[cmthomlinson]

Could you guys provide an code example, thank you heaps

[HeadBoffin]

First post IS the example