Getting empty Results , even thought a packet is received

[gc9n]

hi there , i am trying to search on a certain range of frequensies , with an interupt on IRQ
on every freq i stop for a couple of seconds , even though it triggers an incoming packet , i get no data for it , if the parameters are not the same as the sender i imaging that i would not get any triggering at all .
is there some protection layer that dont return me any data if theres somthing wrong , i want even the garbages from the "incoming"package

`Loading candidate frequency: 915.010 MHz
Error reading packet, code: -7   (WRONG CRC)
Loading candidate frequency: 915.020 MHz
Loading candidate frequency: 915.030 MHz
Packet received!
Data (as string): 
Hex Data: 
RSSI: -85.00 dBm
SNR: -0.25 dB
Loading candidate frequency: 915.040 MHz
Loading candidate frequency: 915.050 MHz
Loading candidate frequency: 915.060 MHz
Packet received!
Data (as string): 
Hex Data: 
RSSI: -85.00 dBm
SNR: -0.25 dB
Loading candidate frequency: 915.070 MHz
RSSI: -90.00 dBm
SNR: -0.25 dB
Packet received!
Data (as string): 
Hex Data: 
RSSI: -90.00 dBm
SNR: -0.25 dB
Loading candidate frequency: 915.260 MHz
Loading candidate frequency: 915.270 MHz
Loading candidate frequency: 915.280 MHz
Packet received!
Data (as string): 
Hex Data: 
RSSI: -98.00 dBm
SNR: -1.75 dB
Loading candidate frequency: 915.290 MHz
Loading candidate frequency: 915.300 MHz
Packet received!
Data (as string): 
Hex Data: 
RSSI: -99.00 dBm
SNR: -1.50 dB
Loading candidate frequency: 915.310 MHz
Loading candidate frequency: 915.320 MHz
Loading candidate frequency: 915.330 MHz
Loading candidate frequency: 915.340 MHz
Loading candidate frequency: 915.350 MHz`

`#include <RadioLib.h>
#include <SPI.h>

#define NSS_PIN 5
#define IRQ_PIN 34
#define NRST_PIN 2
#define BUSY_PIN 35
#define LR1121_SCK 18
#define LR1121_MOSI 23
#define LR1121_MISO 19

enum lr11xx_system_irq_e {
  LR11XX_SYSTEM_IRQ_NONE = (0 << 0),
  LR11XX_SYSTEM_IRQ_TX_DONE = (1 << 2),
  LR11XX_SYSTEM_IRQ_RX_DONE = (1 << 3),
  LR11XX_SYSTEM_IRQ_PREAMBLE_DETECTED = (1 << 4),
  LR11XX_SYSTEM_IRQ_SYNC_WORD_HEADER_VALID = (1 << 5),
  LR11XX_SYSTEM_IRQ_HEADER_ERROR = (1 << 6),
  LR11XX_SYSTEM_IRQ_CRC_ERROR = (1 << 7),
  LR11XX_SYSTEM_IRQ_CAD_DONE = (1 << 8),
  LR11XX_SYSTEM_IRQ_CAD_DETECTED = (1 << 9),
  LR11XX_SYSTEM_IRQ_TIMEOUT = (1 << 10),
  LR11XX_SYSTEM_IRQ_LR_FHSS_INTRA_PKT_HOP = (1 << 11),
  LR11XX_SYSTEM_IRQ_RTTOF_REQ_VALID = (1 << 14),
  LR11XX_SYSTEM_IRQ_RTTOF_REQ_DISCARDED = (1 << 15),
  LR11XX_SYSTEM_IRQ_RTTOF_RESP_DONE = (1 << 16),
  LR11XX_SYSTEM_IRQ_RTTOF_EXCH_VALID = (1 << 17),
  LR11XX_SYSTEM_IRQ_RTTOF_TIMEOUT = (1 << 18),
  LR11XX_SYSTEM_IRQ_GNSS_SCAN_DONE = (1 << 19),
  LR11XX_SYSTEM_IRQ_WIFI_SCAN_DONE = (1 << 20),
  LR11XX_SYSTEM_IRQ_EOL = (1 << 21),
  LR11XX_SYSTEM_IRQ_CMD_ERROR = (1 << 22),
  LR11XX_SYSTEM_IRQ_ERROR = (1 << 23),
  LR11XX_SYSTEM_IRQ_FSK_LEN_ERROR = (1 << 24),
  LR11XX_SYSTEM_IRQ_FSK_ADDR_ERROR = (1 << 25),
  LR11XX_SYSTEM_IRQ_LORA_RX_TIMESTAMP = (1 << 27),
  LR11XX_SYSTEM_IRQ_ALL_MASK =
    LR11XX_SYSTEM_IRQ_TX_DONE | LR11XX_SYSTEM_IRQ_RX_DONE | LR11XX_SYSTEM_IRQ_PREAMBLE_DETECTED | LR11XX_SYSTEM_IRQ_SYNC_WORD_HEADER_VALID |
    LR11XX_SYSTEM_IRQ_HEADER_ERROR | LR11XX_SYSTEM_IRQ_CRC_ERROR | LR11XX_SYSTEM_IRQ_CAD_DONE | LR11XX_SYSTEM_IRQ_CAD_DETECTED |
    LR11XX_SYSTEM_IRQ_TIMEOUT | LR11XX_SYSTEM_IRQ_LR_FHSS_INTRA_PKT_HOP | LR11XX_SYSTEM_IRQ_RTTOF_REQ_VALID |
    LR11XX_SYSTEM_IRQ_RTTOF_REQ_DISCARDED | LR11XX_SYSTEM_IRQ_RTTOF_RESP_DONE | LR11XX_SYSTEM_IRQ_RTTOF_EXCH_VALID |
    LR11XX_SYSTEM_IRQ_RTTOF_TIMEOUT | LR11XX_SYSTEM_IRQ_GNSS_SCAN_DONE | LR11XX_SYSTEM_IRQ_WIFI_SCAN_DONE | LR11XX_SYSTEM_IRQ_EOL |
    LR11XX_SYSTEM_IRQ_CMD_ERROR | LR11XX_SYSTEM_IRQ_ERROR | LR11XX_SYSTEM_IRQ_FSK_LEN_ERROR | LR11XX_SYSTEM_IRQ_FSK_ADDR_ERROR |
    LR11XX_SYSTEM_IRQ_LORA_RX_TIMESTAMP,
};

SPIClass newSPI(HSPI);
LR1121 radio = new Module(NSS_PIN, IRQ_PIN, NRST_PIN, BUSY_PIN, newSPI);

#define WHITENING_INITIAL 0x00FF

static const uint32_t rfswitch_dio_pins[] = {
  RADIOLIB_LR11X0_DIO5, RADIOLIB_LR11X0_DIO6,
  RADIOLIB_NC, RADIOLIB_NC, RADIOLIB_NC
};

static const Module::RfSwitchMode_t rfswitch_table[] = {
  { LR11x0::MODE_STBY, { LOW, LOW } },
  { LR11x0::MODE_RX, { LOW, LOW } },
  { LR11x0::MODE_TX, { LOW, HIGH } },
  { LR11x0::MODE_TX_HP, { LOW, HIGH } },
  { LR11x0::MODE_TX_HF, { LOW, LOW } },
  { LR11x0::MODE_GNSS, { LOW, LOW } },
  { LR11x0::MODE_WIFI, { LOW, LOW } },
  END_OF_MODE_TABLE,
};

#define TCXO 0

const float BASE_FREQ = 915.0;
const float MAX_FREQ = 960.0;
const float FREQ_STEP = 0.010;
float currentFreq = BASE_FREQ;

const float BW = 500.0;
const int SF = 7;
const int CR = 5;
const int SYNC = 0x12;
const int PWR = 14;
const int PREAMBLE = 8;

unsigned long candidateStartTime = 0;
const unsigned long dwellTime = 3000;

volatile bool receivedFlag = false;
void setFlag(void) {
  receivedFlag = true;
}

void printHex(const String &data) {
  Serial.print("Hex Data: ");
  for (uint16_t i = 0; i < data.length(); i++) {
    uint8_t b = data[i];
    if (b < 16) Serial.print("0");
    Serial.print(b, HEX);
    Serial.print(" ");
  }
  Serial.println();
}

void loadCandidate(float freq) {
  Serial.print("Loading candidate frequency: ");
  Serial.print(freq, 3);
  Serial.println(" MHz");
  int state = radio.begin(freq, BW, SF, CR, SYNC, PWR, PREAMBLE, TCXO);
  if (state != RADIOLIB_ERR_NONE) {
    Serial.print("Radio init failed, code: ");
    Serial.println(state);
  } else {
    radio.setWhitening(true);
    state = radio.startReceive();
    if (state != RADIOLIB_ERR_NONE) {
      Serial.print("Failed to start receive, code: ");
      Serial.println(state);
    }
  }
  candidateStartTime = millis();
}

uint32_t customIRQMask = LR11XX_SYSTEM_IRQ_SYNC_WORD_HEADER_VALID | LR11XX_SYSTEM_IRQ_PREAMBLE_DETECTED | LR11XX_SYSTEM_IRQ_RX_DONE;

void setup() {
  Serial.begin(115200);
  newSPI.begin(LR1121_SCK, LR1121_MISO, LR1121_MOSI, NSS_PIN);
  radio.setRfSwitchTable(rfswitch_dio_pins, rfswitch_table);
  radio.setPacketReceivedAction(setFlag);
  radio.setDioIrqParams(customIRQMask);
  Serial.println("Starting configuration with frequency rotation...");
  loadCandidate(currentFreq);
}

void loop() {
  if (receivedFlag) {
    receivedFlag = false;
    String packet;
    int state = radio.readData(packet);
    if (state == RADIOLIB_ERR_NONE) {
      Serial.println("Packet received!");
      Serial.print("Data (as string): ");
      Serial.println(packet);
      printHex(packet);
      Serial.print("RSSI: ");
      Serial.print(radio.getRSSI());
      Serial.println(" dBm");
      Serial.print("SNR: ");
      Serial.print(radio.getSNR());
      Serial.println(" dB");
    } else {
      Serial.print("Error reading packet, code: ");
      Serial.println(state);
    }
  }
  if (millis() - candidateStartTime >= dwellTime) {
    currentFreq += FREQ_STEP;
    if (currentFreq >= MAX_FREQ) {
      currentFreq = BASE_FREQ;
    }
    loadCandidate(currentFreq);
  }
  delay(10);
}

`

[gc9n]

I will try modify the IRQ mask so that you only trigger on the RX_DONE event