jgromes
commented
1 month ago The timing information is interesting - it seems that these "packets" always arrive directly after receiving real data. My first guess is that the IRQ gets triggered multiple times for some reason, pulling garbage data from the internal FIFO. Why this does not get caught by the CRC and/or packet length check is also interestting in of itself.
Notice how the values are the same each time when corrupted.
They are similar, but not exactly the same. It is also interesting that the frequency error and RSSI is the same, but SNR is not. Though maybe that's just because we have relatively few data points.
20:12:00.239 -> [SX1262] Data: 012342CEB3C
20:12:00.239 -> [SX1262] RSSI: -49.00 dBm
20:12:00.239 -> [SX1262] SNR: 12.50 dB
20:12:00.239 -> [SX1262] Frequency error: -546.38 Hz
20:12:00.398 -> [SX1262] Received packet!
20:12:00.398 -> [SX1262] Data: 01234EDF13C
20:12:00.398 -> [SX1262] RSSI: -49.00 dBm
20:12:00.398 -> [SX1262] SNR: 13.00 dB
20:12:00.398 -> [SX1262] Frequency error: -546.38 Hz
jacobeva
amirna2
Describe the bug When the bandwidth is set to 125kHz on the SX1262, and the SF is 8 (and only 8), sometimes packet data is incorrect when received. But CRC has been passed of course.
Debug mode output
``` 20:08:31.710 -> [SX1262] Received packet! 20:08:31.710 -> [SX1262] Data: 20:08:31.710 -> [SX1262] RSSI: -53.00 dBm 20:08:31.710 -> [SX1262] SNR: 12.50 dB 20:08:31.710 -> [SX1262] Frequency error: -546.38 Hz 20:08:32.710 -> [SX1262] Received packet! 20:08:32.710 -> [SX1262] Data: Hello World! #12 20:08:32.710 -> [SX1262] RSSI: -33.00 dBm 20:08:32.710 -> [SX1262] SNR: 11.75 dB 20:08:32.710 -> [SX1262] Frequency error: 337.12 Hz 20:08:33.807 -> [SX1262] Received packet! 20:08:33.807 -> [SX1262] Data: Hello World! #13 20:08:33.807 -> [SX1262] RSSI: -31.00 dBm 20:08:33.807 -> [SX1262] SNR: 13.50 dB 20:08:33.807 -> [SX1262] Frequency error: 337.12 Hz ``` You will notice the data field is empty. I am using the receive example which tries to send a string, of course. When sending a byte array instead, the output is thus: ``` 20:11:59.045 -> [SX1262] Data: 123455678ABCDEF 20:11:59.045 -> [SX1262] RSSI: -31.00 dBm 20:11:59.045 -> [SX1262] SNR: 13.00 dB 20:11:59.045 -> [SX1262] Frequency error: 329.38 Hz 20:12:00.142 -> [SX1262] Received packet! 20:12:00.142 -> [SX1262] Data: 123455678ABCDEF 20:12:00.142 -> [SX1262] RSSI: -31.00 dBm 20:12:00.142 -> [SX1262] SNR: 11.50 dB 20:12:00.142 -> [SX1262] Frequency error: 329.38 Hz 20:12:00.239 -> [SX1262] Received packet! 20:12:00.239 -> [SX1262] Data: 012342CEB3C 20:12:00.239 -> [SX1262] RSSI: -49.00 dBm 20:12:00.239 -> [SX1262] SNR: 12.50 dB 20:12:00.239 -> [SX1262] Frequency error: -546.38 Hz 20:12:00.398 -> [SX1262] Received packet! 20:12:00.398 -> [SX1262] Data: 01234EDF13C 20:12:00.398 -> [SX1262] RSSI: -49.00 dBm 20:12:00.398 -> [SX1262] SNR: 13.00 dB 20:12:00.398 -> [SX1262] Frequency error: -546.38 Hz 20:12:01.203 -> [SX1262] Received packet! 20:12:01.203 -> [SX1262] Data: 123455678ABCDEF 20:12:01.203 -> [SX1262] RSSI: -32.00 dBm 20:12:01.203 -> [SX1262] SNR: 12.50 dB 20:12:01.203 -> [SX1262] Frequency error: 329.38 Hz 20:12:02.298 -> [SX1262] Received packet! 20:12:02.298 -> [SX1262] Data: 123455678ABCDEF 20:12:02.298 -> [SX1262] RSSI: -32.00 dBm 20:12:02.298 -> [SX1262] SNR: 12.50 dB 20:12:02.298 -> [SX1262] Frequency error: 329.38 Hz 20:12:02.362 -> [SX1262] Received packet! 20:12:02.362 -> [SX1262] Data: 012342CEB3C 20:12:02.362 -> [SX1262] RSSI: -48.00 dBm 20:12:02.362 -> [SX1262] SNR: 12.50 dB 20:12:02.362 -> [SX1262] Frequency error: -530.88 Hz 20:12:03.392 -> [SX1262] Received packet! 20:12:03.392 -> [SX1262] Data: 123455678ABCDEF 20:12:03.392 -> [SX1262] RSSI: -31.00 dBm 20:12:03.392 -> [SX1262] SNR: 13.00 dB 20:12:03.392 -> [SX1262] Frequency error: 329.38 Hz ``` Notice how the values are the same each time when corrupted.
To Reproduce
Sketch that is causing the module fail
Receive: ```c++ // include the library #include
// SX1262 has the following connections:
// NSS pin: 10
// DIO1 pin: 2
// NRST pin: 3
// BUSY pin: 9
SX1262 radio = new Module(10, 2, 3, 9);
// or using RadioShield
// https://github.com/jgromes/RadioShield
//SX1262 radio = RadioShield.ModuleA;
// or using CubeCell
//SX1262 radio = new Module(RADIOLIB_BUILTIN_MODULE);
void setup() {
Serial.begin(9600);
// initialize SX1262 with default settings
Serial.print(F("[SX1262] Initializing ... "));
int state = radio.begin(868.0, 125.0, 8);
if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
Serial.println(state);
while (true) { delay(10); }
}
// set the function that will be called
// when new packet is received
radio.setPacketReceivedAction(setFlag);
// start listening for LoRa packets
Serial.print(F("[SX1262] Starting to listen ... "));
state = radio.startReceive();
if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
Serial.println(state);
while (true) { delay(10); }
}
// if needed, 'listen' mode can be disabled by calling
// any of the following methods:
//
// radio.standby()
// radio.sleep()
// radio.transmit();
// radio.receive();
// radio.scanChannel();
}
// flag to indicate that a packet was received
volatile bool receivedFlag = false;
// 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!
#if defined(ESP8266) || defined(ESP32)
ICACHE_RAM_ATTR
#endif
void setFlag(void) {
// we got a packet, set the flag
receivedFlag = true;
}
void loop() {
// check if the flag is set
if(receivedFlag) {
// reset flag
receivedFlag = false;
// you can read received data as an Arduino String
String str;
int state = radio.readData(str);
// you can also read received data as byte array
/*
byte byteArr[8];
int numBytes = radio.getPacketLength();
int state = radio.readData(byteArr, numBytes);
*/
if (state == RADIOLIB_ERR_NONE) {
// 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"));
// print frequency error
Serial.print(F("[SX1262] Frequency error:\t"));
Serial.print(radio.getFrequencyError());
Serial.println(F(" Hz"));
} else if (state == RADIOLIB_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);
}
}
}
```
Send:
```c++
// include the library
#include
// SX1262 has the following connections:
// NSS pin: 10
// DIO1 pin: 2
// NRST pin: 3
// BUSY pin: 9
SX1262 radio = new Module(10, 2, 3, 9);
// or using RadioShield
// https://github.com/jgromes/RadioShield
//SX1262 radio = RadioShield.ModuleA;
// or using CubeCell
//SX1262 radio = new Module(RADIOLIB_BUILTIN_MODULE);
void setup() {
Serial.begin(9600);
// initialize SX1262 with default settings
Serial.print(F("[SX1262] Initializing ... "));
int state = radio.begin(868.0, 125.0, 8);
if (state == RADIOLIB_ERR_NONE) {
Serial.println(F("success!"));
} else {
Serial.print(F("failed, code "));
Serial.println(state);
while (true) { delay(10); }
}
// 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);
*/
}
// counter to keep track of transmitted packets
int count = 0;
void loop() {
Serial.print(F("[SX1262] Transmitting packet ... "));
// you can transmit C-string or Arduino string up to
// 256 characters long
String str = "Hello World! #" + String(count++);
int state = radio.transmit(str);
// you can also transmit byte array up to 256 bytes long
/*
byte byteArr[] = {0x01, 0x23, 0x45, 0x56, 0x78, 0xAB, 0xCD, 0xEF};
int state = radio.transmit(byteArr, 8);
*/
if (state == RADIOLIB_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 == RADIOLIB_ERR_PACKET_TOO_LONG) {
// the supplied packet was longer than 256 bytes
Serial.println(F("too long!"));
} else if (state == RADIOLIB_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);
}
// wait for a second before transmitting again
delay(1000);
}
```
Expected behavior Obviously these packets shouldn't be corrupted the way they are.
Additional info (please complete):