How to set up multiple nodes without interfering certain nodes? SX1276/RFM95 modules

[nkebx2]

I wish to set up a Lora node system running with multiple arduino-SX1276 modules. I tried the SX127x_Transmit and SX127x_Receive templates, it worked perfectly. However, when I added one or more transmitter/receiver, some of the incoming data could be missing.

May I know it possible to add an address to every node, so that the message sent from one node wouldn't be interfering to the other nodes?

/*
   RadioLib SX127x Receive Example

   This example listens for LoRa transmissions using SX127x Lora modules.
   To successfully receive data, the following settings have to be the same
   on both transmitter and receiver:
    - carrier frequency
    - bandwidth
    - spreading factor
    - coding rate
    - sync word
    - preamble length

   Other modules from SX127x/RFM9x family can also be used.

   For default module settings, see the wiki page
   https://github.com/jgromes/RadioLib/wiki/Default-configuration#sx127xrfm9x---lora-modem

   For full API reference, see the GitHub Pages
   https://jgromes.github.io/RadioLib/
*/

// include the library
#include <RadioLib.h>
// SX1276 has the following connections:
// NSS pin:   10
// DIO0 pin:  2
// RESET pin: 9
// DIO1 pin:  3
SX1276 radio = new Module(10, 2, 7, 5);
// or using RadioShield
// https://github.com/jgromes/RadioShield
//SX1276 radio = RadioShield.ModuleA;


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

  // initialize SX1276 with default settings
  Serial.print(F("[SX1276] Initializing ... "));
  int state = radio.begin();
  if (state == ERR_NONE) {
    Serial.println(F("success!"));
  } else {
    Serial.print(F("failed, code "));
    Serial.println(state);
    while (true);
  }

  
  // set carrier frequency to 433.5 MHz
  if (radio.setFrequency(915.0) == ERR_INVALID_FREQUENCY) {
    Serial.println(F("Selected frequency is invalid for this module!"));
    while (true);
  }

  // set bandwidth to 250 kHz
  if (radio.setBandwidth(125.0) == ERR_INVALID_BANDWIDTH) {
    Serial.println(F("Selected bandwidth is invalid for this module!"));
    while (true);
  }

  // set spreading factor to 10
  if (radio.setSpreadingFactor(7) == ERR_INVALID_SPREADING_FACTOR) {
    Serial.println(F("Selected spreading factor is invalid for this module!"));
    while (true);
  }

  // set coding rate to 6
  if (radio.setCodingRate(5) == ERR_INVALID_CODING_RATE) {
    Serial.println(F("Selected coding rate is invalid for this module!"));
    while (true);
  }

  // set LoRa sync word to 0x14
  // NOTE: value 0x34 is reserved for LoRaWAN networks and should not be used
  if (radio.setSyncWord(0x12) != ERR_NONE) {
    Serial.println(F("Unable to set sync word!"));
    while (true);
  }
}

void loop() {
  Serial.print(F("[SX1276] Waiting for incoming transmission ... "));

  // you can receive data as an Arduino String
  // NOTE: receive() is a blocking method!
  //       See example ReceiveInterrupt for details
  //       on non-blocking reception method.
//  String str;
//  int state = radio.receive(str);

  // you can also receive data as byte array
//  
    byte byteArr[8];
    int state = radio.receive(byteArr, 8);

  if (state == ERR_NONE) {
    // packet was successfully received
    Serial.println(F("success!"));

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

    Serial.println(byteArr[1]);

    // print the RSSI (Received Signal Strength Indicator)
    // of the last received packet
    Serial.print(F("[SX1276] RSSI:\t\t\t"));
    Serial.print(radio.getRSSI());
    Serial.println(F(" dBm"));

    // print the SNR (Signal-to-Noise Ratio)
    // of the last received packet
    Serial.print(F("[SX1276] SNR:\t\t\t"));
    Serial.print(radio.getSNR());
    Serial.println(F(" dB"));

    // print frequency error
    // of the last received packet
    Serial.print(F("[SX1276] Frequency error:\t"));
    Serial.print(radio.getFrequencyError());
    Serial.println(F(" Hz"));

  } else if (state == ERR_RX_TIMEOUT) {
    // timeout occurred while waiting for a packet
    Serial.println(F("timeout!"));

  } else if (state == 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);

  }
}

/*
   RadioLib SX127x Transmit Example

   This example transmits packets using RFM95 LoRa radio module.
   Each packet contains up to 256 bytes of data, in the form of:
    - Arduino String
    - null-terminated char array (C-string)
    - arbitrary binary data (byte array)

   Other modules from SX127x/RFM9x family can also be used.

   For default module settings, see the wiki page
   https://github.com/jgromes/RadioLib/wiki/Default-configuration#sx127xrfm9x---lora-modem

   For full API reference, see the GitHub Pages
   https://jgromes.github.io/RadioLib/
*/

// include the library
#include <RadioLib.h>

// RFM95 has the following connections:
// NSS pin:   10
// DIO0 pin:  2
// RESET pin: 9
// DIO1 pin:  3
RFM95 radio = new Module(10, 2, 7, 5);

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

#include "DHT.h"
#define DHTPIN 8
#define DHTTYPE DHT11 
DHT dht(DHTPIN, DHTTYPE);
// Generally, you should use "unsigned long" for variables that hold time
// The value will quickly become too large for an int to store
unsigned long previousMillis = 0;        // will store last time LED was updated

void setup() {
  Serial.begin(9600);
  dht.begin();
  
  // initialize RFM95 with default settings
  Serial.print(F("[RFM95] Initializing ... "));
  int state = radio.begin();
  if (state == ERR_NONE) {
    Serial.println(F("success!"));
  } else {
    Serial.print(F("failed, code "));
    Serial.println(state);
    while (true);
  }

  // set carrier frequency to 433.5 MHz
  if (radio.setFrequency(915.0) == ERR_INVALID_FREQUENCY) {
    Serial.println(F("Selected frequency is invalid for this module!"));
    while (true);
  }

  // set bandwidth to 250 kHz
  if (radio.setBandwidth(125.0) == ERR_INVALID_BANDWIDTH) {
    Serial.println(F("Selected bandwidth is invalid for this module!"));
    while (true);
  }

  // set spreading factor to 10
  if (radio.setSpreadingFactor(7) == ERR_INVALID_SPREADING_FACTOR) {
    Serial.println(F("Selected spreading factor is invalid for this module!"));
    while (true);
  }

  // set coding rate to 6
  if (radio.setCodingRate(5) == ERR_INVALID_CODING_RATE) {
    Serial.println(F("Selected coding rate is invalid for this module!"));
    while (true);
  }

  // set LoRa sync word to 0x14
  // NOTE: value 0x34 is reserved for LoRaWAN networks and should not be used
  if (radio.setSyncWord(0x12) != ERR_NONE) {
    Serial.println(F("Unable to set sync word!"));
    while (true);
  }
  
  // some modules have an external RF switch
  // controlled via two pins (RX enable, TX enable)
  // to enable automatic control of the switch,
  // call the following method
  // RX enable:   4
  // TX enable:   5
  /*
    radio.setRfSwitchPins(4, 5);
  */
}

void loop() {
  byte byteArr1[8];
  int state = radio.receive(byteArr1, 8);

  if (state == ERR_NONE) {
    // packet was successfully received
      if(byteArr1[0]==254){
        Serial.println(F("success!"));
        Serial.print("           ");
        Serial.println(byteArr1[1]);
      }else{
        Serial.println("Wrong address");
      }
  }else if (state == ERR_RX_TIMEOUT) {
    // timeout occurred while waiting for a packet
    Serial.println(F("timeout!"));

  } else if (state == 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);

  }
  
  unsigned long currentMillis = millis();

  if (currentMillis - previousMillis >= 1000) {
      previousMillis = currentMillis;
      
  Serial.print(F("[RFM95] Transmitting packet ... "));

  // you can transmit C-string or Arduino string up to
  // 256 characters long
  // NOTE: transmit() is a blocking method!
  //       See example SX127x_Transmit_Interrupt for details
  //       on non-blocking transmission method.

  // you can also transmit byte array up to 256 bytes long
  
    float t = dht.readTemperature();
    // Read temperature as Celsius (the default)
    if (isnan(t) ) {
      Serial.println("Failed to read from DHT sensor!");
      return;
    }
    Serial.print("Temperature: ");
    Serial.print(t);
    Serial.println("°C ");
    int (temp) = int (t);
    
    byte byteArr[] = {0xFF,temp};
    int state = radio.transmit(byteArr, sizeof(byteArr));
     

  if (state == ERR_NONE) {
    // the packet was successfully transmitted
    Serial.println(F(" success!"));
    // print measured data rate
    Serial.print(F("[RFM95] Datarate:\t"));
    Serial.print(radio.getDataRate());
    Serial.println(F(" bps"));
  } else if (state == ERR_PACKET_TOO_LONG) {
    // the supplied packet was longer than 256 bytes
    Serial.println(F("too long!"));
  } else if (state == ERR_TX_TIMEOUT) {
    // timeout occurred while transmitting packet
    Serial.println(F("timeout!"));
  } else {
    // some other error occurred
    Serial.print(F("failed, code "));
    Serial.println(state);
  }

  }
}

[jgromes]

LoRa physical layer has no concept of "node address", you will have to implement that yourself. For example, a byte at the start of every packet inidicating its target node. All nodes in this setup would be constantly listening and receiving all packets sent in the network, and only process those intended for them.

Since your nodes are running asynchronously, some sort of liste-before-talk feature could also be handy here - channel activity detection prior to any transmission should be enough to achieve that.

Also, one thing I noticed in your sketch:

int (temp) = int (t);
byte byteArr[] = {0xFF,temp};

On Arduino Uno, temp will be 2-byte variablem so you will only have the lower byte of tempterature in your byte array - not sure if that's intended or not. If you can spare 3 more bytes in the packet, you can send the raw float number without any precision loss.

[jgromes]

I see you're using a blocking receive method, I suggest using interrupt receive instead. Blocking receive is going to have pauses between receive windows, so if the node transmits within that pause, there's nothing to receive it. Interrupt-receive has no such pauses, it is always in receive mode and will generate an interrupt when a packet is received.

[nkebx2]

Thank you for your reply.

Is it possible to use this receiver interrupt unit as an transmitter interrupt at the same time? Or a transceiver interrupt.

[jgromes]

You need only interrupt-driven receive, transmit can be left as blocking - though you have to keep in mind you will have to call clearDio0Action prior to transmit so that setFlag function isn't called during transmission, because that will change the state of DIO0 pin. After that, call setDio0Action(setFlag) again.

[nkebx2]

Thank you for your reply.

I tried what you mentioned and it worked, though I'm not sure if I wrote it correctly. Should I just leave the void clearDio0Action(){} function blank?

If I wish to transmit first before receive interrupt, can I use the same structure?

// include the library
#include <RadioLib.h>

// RFM95 has the following connections:
// NSS pin:   10
// DIO0 pin:  2
// RESET pin: 9
// DIO1 pin:  3
RFM95 radio = new Module(10, 2, 7, 5);

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

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

  // initialize RFM95 with default settings
  Serial.print(F("[RFM95] Initializing ... "));
  int state = radio.begin();
  if (state == ERR_NONE) {
    Serial.println(F("success!"));
  } else {
    Serial.print(F("failed, code "));
    Serial.println(state);
    while (true);
  }

  // set carrier frequency to 433.5 MHz
  if (radio.setFrequency(923) == ERR_INVALID_FREQUENCY) {
    Serial.println(F("Selected frequency is invalid for this module!"));
    while (true);
  }

  // set bandwidth to 250 kHz
  if (radio.setBandwidth(125.0) == ERR_INVALID_BANDWIDTH) {
    Serial.println(F("Selected bandwidth is invalid for this module!"));
    while (true);
  }

  // set spreading factor to 10
  if (radio.setSpreadingFactor(7) == ERR_INVALID_SPREADING_FACTOR) {
    Serial.println(F("Selected spreading factor is invalid for this module!"));
    while (true);
  }

  // set coding rate to 6
  if (radio.setCodingRate(5) == ERR_INVALID_CODING_RATE) {
    Serial.println(F("Selected coding rate is invalid for this module!"));
    while (true);
  }

  // set LoRa sync word to 0x14
  // NOTE: value 0x34 is reserved for LoRaWAN networks and should not be used
  if (radio.setSyncWord(0x12) != ERR_NONE) {
    Serial.println(F("Unable to set sync word!"));
    while (true);
  }  
  // set the function that will be called
  // when new packet is received
  radio.setDio0Action(setFlag);

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

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

// disable interrupt when it's not needed
volatile bool enableInterrupt = true;

// 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) {
  // check if the interrupt is enabled
  if(!enableInterrupt) {
    return;
  }

  // we got a packet, set the flag
  receivedFlag = true;
}

void clearDio0Action(){}

void loop() {

    // check if the flag is set
    if(receivedFlag) {
      // disable the interrupt service routine while
      // processing the data
      enableInterrupt = false;
  
      // reset flag
      receivedFlag = false;
  
      // you can also read received data as byte array

        byte byteArr[8];
        int state = radio.readData(byteArr, 8);
  
      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(byteArr[1]);
  
        // 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"));

            //Transmit if successfully receive
            clearDio0Action();
            byte byteArr[] = {0xFF, 0x23};
            int state = radio.transmit(byteArr, 3);
            
            if (state == ERR_NONE) {
            // the packet was successfully transmitted
            Serial.println(F(" success!"));
        
            // print measured data rate
            Serial.print(F("[RFM95] Datarate:\t"));
            Serial.print(radio.getDataRate());
            Serial.println(F(" bps"));
        
            } else if (state == ERR_PACKET_TOO_LONG) {
              // the supplied packet was longer than 256 bytes
              Serial.println(F("too long!"));
          
            } else if (state == ERR_TX_TIMEOUT) {
              // timeout occurred while transmitting packet
              Serial.println(F("timeout!"));
          
            } else {
              // some other error occurred
              Serial.print(F("failed, code "));
              Serial.println(state);
            }
            radio.setDio0Action(setFlag);
          
      } 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);
  
      }

  
      // put module back to listen mode
      radio.startReceive();
  
      // we're ready to receive more packets,
      // enable interrupt service routine
      enableInterrupt = true;
    }
}

[jgromes]

No, it's a method so should call it like radio.clearDio0Action() - this will remove the action that was associated by calling radio.setDio0Action() previously.

You can use the same logic to transmit before the first reception, just keep in mind you have to clear DIO0 action before transmitting, and set it back afterwards.