Missing messeages

[frogg1ven]

Hello, I got problem with missing messeages. Example: 3 in row missed, one received, 3 missed...
With default code it is receiving every messeage.

Here is my transmitter code (components I'm using - sht31, hx711, max4466):

#include <RadioLib.h>

#include <avr/sleep.h>
#include <avr/power.h>
#include <LowPower.h>

#include "HX711.h"

#include "Adafruit_SHT31.h"
// hx711
#define calibration_factor 20780.0  //Odczytana wartość z programu kalibracyjnego
#define DOUT  5          
#define CLK  6  
HX711 scale(DOUT, CLK);
// sht21
Adafruit_SHT31 sht31 = Adafruit_SHT31();
// MAX4466
const int sampleWindow = 50; // Sample window width in mS (50 mS = 20Hz)
unsigned int sample;

// SX1262 has the following connections:
// NSS pin:   10
// DIO1 pin:  7
// NRST pin:  8
// BUSY pin:  9
SX1262 radio = new Module(10, 7, 8, 9);

int count = 0;

void setup() {
  Serial.begin(9600);
  pinMode(2,OUTPUT);
  pinMode(3,OUTPUT);
  pinMode(4,OUTPUT);

  digitalWrite(2, HIGH);
  digitalWrite(4, HIGH);
  
  // hx711 calibration
  scale.set_scale(calibration_factor);
  scale.tare();

  // sht31 connecting
  if (! sht31.begin(0x44))        // Set to 0x45 for alternate i2c addr
  { 
    Serial.println("Couldn't find SHT31");
    while(1)
      delay(1);
  }
  
  // lora ini
  Serial.print(F("[SX1262] Initializing ... "));
  int state = radio.begin();
  radio.setFrequency(869.5);
  radio.setBandwidth(125.0);
  radio.setSpreadingFactor(12);
  radio.setSyncWord(0xAB);
  radio.setOutputPower(19);  
  Serial.println(state);

  if (state == ERR_NONE) {
    Serial.println(F("success!"));
  } else {
    Serial.print(F("failed, code "));
    Serial.println(state);
    while (true);
  }
  
  digitalWrite(2, LOW);
  digitalWrite(3, LOW);
  digitalWrite(4, LOW);
}

void loop() {
  String data = "";
  digitalWrite(2, HIGH);
  delay(200);
  data = String(sht31.readTemperature()) + " " + String(sht31.readHumidity());

  // MAX4466 read
  unsigned long startMillis= millis();  // Start of sample window
  unsigned int peakToPeak = 0;   // peak-to-peak level
 
  unsigned int signalMax = 0;
  unsigned int signalMin = 1024;
  // collect data for 50 mS
  while (millis() - startMillis < sampleWindow)
  {
     sample = analogRead(A0);
     if (sample < 1024)  // toss out spurious readings
     {
        if (sample > signalMax)
        {
           signalMax = sample;  // save just the max levels
        }
        else if (sample < signalMin)
        {
           signalMin = sample;  // save just the min levels
        }
     }
  }
  peakToPeak = signalMax - signalMin;  // max - min = peak-peak amplitude
  data = data + " " + String((peakToPeak * 3.3) / 1024); delay(1);
  digitalWrite(2, LOW);
  // hx711 read
  digitalWrite(4, HIGH);
  delay(100);
  data = data + " " + String(scale.get_units());
  digitalWrite(4, LOW);
  // battery read
  data = data + " " + String(analogRead(A1) * 2 * (3.3 / 1023.0)) + " " + "1" + " " + String(count);
  count++;
  Serial.println(data);
  // power on lora & sending message
  digitalWrite(3, HIGH);
  delay(100);
  int state = radio.transmit(data);
  digitalWrite(3, LOW);
  if (state == ERR_NONE) {
    // the packet was successfully transmitted
    Serial.println(F("success!"));

    // print measured data rate
    Serial.print(F("[SX1262] 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 occured while transmitting packet
    Serial.println(F("timeout!"));

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

  // lora and arduino sleep
  radio.standby();
  radio.sleep(); 
  for (int i = 0; i < 1; i++)
    LowPower.powerDown(SLEEP_8S, ADC_OFF, BOD_OFF);
}

and this is reveiver (with few libraries to connect wifi and send data to server):

#include <RadioLib.h>

// wifi libs
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <ESP8266HTTPClient.h>

// strof() lib
#include <stdlib.h>

// SX1262 has the following connections:
SX1262 radio = new Module(15, 0, 4, 2);

/* Set these to your desired credentials. */
const char *ssid = "some_ssid";  
const char *password = "some_pass";
//Web/Server address to read/write from
const char *host = "some_ip";  

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

  // connecting wifi
  WiFi.mode(WIFI_OFF);        //Prevents reconnection issue (taking too long to connect)
  delay(1000);
  WiFi.mode(WIFI_STA);        //This line hides the viewing of ESP as wifi hotspot

  WiFi.begin(ssid, password);     //Connect to your WiFi router
  Serial.println("");

  Serial.print("Connecting");
  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  // lora connecting
  pinMode(5, OUTPUT);
  digitalWrite(5, HIGH);
  
  // initialize SX1262
  Serial.print(F("[SX1262] Initializing ... "));
  int state = radio.begin();
  radio.setFrequency(869.5);
  radio.setBandwidth(125.0);
  radio.setSpreadingFactor(12);
  radio.setSyncWord(0xAB);
  radio.setOutputPower(22);

  
  if (state == ERR_NONE) {
    Serial.println(F("success!"));
  } else {
    Serial.print(F("failed, code "));
    Serial.println(state);
    while (true);
  }
}

void loop() {
  HTTPClient http;    //Declare object of class HTTPClient

//  Serial.print(F("[SX1262] Waiting for incoming transmission ... "));

  String str, postData;
  int state = radio.receive(str);

  if (state == ERR_NONE) {
    int str_len = str.length() + 1; 
    char char_array[str_len];
    str.toCharArray(char_array, str_len);
    String f1 = strtok(char_array, " ");
    String f2 = strtok(NULL, " ");
    String f3 = strtok(NULL, " ");
    String f4 = strtok(NULL, " ");
    String f5 = strtok(NULL, " ");
    String f6 = strtok(NULL, " ");
    String f7 = strtok(NULL, " ");
    // packet was successfully received
    Serial.println(F("success!"));

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

    // print the RSSI (Received Signal Strength Indicator)
    // of the last received packet
    Serial.print(F("[SX1262] RSSI:\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("[SX1262] SNR:\t\t"));
    Serial.print(radio.getSNR());
    Serial.println(F(" dB"));

    //Post Data
    postData = "temperature=" + f1 + "&humidity=" + f2 + "&sound=" + f3 + "&weight=" + f4  + "&battery=" + f5  + "&hivenumer=" + f6;
    http.begin("http://some_ip.php");              //Specify request destination
    http.addHeader("Content-Type", "application/x-www-form-urlencoded");    //Specify content-type header
    int httpCode = http.POST(postData);   //Send the request
    String payload = http.getString();    //Get the response payload
  
    Serial.println(httpCode);   //Print HTTP return code
    Serial.println(payload);    //Print request response payload
    http.end();  //Close connection
  } 
  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);
  }
}

I need to receive every message so it could be updated on website, but my program is missig data. I was testing how long it takes to send message if status code is 200, and it's about 320ms, but messages are sending in 1 min intervals (or larger), to it's not possible to miss receiving.
Could you help me or do you have any suggestion what could i change?
Thanks in advance.

[jgromes]

it's not possible to miss receiving

It is very much possible to miss reception, for two reasons:

1. You're using blocking receive, which will have "gaps" between receive slots. Try the interrupt based reception.
2. You set sync word to 0xAB, and that's going to massively impact sensitivity. LoRa sync word is very poorly named IMO (and very poorly documented), because it doesn't really work like sync word in FSK packets - different LoRa sync words will give you different demodulator sensitivites. I've learned this the hard way on FOSSASAT-1. So unless you know what you're doing and have a way to measure the sensitivity impact of a different sync word, do not change it from the default 0x12 value.

[frogg1ven]

thanks for answer, i'll try to do it properly

[frogg1ven]

@jgromes
I have tried to implement my code to your SX126x_Receive_interrupt example with nodemcu, but my serial monitor shows "ISR not in IRAM!" and keeps reseting on radio.setDio1Action(setFlag); function. I have read that something like ICACHE_RAM_ATTR is needed in esp, but i don't really know where to put it. Could you help me?
This is my new code:

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

// wifi libs
#include <ESP8266WiFi.h>
#include <WiFiClient.h>
#include <ESP8266WebServer.h>
#include <ESP8266HTTPClient.h>

// strof() lib
#include <stdlib.h>

SX1262 radio = new Module(15, 0, 4, 2);

/* Set these to your desired credentials. */
const char *ssid = "somessid";  //ENTER YOUR WIFI SETTINGS
const char *password = "somepassword";
//Web/Server address to read/write from
const char *host = "someip";   //https://circuits4you.com website or IP address of server

void setup() {
  Serial.begin(9600);
  // lora connecting
  pinMode(5, OUTPUT);
  digitalWrite(5, HIGH);

  // initialize SX1262 with default settings
  Serial.print(F("[SX1262] Initializing ... "));
  int state = radio.begin();
  radio.setFrequency(869.5);
  radio.setBandwidth(125.0);
  radio.setSpreadingFactor(12);
  radio.setOutputPower(22);
  
  if (state == ERR_NONE) {
    Serial.println(F("success!"));
  } else {
    Serial.print(F("failed, code "));
    Serial.println(state);
    while (true);
  }
  // set the function that will be called
  // when new packet is received
  radio.setDio1Action(setFlag);
  // start listening for LoRa packets
  Serial.print(F("[SX1262] 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);
  }

  // connecting wifi
  WiFi.mode(WIFI_OFF);        //Prevents reconnection issue (taking too long to connect)
  delay(1000);
  WiFi.mode(WIFI_STA);        //This line hides the viewing of ESP as wifi hotspot

  WiFi.begin(ssid, password);     //Connect to your WiFi router
  Serial.println("");

  Serial.print("Connecting");
  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  // 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();
}

// 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 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 read received data as an Arduino String
    String str, postData;
    int state = radio.readData(str);

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

    if (state == ERR_NONE) {
      HTTPClient http;    //Declare object of class HTTPClient

      int str_len = str.length() + 1; 
      char char_array[str_len];
      str.toCharArray(char_array, str_len);
      String f1 = strtok(char_array, " ");
      String f2 = strtok(NULL, " ");
      String f3 = strtok(NULL, " ");
      String f4 = strtok(NULL, " ");
      String f5 = strtok(NULL, " ");
      String f6 = strtok(NULL, " ");
      String f7 = strtok(NULL, " ");

      // packet was successfully received
      Serial.println(F("[SX1262] Received packet!"));

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

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

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

      //Post Data
      postData = "temperature=" + f1 + "&humidity=" + f2 + "&sound=" + f3 + "&weight=" + f4  + "&battery=" + f5  + "&hivenumer=" + f6;
      delay(1);
      http.begin("http://someip.php");              //Specify request destination
      http.addHeader("Content-Type", "application/x-www-form-urlencoded");    //Specify content-type header
      delay(1);
      int httpCode = http.POST(postData);   //Send the request
      String payload = http.getString();    //Get the response payload
    
      Serial.println(httpCode);   //Print HTTP return code
      Serial.println(payload);    //Print request response payload
      delay(1);
      http.end();  //Close connection

    } 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);

    }

    // put module back to listen mode
    radio.startReceive();

    // we're ready to receive more packets,
    // enable interrupt service routine
    enableInterrupt = true;
  }
}

[jgromes]

You have to put the ICACHE_RAM_ATTR attribute prior to the ISR function definition on ESP8266. In your case:

ICACHE_RAM_ATTR void setFlag(void) {
  // check if the interrupt is enabled
  if(!enableInterrupt) {
    return;
  }

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

[frogg1ven]

Thank you so much, it works perfectly now!