[ESP32-P4] SPI / SX1262 LoRa module failing to initialize (RadioLib -2)

[Raiyanv]

Good morning,

I am trying to get an ESP32-P4 to communicate with a SX1262 LoRa module over SPI. The radio refuses to wake up, the BUSY line stays permanently high, and I am receiving a -2 (RADIOLIB_ERR_CHIP_NOT_FOUND) error from RadioLib.

I have done extensive hardware and software debugging (including DMA memory alignment, checking power domains, and verifying signals) but the module remains unresponsive. I have looked over the datasheets and technical reference manuals for potential GPIO conflicts, but that did not help.

I would greatly appreciate any possible guidance and help on this issue.

Hardware Setup
MCU: Waveshare ESP32-P4-Module-DEV-KIT
LoRa Module: Waveshare SX1262 LoRa Module (Sub-GHz)
Framework: ESP-IDF v5.5.2-729
Library: RadioLib (with a custom EspHal.h)

Pin Config
constexpr gpio_num_t LORA_CS = GPIO_NUM_1;
constexpr gpio_num_t LORA_SCK = GPIO_NUM_22;
constexpr gpio_num_t LORA_MOSI = GPIO_NUM_21;
constexpr gpio_num_t LORA_MISO = GPIO_NUM_33;
constexpr gpio_num_t LORA_RST = GPIO_NUM_20;
constexpr gpio_num_t LORA_BUSY = GPIO_NUM_32;
constexpr gpio_num_t LORA_DIO1 = GPIO_NUM_53;
constexpr gpio_num_t LORA_RXEN = GPIO_NUM_48;
constexpr gpio_num_t LORA_TXEN = GPIO_NUM_54;

Error Messages

I (1595) EspHal: spiBegin SCK=22 MISO=33 MOSI=21 @ 1000000Hz
I (1605) EspHal: spiBegin OK
[10.742857] RLB_SPI: CMDW	00
[10.742969] RLB_SPI: SI		
[10.743062] RLB_SPI: SO	FF	
[10.952857] RLB_SPI: CMDW	00
[10.952968] RLB_SPI: SI		
[10.953061] RLB_SPI: SO	FF	
[11.362881] RLB_SPI: CMDW	00
[11.362992] RLB_SPI: SI		
[11.363085] RLB_SPI: SO	FF	
[11.572857] RLB_SPI: CMDW	00
[11.572969] RLB_SPI: SI		
[11.573062] RLB_SPI: SO	FF	
[11.782857] RLB_SPI: CMDW	00
[11.782969] RLB_SPI: SI		
[11.783065] RLB_SPI: SO	FF	
[11.992857] RLB_SPI: CMDW	00
[11.992969] RLB_SPI: SI		
[11.993062] RLB_SPI: SO	FF	
[12.202857] RLB_SPI: CMDW	00
[12.202969] RLB_SPI: SI		
[12.203062] RLB_SPI: SO	FF	
I (14184) EspHal: spiEnd OK
E (14184) TransmitDriver: begin failed: -2
E (14184) Transmit: TransmitDriver init failed: ESP_FAIL

Code:

 /** From my TransmitDriver.h
EspHal   m_hal;
Module   m_module;
SX1262   m_radio;
TransmitDriver(): 
          m_hal(),
          m_module(&m_hal,
                   (uint32_t)Config::Pins::LORA_CS,
                   (uint32_t)Config::Pins::LORA_DIO1,
                   (uint32_t)Config::Pins::LORA_RST,
                   (uint32_t)Config::Pins::LORA_BUSY),
          m_radio(&m_module)   // ← SX1262 takes Module*
    {}
*/
// TransmitDriver.cpp
esp_err_t TransmitDriver::init() {
    std::lock_guard<std::mutex> lock(m_mtx);
    if (m_is_init) return ESP_OK;

    // 1. SPI first — must be up before any GPIO RadioLib touches
    m_hal.setSpiPins(Config::Pins::LORA_SCK,
                     Config::Pins::LORA_MISO,
                     Config::Pins::LORA_MOSI);
    m_hal.setSpiFrequency(1000000);
    m_hal.spiBegin();
    m_module.spiConfig.timeout = 200;

    int state = m_radio.begin(
        915.0f, 125.0f, 7, 5,
        RADIOLIB_SX126X_SYNC_WORD_PRIVATE,
        14, 8,
        1.6f
    );

    if (state != RADIOLIB_ERR_NONE) {
        ESP_LOGE(TAG, "begin failed: %d", state);
        return ESP_FAIL;
    }

    m_radio.setRfSwitchPins(Config::Pins::LORA_RXEN, Config::Pins::LORA_TXEN);

    m_is_init = true;
    ESP_LOGI(TAG, "SX1262 ready @ 915MHz SF7 BW125");
    return ESP_OK;
}

EspHal.h

#pragma once


#include <RadioLib.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "driver/spi_master.h"
#include "hal/gpio_hal.h"
#include "esp_timer.h"
#include "esp_log.h"
#include "esp_heap_caps.h"


// define Arduino-style macros
#define LOW                         (0x0)
#define HIGH                        (0x1)
#define INPUT                       (0x01)
#define OUTPUT                      (0x03)
#define RISING                      (0x01)
#define FALLING                     (0x02)
#define NOP()                       asm volatile ("nop")

static const char* TAG_HAL = "EspHal";
class EspHal : public RadioLibHal {
  public:
    // default constructor - initializes the base HAL and any needed private members
    EspHal()
      : RadioLibHal(INPUT, OUTPUT, LOW, HIGH, RISING, FALLING) {}

    void setSpiPins(int8_t sck, int8_t miso, int8_t mosi) {
        _spiPins = {sck, miso, mosi};
    }

    void setSpiFrequency(uint32_t freq) { _spiFrequency = freq; }

    void pinMode(uint32_t pin, uint32_t mode) override {
      if(pin == RADIOLIB_NC) {
        return;
      }
      gpio_config_t conf = {};
      conf.pin_bit_mask   = (1ULL<<pin);
      conf.mode           = static_cast<gpio_mode_t>(mode);
      conf.pull_up_en     = GPIO_PULLUP_DISABLE;
      conf.pull_down_en   = GPIO_PULLDOWN_DISABLE;
      conf.intr_type      = GPIO_INTR_DISABLE;
      conf.hys_ctrl_mode  = GPIO_HYS_SOFT_DISABLE;
      gpio_config(&conf);

      if (mode == GPIO_MODE_OUTPUT){
        gpio_set_drive_capability(static_cast<gpio_num_t>(pin), GPIO_DRIVE_CAP_3);
      }
    }

  void digitalWrite(uint32_t pin, uint32_t value) override {
      if (pin == RADIOLIB_NC) return;
      // ESP_LOGI(TAG_HAL, "digitalWrite: pin=%lu val=%lu",
      //         pin, value);
      gpio_set_drive_capability(static_cast<gpio_num_t>(pin), GPIO_DRIVE_CAP_3);
      gpio_set_level(static_cast<gpio_num_t>(pin), value);
  }

    uint32_t digitalRead(uint32_t pin) override {
      if(pin == RADIOLIB_NC) { return 0; }
      return gpio_get_level(static_cast<gpio_num_t>(pin));
    }

    void attachInterrupt(uint32_t pin, void (*cb)(void), uint32_t mode) override {
      if(pin == RADIOLIB_NC) { return; }
      // ESP_LOGI(TAG_HAL, "attachInterrupt: pin=%lu mode=%lu", pin, mode);  
      gpio_install_isr_service(ESP_INTR_FLAG_IRAM);
      gpio_set_intr_type((gpio_num_t)pin, (gpio_int_type_t)(mode & 0x7));
      gpio_isr_handler_add((gpio_num_t)pin, (void (*)(void*))cb , NULL);
    }

    void detachInterrupt(uint32_t pin) override {
      if(pin == RADIOLIB_NC) { return;  }

      // ESP_LOGI(TAG_HAL, "detachInterrupt: pin=%lu", pin);
      gpio_isr_handler_remove((gpio_num_t)pin);
      gpio_set_intr_type((gpio_num_t)pin, GPIO_INTR_DISABLE);
    }

    void delay(unsigned long ms) override {
      vTaskDelay(pdMS_TO_TICKS(ms));
    }

    void delayMicroseconds(unsigned long us) override {
      uint64_t end = esp_timer_get_time() + us;
      while(esp_timer_get_time() < end) { NOP(); }
    }

    unsigned long millis() override {
      return((unsigned long)(esp_timer_get_time() / 1000ULL));
    }

    unsigned long micros() override {
      return((unsigned long)(esp_timer_get_time()));
    }

    long pulseIn(uint32_t pin, uint32_t state, RadioLibTime_t timeout) override {
        if (pin == RADIOLIB_NC) return 0;
        const RadioLibTime_t start = micros();
        while (digitalRead(pin) != state)
            if (micros() - start > timeout) return 0;
        const RadioLibTime_t pulseStart = micros();
        while (digitalRead(pin) == state)
            if (micros() - start > timeout) return 0;
        return micros() - pulseStart;
    }

    void spiBegin() override {
        if (_spiInitialized) return;

        ESP_LOGI(TAG_HAL, "spiBegin SCK=%d MISO=%d MOSI=%d @ %luHz",
                 _spiPins.sck, _spiPins.miso, _spiPins.mosi, _spiFrequency);

        spi_bus_config_t buscfg = {};
        buscfg.mosi_io_num     = _spiPins.mosi;
        buscfg.miso_io_num     = _spiPins.miso;
        buscfg.sclk_io_num     = _spiPins.sck;
        buscfg.quadwp_io_num   = -1;
        buscfg.quadhd_io_num   = -1;
        buscfg.max_transfer_sz = 4096;

        spi_device_interface_config_t devcfg = {};
        devcfg.mode           = 0;
        devcfg.clock_speed_hz = (int)_spiFrequency;
        devcfg.spics_io_num   = -1;
        devcfg.queue_size     = 7;

        ESP_ERROR_CHECK(spi_bus_initialize(SPI3_HOST, &buscfg, SPI_DMA_CH_AUTO));
        ESP_ERROR_CHECK(spi_bus_add_device(SPI3_HOST, &devcfg, &_spiHandle));
        _spiInitialized = true;
        ESP_LOGI(TAG_HAL, "spiBegin OK");
    }

    void spiBeginTransaction() override {
      spi_device_acquire_bus(_spiHandle, portMAX_DELAY);
    }
    void spiEndTransaction() override {
      spi_device_release_bus(_spiHandle);
    }

void spiTransfer(uint8_t* out, size_t len, uint8_t* in) override {
    if (len == 0) return;

    spi_transaction_t t = {};
    t.length = len * 8;

    if (len <= 4) {
      if (out != nullptr){
        t.flags |= SPI_TRANS_USE_TXDATA;
        memcpy(t.tx_data, out, len);
      }
      if (in != nullptr){
        t.flags |= SPI_TRANS_USE_RXDATA;
      }

      esp_err_t err = spi_device_transmit(_spiHandle, &t);
      if (err != ESP_OK){
        ESP_LOGE(TAG_HAL, "spiTransfer failed: %s", esp_err_to_name((err)));
      }
      if (in != nullptr){
        memcpy(in, t.rx_data, len);
      }
      return;
    }
    // DMA-capable
    uint8_t* dma_tx = (uint8_t*)heap_caps_calloc(len, 1, MALLOC_CAP_DMA); // Calloc ensures it defaults to 0x00 NOPs
    uint8_t* dma_rx = nullptr;
    
    if (out != nullptr) {
        memcpy(dma_tx, out, len);
    }
    t.tx_buffer = dma_tx;

    if (in != nullptr) {
        dma_rx = (uint8_t*)heap_caps_calloc(len, 1, MALLOC_CAP_DMA);
        t.rx_buffer = dma_rx;
    }

    // Execute the transaction
    esp_err_t err = spi_device_transmit(_spiHandle, &t);
    if (err != ESP_OK) {
        ESP_LOGE(TAG_HAL, "spiTransfer DMA failed: %s", esp_err_to_name(err));
    }

    // Copy the received DMA data back to RadioLib's original pointer
    if (in != nullptr && dma_rx != nullptr) {
        memcpy(in, dma_rx, len);
    }

    // Free the temporary DMA memory
    if (dma_tx) heap_caps_free(dma_tx);
    if (dma_rx) heap_caps_free(dma_rx);
}

    void spiEnd() override {
        if (!_spiInitialized) return;
        spi_bus_remove_device(_spiHandle);
        spi_bus_free(SPI3_HOST);
        _spiInitialized = false;
        ESP_LOGI(TAG_HAL, "spiEnd OK");
    }

    void init() override { spiBegin(); }
    void term() override { spiEnd(); }

  private:
    struct { int8_t sck, miso, mosi; } _spiPins = {-1, -1, -1};
    bool _spiInitialized = false;
    uint32_t _spiFrequency = 8000000;
    spi_device_handle_t _spiHandle = nullptr;
};

[jgromes]

The debug mode shows that the SPI is continuously reading out 0xFF bytes - that is a typical behavior of incorrectly set pins or a bad connection. If you have an oscilloscope or a logic analyzer, you can check data is being at least sent out from the ESP32 correctly, that will rule out an issue with the SPI configuration. Since 0xFF is all bits set to logic 1, I would look into issues with the chip select pin first.

[Raiyanv]

This worked, thank you so much