Merge branch 'espressif:esp-idf-v5.1-libs' into esp-idf-v5.1-libs

Author: Jason2866

.github/workflows/hil.yml

@@ -66,19 +66,12 @@ jobs:
   Test:
     needs: [gen_chunks, Build]
     name: ${{matrix.chip}}-Test#${{matrix.chunks}}
-    runs-on:
-      - ESP32
-      - ESP32-S2
-      - ESP32-S3
-      - ESP32-C3
-      - ESP32-C6
-      - ESP32-H2
-
     strategy:
       fail-fast: false
       matrix:
         chip: ['esp32', 'esp32s2', 'esp32s3', 'esp32c3', 'esp32c6', 'esp32h2']
         chunks: ${{fromJson(needs.gen_chunks.outputs.chunks)}}
+    runs-on: [arduino, "${{matrix.chip}}"]
     container:
       image: python:3.10.1-bullseye
       options: --privileged

cores/esp32/HWCDC.cpp

@@ -32,11 +32,11 @@
 ESP_EVENT_DEFINE_BASE(ARDUINO_HW_CDC_EVENTS);
 
 static RingbufHandle_t tx_ring_buf = NULL;
-static xQueueHandle rx_queue = NULL;
+static QueueHandle_t rx_queue = NULL;
 static uint8_t rx_data_buf[64] = {0};
 static intr_handle_t intr_handle = NULL;
 static volatile bool initial_empty = false;
-static xSemaphoreHandle tx_lock = NULL;
+static SemaphoreHandle_t tx_lock = NULL;
 
 // workaround for when USB CDC is not connected
 static uint32_t tx_timeout_ms = 0;

cores/esp32/HardwareSerial.cpp

@@ -79,7 +79,7 @@ void serialEvent(void) {}
 #define TX1 19
 #elif CONFIG_IDF_TARGET_ESP32S3
 #define TX1 16
-#elif CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
+#elif CONFIG_IDF_TARGET_ESP32C6
 #define TX1 4
 #elif CONFIG_IDF_TARGET_ESP32H2
 #define TX1 1
@@ -95,7 +95,7 @@ void serialEvent1(void) {}
 #if CONFIG_IDF_TARGET_ESP32
 #define RX2 16
 #elif CONFIG_IDF_TARGET_ESP32S3
-#define RX2 19 
+#define RX2 19
 #endif
 #endif
 
@@ -144,16 +144,16 @@ void serialEventRun(void)
 #define HSERIAL_MUTEX_LOCK()    do {} while (xSemaphoreTake(_lock, portMAX_DELAY) != pdPASS)
 #define HSERIAL_MUTEX_UNLOCK()  xSemaphoreGive(_lock)
 #else
-#define HSERIAL_MUTEX_LOCK()    
-#define HSERIAL_MUTEX_UNLOCK()  
+#define HSERIAL_MUTEX_LOCK()
+#define HSERIAL_MUTEX_UNLOCK()
 #endif
 
-HardwareSerial::HardwareSerial(int uart_nr) : 
-_uart_nr(uart_nr), 
+HardwareSerial::HardwareSerial(int uart_nr) :
+_uart_nr(uart_nr),
 _uart(NULL),
 _rxBufferSize(256),
-_txBufferSize(0), 
-_onReceiveCB(NULL), 
+_txBufferSize(0),
+_onReceiveCB(NULL),
 _onReceiveErrorCB(NULL),
 _onReceiveTimeout(false),
 _rxTimeout(2),
@@ -202,10 +202,10 @@ void HardwareSerial::_destroyEventTask(void)
     }
 }
 
-void HardwareSerial::onReceiveError(OnReceiveErrorCb function) 
+void HardwareSerial::onReceiveError(OnReceiveErrorCb function)
 {
     HSERIAL_MUTEX_LOCK();
-    // function may be NULL to cancel onReceive() from its respective task 
+    // function may be NULL to cancel onReceive() from its respective task
     _onReceiveErrorCB = function;
     // this can be called after Serial.begin(), therefore it shall create the event task
     if (function != NULL && _uart != NULL && _eventTask == NULL) {
@@ -217,7 +217,7 @@ void HardwareSerial::onReceiveError(OnReceiveErrorCb function)
 void HardwareSerial::onReceive(OnReceiveCb function, bool onlyOnTimeout)
 {
     HSERIAL_MUTEX_LOCK();
-    // function may be NULL to cancel onReceive() from its respective task 
+    // function may be NULL to cancel onReceive() from its respective task
     _onReceiveCB = function;
 
     // setting the callback to NULL will just disable it
@@ -265,14 +265,14 @@ bool HardwareSerial::setRxFIFOFull(uint8_t fifoBytes)
 bool HardwareSerial::setRxTimeout(uint8_t symbols_timeout)
 {
     HSERIAL_MUTEX_LOCK();
-    
+
     // Zero disables timeout, thus, onReceive callback will only be called when RX FIFO reaches 120 bytes
-    // Any non-zero value will activate onReceive callback based on UART baudrate with about 11 bits per symbol 
-    _rxTimeout = symbols_timeout;   
-    if (!symbols_timeout) _onReceiveTimeout = false;  // only when RX timeout is disabled, we also must disable this flag 
+    // Any non-zero value will activate onReceive callback based on UART baudrate with about 11 bits per symbol
+    _rxTimeout = symbols_timeout;
+    if (!symbols_timeout) _onReceiveTimeout = false;  // only when RX timeout is disabled, we also must disable this flag
 
     bool retCode = uartSetRxTimeout(_uart, _rxTimeout); // Set new timeout
-    
+
     HSERIAL_MUTEX_UNLOCK();
     return retCode;
 }
@@ -281,7 +281,7 @@ void HardwareSerial::eventQueueReset()
 {
     QueueHandle_t uartEventQueue = NULL;
     if (_uart == NULL) {
-	    return;
+      return;
     }
     uartGetEventQueue(_uart, &uartEventQueue);
     if (uartEventQueue != NULL) {
@@ -298,12 +298,12 @@ void HardwareSerial::_uartEventTask(void *args)
     if (uartEventQueue != NULL) {
         for(;;) {
             //Waiting for UART event.
-            if(xQueueReceive(uartEventQueue, (void * )&event, (portTickType)portMAX_DELAY)) {
+            if(xQueueReceive(uartEventQueue, (void * )&event, (TickType_t)portMAX_DELAY)) {
                 hardwareSerial_error_t currentErr = UART_NO_ERROR;
                 switch(event.type) {
                     case UART_DATA:
-                        if(uart->_onReceiveCB && uart->available() > 0 && 
-                            ((uart->_onReceiveTimeout && event.timeout_flag) || !uart->_onReceiveTimeout) ) 
+                        if(uart->_onReceiveCB && uart->available() > 0 &&
+                            ((uart->_onReceiveTimeout && event.timeout_flag) || !uart->_onReceiveTimeout) )
                                 uart->_onReceiveCB();
                         break;
                     case UART_FIFO_OVF:
@@ -410,18 +410,18 @@ void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, in
         }
     }
     // create a task to deal with Serial Events when, for example, calling begin() twice to change the baudrate,
-    // or when setting the callback before calling begin() 
+    // or when setting the callback before calling begin()
     if (_uart != NULL && (_onReceiveCB != NULL || _onReceiveErrorCB != NULL) && _eventTask == NULL) {
         _createEventTask(this);
     }
 
     // Set UART RX timeout
     uartSetRxTimeout(_uart, _rxTimeout);
 
-    // Set UART FIFO Full depending on the baud rate. 
+    // Set UART FIFO Full depending on the baud rate.
     // Lower baud rates will force to emulate byte-by-byte reading
     // Higher baud rates will keep IDF default of 120 bytes for FIFO FULL Interrupt
-    // It can also be changed by the application at any time 
+    // It can also be changed by the application at any time
     if (!_rxFIFOFull) {    // it has not being changed before calling begin()
       //  set a default FIFO Full value for the IDF driver
       uint8_t fifoFull = 1;
@@ -437,23 +437,23 @@ void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, in
 
 void HardwareSerial::updateBaudRate(unsigned long baud)
 {
-	uartSetBaudRate(_uart, baud);
+  uartSetBaudRate(_uart, baud);
 }
 
 void HardwareSerial::end(bool fullyTerminate)
 {
-    // default Serial.end() will completely disable HardwareSerial, 
+    // default Serial.end() will completely disable HardwareSerial,
     // including any tasks or debug message channel (log_x()) - but not for IDF log messages!
     if(fullyTerminate) {
         _onReceiveCB = NULL;
         _onReceiveErrorCB = NULL;
         if (uartGetDebug() == _uart_nr) {
             uartSetDebug(0);
         }
-        _rxFIFOFull = 0; 
+        _rxFIFOFull = 0;
         uartEnd(_uart);  // fully detach all pins and delete the UART driver
     } else {
-      // do not invalidate callbacks, detach pins, invalidate DBG output 
+      // do not invalidate callbacks, detach pins, invalidate DBG output
       uart_driver_delete(_uart_nr);
     }
     _uart = 0;
@@ -540,7 +540,7 @@ size_t HardwareSerial::write(const uint8_t *buffer, size_t size)
 uint32_t  HardwareSerial::baudRate()
 
 {
-	return uartGetBaudRate(_uart);
+  return uartGetBaudRate(_uart);
 }
 HardwareSerial::operator bool() const
 {

cores/esp32/USBCDC.cpp

@@ -123,7 +123,7 @@ size_t USBCDC::setRxBufferSize(size_t rx_queue_len){
             uxQueueSpacesAvailable(rx_queue) + uxQueueMessagesWaiting(rx_queue) : 0;
 
     if (rx_queue_len != currentQueueSize) {
-        xQueueHandle new_rx_queue = NULL;
+        QueueHandle_t new_rx_queue = NULL;
         if (rx_queue_len) {
             new_rx_queue = xQueueCreate(rx_queue_len, sizeof(uint8_t));
             if(!new_rx_queue){

cores/esp32/USBCDC.h

@@ -135,8 +135,8 @@ class USBCDC: public Stream
     bool     rts;
     bool     connected;
     bool     reboot_enable;
-    xQueueHandle rx_queue;
-    xSemaphoreHandle tx_lock;
+    QueueHandle_t rx_queue;
+    SemaphoreHandle_t tx_lock;
     uint32_t tx_timeout_ms;
 
 };

cores/esp32/esp32-hal-cpu.c

@@ -60,7 +60,7 @@ typedef struct apb_change_cb_s {
 
 
 static apb_change_t * apb_change_callbacks = NULL;
-static xSemaphoreHandle apb_change_lock = NULL;
+static SemaphoreHandle_t apb_change_lock = NULL;
 
 static void initApbChangeCallback(){
     static volatile bool initialized = false;

cores/esp32/esp32-hal-i2c-slave.c

@@ -76,16 +76,16 @@ typedef struct i2c_slave_struct_t {
     void * arg;
     intr_handle_t intr_handle;
     TaskHandle_t task_handle;
-    xQueueHandle event_queue;
+    QueueHandle_t event_queue;
 #if I2C_SLAVE_USE_RX_QUEUE
-    xQueueHandle rx_queue;
+    QueueHandle_t rx_queue;
 #else
     RingbufHandle_t rx_ring_buf;
 #endif
-    xQueueHandle tx_queue;
+    QueueHandle_t tx_queue;
     uint32_t rx_data_count;
 #if !CONFIG_DISABLE_HAL_LOCKS
-    xSemaphoreHandle lock;
+    SemaphoreHandle_t lock;
 #endif
 } i2c_slave_struct_t;
 
@@ -431,7 +431,7 @@ size_t i2cSlaveWrite(uint8_t num, const uint8_t *buf, uint32_t len, uint32_t tim
                 to_queue = len;
             }
             for (size_t i = 0; i < to_queue; i++) {
-                if (xQueueSend(i2c->tx_queue, &buf[i], timeout_ms / portTICK_RATE_MS) != pdTRUE) {
+                if (xQueueSend(i2c->tx_queue, &buf[i], timeout_ms / portTICK_PERIOD_MS) != pdTRUE) {
                     xQueueReset(i2c->tx_queue);
                     to_queue = 0;
                     break;

cores/esp32/esp32-hal-i2c.c

@@ -184,7 +184,7 @@ esp_err_t i2cWrite(uint8_t i2c_num, uint16_t address, const uint8_t* buff, size_
     }
 
     //short implementation does not support zero size writes (example when scanning) PR in IDF?
-    //ret =  i2c_master_write_to_device((i2c_port_t)i2c_num, address, buff, size, timeOutMillis / portTICK_RATE_MS);
+    //ret =  i2c_master_write_to_device((i2c_port_t)i2c_num, address, buff, size, timeOutMillis / portTICK_PERIOD_MS);
 
     ret = ESP_OK;
     uint8_t cmd_buff[I2C_LINK_RECOMMENDED_SIZE(1)] = { 0 };
@@ -207,7 +207,7 @@ esp_err_t i2cWrite(uint8_t i2c_num, uint16_t address, const uint8_t* buff, size_
     if (ret != ESP_OK) {
         goto end;
     }
-    ret = i2c_master_cmd_begin((i2c_port_t)i2c_num, cmd, timeOutMillis / portTICK_RATE_MS);
+    ret = i2c_master_cmd_begin((i2c_port_t)i2c_num, cmd, timeOutMillis / portTICK_PERIOD_MS);
 
 end:
     if(cmd != NULL){
@@ -235,7 +235,7 @@ esp_err_t i2cRead(uint8_t i2c_num, uint16_t address, uint8_t* buff, size_t size,
     if(!bus[i2c_num].initialized){
         log_e("bus is not initialized");
     } else {
-        ret = i2c_master_read_from_device((i2c_port_t)i2c_num, address, buff, size, timeOutMillis / portTICK_RATE_MS);
+        ret = i2c_master_read_from_device((i2c_port_t)i2c_num, address, buff, size, timeOutMillis / portTICK_PERIOD_MS);
         if(ret == ESP_OK){
             *readCount = size;
         } else {
@@ -264,7 +264,7 @@ esp_err_t i2cWriteReadNonStop(uint8_t i2c_num, uint16_t address, const uint8_t*
     if(!bus[i2c_num].initialized){
         log_e("bus is not initialized");
     } else {
-        ret = i2c_master_write_read_device((i2c_port_t)i2c_num, address, wbuff, wsize, rbuff, rsize, timeOutMillis / portTICK_RATE_MS);
+        ret = i2c_master_write_read_device((i2c_port_t)i2c_num, address, wbuff, wsize, rbuff, rsize, timeOutMillis / portTICK_PERIOD_MS);
         if(ret == ESP_OK){
             *readCount = rsize;
         } else {

cores/esp32/esp32-hal-rmt.c

@@ -60,7 +60,7 @@ struct rmt_obj_s {
   size_t *num_symbols_read;                  // Pointer to the number of RMT symbol read by IDF RMT RX Done
 
 #if !CONFIG_DISABLE_HAL_LOCKS
-  xSemaphoreHandle g_rmt_objlocks;           // Channel Semaphore Lock
+  SemaphoreHandle_t g_rmt_objlocks;           // Channel Semaphore Lock
 #endif /* CONFIG_DISABLE_HAL_LOCKS */
 };
 
@@ -69,7 +69,7 @@ typedef struct rmt_obj_s *rmt_bus_handle_t;
 /**
    Internal variables used in RMT API
 */
-static xSemaphoreHandle g_rmt_block_lock = NULL;
+static SemaphoreHandle_t g_rmt_block_lock = NULL;
 
 /**
    Internal method (private) declarations

cores/esp32/esp32-hal-spi.c

@@ -59,7 +59,7 @@
 struct spi_struct_t {
     spi_dev_t * dev;
 #if !CONFIG_DISABLE_HAL_LOCKS
-    xSemaphoreHandle lock;
+    SemaphoreHandle_t lock;
 #endif
     uint8_t num;
     int8_t sck;

cores/esp32/esp32-hal-tinyusb.c

@@ -406,7 +406,7 @@ static void hw_cdc_reset_handler(void *arg) {
     usb_serial_jtag_ll_clr_intsts_mask(usbjtag_intr_status);
 
     if (usbjtag_intr_status & USB_SERIAL_JTAG_INTR_BUS_RESET) {
-        xSemaphoreGiveFromISR((xSemaphoreHandle)arg, &xTaskWoken);
+        xSemaphoreGiveFromISR((SemaphoreHandle_t)arg, &xTaskWoken);
     }
 
     if (xTaskWoken == pdTRUE) {
@@ -441,7 +441,7 @@ static void usb_switch_to_cdc_jtag(){
     usb_serial_jtag_ll_clr_intsts_mask(USB_SERIAL_JTAG_LL_INTR_MASK);
     usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_BUS_RESET);
     intr_handle_t intr_handle = NULL;
-    xSemaphoreHandle reset_sem = xSemaphoreCreateBinary();
+    SemaphoreHandle_t reset_sem = xSemaphoreCreateBinary();
     if(reset_sem){
         if(esp_intr_alloc(ETS_USB_SERIAL_JTAG_INTR_SOURCE, 0, hw_cdc_reset_handler, reset_sem, &intr_handle) != ESP_OK){
             vSemaphoreDelete(reset_sem);

cores/esp32/esp32-hal-uart.c

@@ -38,7 +38,7 @@ static int s_uart_debug_nr = 0;
 struct uart_struct_t {
 
 #if !CONFIG_DISABLE_HAL_LOCKS
-    xSemaphoreHandle lock;
+    SemaphoreHandle_t lock;
 #endif
 
     uint8_t num;
@@ -459,7 +459,7 @@ uint8_t uartRead(uart_t* uart)
       c = uart->peek_byte;
     } else {
 
-        int len = uart_read_bytes(uart->num, &c, 1, 20 / portTICK_RATE_MS);
+        int len = uart_read_bytes(uart->num, &c, 1, 20 / portTICK_PERIOD_MS);
         if (len <= 0) { // includes negative return from IDF in case of error
             c  = 0;
         }
@@ -481,7 +481,7 @@ uint8_t uartPeek(uart_t* uart)
     if (uart->has_peek) {
       c = uart->peek_byte;
     } else {
-        int len = uart_read_bytes(uart->num, &c, 1, 20 / portTICK_RATE_MS);
+        int len = uart_read_bytes(uart->num, &c, 1, 20 / portTICK_PERIOD_MS);
         if (len <= 0) { // includes negative return from IDF in case of error
             c  = 0;
         } else {

libraries/AsyncUDP/src/AsyncUDP.cpp

@@ -145,7 +145,7 @@ typedef struct {
         struct netif * netif;
 } lwip_event_packet_t;
 
-static xQueueHandle _udp_queue;
+static QueueHandle_t _udp_queue;
 static volatile TaskHandle_t _udp_task_handle = NULL;
 
 static void _udp_task(void *pvParameters){

libraries/AsyncUDP/src/AsyncUDP.h

@@ -104,7 +104,7 @@ class AsyncUDP : public Print
 {
 protected:
     udp_pcb *_pcb;
-    //xSemaphoreHandle _lock;
+    //SemaphoreHandle_t _lock;
     bool _connected;
 	esp_err_t _lastErr;
     AuPacketHandlerFunction _handler;

libraries/BluetoothSerial/src/BluetoothSerial.cpp

@@ -47,8 +47,8 @@ const char * _spp_server_name = "ESP32SPP";
 #define SPP_CONGESTED_TIMEOUT 1000
 
 static uint32_t _spp_client = 0;
-static xQueueHandle _spp_rx_queue = NULL;
-static xQueueHandle _spp_tx_queue = NULL;
+static QueueHandle_t _spp_rx_queue = NULL;
+static QueueHandle_t _spp_tx_queue = NULL;
 static SemaphoreHandle_t _spp_tx_done = NULL;
 static TaskHandle_t _spp_task_handle = NULL;
 static EventGroupHandle_t _spp_event_group = NULL;