ESP-IDF HAL for ESP32-S3

[timoehl]

I am trying to create a hardware abstraction for RadioLib to work with the ESP32-S3, and ideally all other models of ESP32 with the ESP-IDF. In order to make it as compatible I am using the ESP-IDF SPI master driver. It seems to work on the normal ESP32, but not on the ESP32-S3, there I get error code -2. I would appreciate suggestions. Here is my current code:

#pragma once

// include RadioLib
#include <RadioLib.h>
#include <rom/ets_sys.h>
#include "driver/spi_common.h"
#include "driver/spi_master.h"

#include "driver/gpio.h"
#include "hal/gpio_hal.h"
#include "esp_timer.h"
#include "esp_log.h"
#include "soc/gpio_sig_map.h"
#include "soc/rtc.h"

#include "esp_system.h"
#include "esp_intr_alloc.h"

#if CONFIG_IDF_TARGET_ESP32  

#elif CONFIG_IDF_TARGET_ESP32S2
#include "esp32s2/rom/ets_sys.h"
#include "esp32s2/rom/gpio.h"
#elif CONFIG_IDF_TARGET_ESP32S3
#include "esp32s3/rom/ets_sys.h"
#include "esp32s3/rom/gpio.h"
#elif CONFIG_IDF_TARGET_ESP32C2
#include "esp32c2/rom/ets_sys.h"
#include "esp32c2/rom/gpio.h"
#elif CONFIG_IDF_TARGET_ESP32C3
#include "esp32c3/rom/ets_sys.h"
#include "esp32c3/rom/gpio.h"
#elif CONFIG_IDF_TARGET_ESP32C6
#include "esp32c6/rom/ets_sys.h"
#include "esp32c6/rom/gpio.h"
#elif CONFIG_IDF_TARGET_ESP32H2
#include "esp32h2/rom/ets_sys.h"
#include "esp32h2/rom/gpio.h"
#else
#error Target CONFIG_IDF_TARGET is not supported
#endif

// 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")

#define MATRIX_DETACH_OUT_SIG       (0x100)
#define MATRIX_DETACH_IN_LOW_PIN    (0x30)


// create a new ESP-IDF hardware abstraction layer
// the HAL must inherit from the base RadioLibHal class
// and implement all of its virtual methods
// this is pretty much just copied from Arduino ESP32 core
class EspHal2 : public RadioLibHal {
  public:
    // default constructor - initializes the base HAL and any needed private members
    EspHal2(int8_t sck, int8_t miso, int8_t mosi)
      : RadioLibHal(INPUT, OUTPUT, LOW, HIGH, RISING, FALLING),
      spiSCK(sck), spiMISO(miso), spiMOSI(mosi)  {
        gpio_install_isr_service((int)ESP_INTR_FLAG_IRAM);
    }

    void init() override {
      // we only need to init the SPI here
      spiBegin();
      return;
    }

    void term() override {
      // we only need to stop the SPI here
      spiEnd();
      return;
    }

    // GPIO-related methods (pinMode, digitalWrite etc.) should check
    // RADIOLIB_NC as an alias for non-connected pins
    void pinMode(uint32_t pin, uint32_t mode) override {
      if(pin == RADIOLIB_NC) {
        return;
      }

      gpio_hal_context_t gpiohal;
      gpiohal.dev = GPIO_LL_GET_HW(GPIO_PORT_0);

      gpio_config_t conf = {
        .pin_bit_mask = (1ULL<<pin),
        .mode = (gpio_mode_t)mode,
        .pull_up_en = GPIO_PULLUP_DISABLE,
        .pull_down_en = GPIO_PULLDOWN_DISABLE,
        .intr_type = (gpio_int_type_t)gpiohal.dev->pin[pin].int_type,
      };
      gpio_config(&conf);
      return;
    }

    void digitalWrite(uint32_t pin, uint32_t value) override {
      if(pin == RADIOLIB_NC) {
        return;
      }

      gpio_set_level((gpio_num_t)pin, value);
    }

    uint32_t digitalRead(uint32_t pin) override {
      if(pin == RADIOLIB_NC) {
        return(0);
      }

      return(gpio_get_level((gpio_num_t)pin));
    }

    void attachInterrupt(uint32_t interruptNum, void (*interruptCb)(void), uint32_t mode) override {
      if(interruptNum == RADIOLIB_NC) {
        return;
      }
      gpio_set_intr_type((gpio_num_t)interruptNum, (gpio_int_type_t)(mode & 0x7));

      // this uses function typecasting, which is not defined when the functions have different signatures
      // untested and might not work
      gpio_isr_handler_add((gpio_num_t)interruptNum, (void (*)(void*))interruptCb, NULL);
      return;
    }

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

      gpio_isr_handler_remove((gpio_num_t)interruptNum);
	    gpio_wakeup_disable((gpio_num_t)interruptNum);
      gpio_set_intr_type((gpio_num_t)interruptNum, GPIO_INTR_DISABLE);
      return;
    }

    void delay(unsigned long ms) override {
      vTaskDelay(ms / portTICK_PERIOD_MS);
      return;
    }

    void delayMicroseconds(unsigned long us) override {
      ets_delay_us(us);
      return;
    }

    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, unsigned long timeout) override {
      if(pin == RADIOLIB_NC) {
        return(0);
      }

      this->pinMode(pin, INPUT);
      uint32_t start = this->micros();
      uint32_t curtick = this->micros();

      while(this->digitalRead(pin) == state) {
        if((this->micros() - curtick) > timeout) {
          return(0);
        }
      }

      return(this->micros() - start);
    }

    void spiBegin() {
        spi_bus_config_t buscfg = {};
        buscfg.miso_io_num = spiMISO;
        buscfg.mosi_io_num = spiMOSI;
        buscfg.sclk_io_num = spiSCK;
        buscfg.quadwp_io_num = -1;
        buscfg.quadhd_io_num = -1;
        buscfg.data4_io_num = -1;
        buscfg.data5_io_num = -1;
        buscfg.data6_io_num = -1;
        buscfg.data7_io_num = -1;
        esp_err_t ret = spi_bus_initialize(SPI3_HOST, &buscfg,  SPI_DMA_CH_AUTO);
        if (ret != ESP_OK) {
            ESP_LOGE("SPI", "Failed to initialize SPI bus: %s", esp_err_to_name(ret));
        }
        spi_device_interface_config_t devcfg = {};
        devcfg.clock_speed_hz = 1 * 1000 * 1000; // 1MHz
        devcfg.mode = 0;
        devcfg.spics_io_num = -1;
        devcfg.queue_size = 1;
        ret = spi_bus_add_device(SPI3_HOST, &devcfg, &spi);
        if (ret != ESP_OK) {
            ESP_LOGE("SPI", "Failed to add SPI device: %s", esp_err_to_name(ret));
        }
        return;
    }

    void spiBeginTransaction() {
      // not needed - in ESP32 Arduino core, this function
      // repeats clock div, mode and bit order configuration
      return;
    }

    uint8_t spiTransferByte(uint8_t data) {
      spi_transaction_t t;
      memset(&t, 0, sizeof(t));  // Zero out the transaction
      t.length = 8;              // Command is 8 bits
      t.tx_buffer = &data;       // The data is the cmd itself
      t.rx_buffer = &data;       // Receive buffer is the same
      spi_device_polling_transmit(spi, &t);
      return data;               // Return the received byte
    }

    void spiTransfer(uint8_t* out, size_t len, uint8_t* in) {
      spi_transaction_t t;
      memset(&t, 0, sizeof(t));  // Zero out the transaction
      t.length = len * 8;        // Length is in bits
      t.tx_buffer = out;         // The data to send
      t.rx_buffer = in;          // The data to receive
      spi_device_polling_transmit(spi, &t);
      return;
    }

    void spiEndTransaction() {
      // nothing needs to be done here
      return;
    }

    void spiEnd() {
      // detach pins
      //spi_bus_free(SPI3_HOST);
      return;
    }

  private:
    // the HAL can contain any additional private members
    int8_t spiSCK;
    int8_t spiMISO;
    int8_t spiMOSI;
    spi_device_handle_t spi;
};

[jgromes]

Without knowing the full context, I get the feeling you might be trying to reinvent the wheel - if your target is "ideally all other models of ESP32", why not just use the Arduino ESP32 core?

[timoehl]

I am trying to develop a IDF component, so using ESP-IDF is not really optional, and the main goal is compatibility to ESP32 and ESP32-S3. I hoped that using the high level driver should make compatibility easy

[jgromes]

I'm not an ESP32 expert by any stretch, but from what I've seen so far there are a lot of subtle differences between the various ESP32 versions. That's in part why the Arduino ESP32 core is so massive, because it covers a lot of corner cases and has been used extensively, so it is quite well tested.

[timoehl]

Maybe you can point me in a direction where the issue could be, I released that I didn't include the error output, maybe you know which part of the HAL could cause such an issue. I get the following output when calling begin. The used chip is an SX1262, the GPIO12 which is repeated in the log multiple times is the Reset Pin.

I (1266) Lora: begin:
I (1266) gpio: GPIO[8]| InputEn: 1| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 
I (1276) gpio: GPIO[13]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 
I (1286) gpio: GPIO[7]| InputEn: 1| OutputEn: 0| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 
I (1296) gpio: GPIO[12]| InputEn: 1| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 
I (1316) gpio: GPIO[12]| InputEn: 1| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 
I (2336) gpio: GPIO[12]| InputEn: 1| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 
I (3346) gpio: GPIO[12]| InputEn: 1| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 
I (4356) gpio: GPIO[12]| InputEn: 1| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 
I (5366) gpio: GPIO[12]| InputEn: 1| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 
I (6376) gpio: GPIO[12]| InputEn: 1| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 
I (7386) gpio: GPIO[12]| InputEn: 1| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 
I (8396) gpio: GPIO[12]| InputEn: 1| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 
I (9406) gpio: GPIO[12]| InputEn: 1| OutputEn: 1| OpenDrain: 0| Pullup: 0| Pulldown: 0| Intr:0 
E (10416) Lora: failed begin, code -2

[jgromes]

You can start by reading what the various error codes mean, and then enabling RadioLib debug output to get more information.

[timoehl]

I have made some progress, it seems I initially also had a Hardware Issue, which I now fixed. Now it seems to work, I can send and receive data, however, when reading data from a radio, it seems to be around 500 times slower on the ESP32-S3 than on the ESP32. I still am unsure if this is is a measurement error and, if not, what the cause could be.

[jgromes]

I'm not sure what kind of measurement you've done, but it looks like incorrectly configured clocks. If the SPI clock is very slow, it will anturelly take a long time to read anything out of the radio.

[imfatant]

@timoehl

I'm interested in doing precisely what you're doing - more or less as a programming exercise. I've wanted to get to grips with the SPI code for a while (since I first started playing around with the ESP32). Anyway, perhaps I'll have more to say soon.

[timoehl]

I'm curious to see what you will have to say. I did measure the SPI frequency, and it was 2MHz, so I think that that was not my issue. Maybe you will have some good ideas.

[Crsarmv7l]

Could be the clock divider

[Zep0]

Hi everyone,
Are there any updates on this topic? Before I start heading down the same path, I wanted to check if anyone has already created a working HAL for the ESP32-S3 that I could test.
That would be great!

[Crsarmv7l]

I don't know... But if you do and/or have familiarity with DMA for ESP-IDF or Arduino that would be a good thing to include.

I have written/modified and troubleshot FIFO refllls for the CC1101 over a long period of time to send signals up to 255 bytes and will be upstreaming it to radiolib in the next month or two I expect Nov/Dec. I still have a couple more PCB's coming, and a variety of capacitor tests to do... and I am moving. But it will happen.

See here for more details: #1138

Currently I am using the core to do it, DMA would be the correct way to go though.

[Zep0]

I'm sorry, unfortunately I don't know enough about DMA for ESP-IDF or Arduino to be able to help :/