Merge branch 'master' into feature/i2s_sr

Author: P-R-O-C-H-Y

cores/esp32/HardwareSerial.cpp

@@ -183,7 +183,7 @@ _eventTask(NULL)
 
 HardwareSerial::~HardwareSerial()
 {
-    end();
+    end(true); // explicit Full UART termination
 #if !CONFIG_DISABLE_HAL_LOCKS
     if(_lock != NULL){
         vSemaphoreDelete(_lock);
@@ -398,7 +398,7 @@ void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, in
     if(_uart) {
         // in this case it is a begin() over a previous begin() - maybe to change baud rate
         // thus do not disable debug output
-        end(false);
+        end(false);  // disables IDF UART driver and UART event Task + sets _uart to NULL
     }
 
     // IDF UART driver keeps Pin setting on restarting. Negative Pin number will keep it unmodified.
@@ -413,7 +413,7 @@ void HardwareSerial::begin(unsigned long baud, uint32_t config, int8_t rxPin, in
             yield();
         }
 
-        end(false);
+        end(false);  // disables IDF UART driver and UART event Task + sets _uart to NULL
 
         if(detectedBaudRate) {
             delay(100); // Give some time...
@@ -470,10 +470,8 @@ void HardwareSerial::end(bool fullyTerminate)
       // do not invalidate callbacks, detach pins, invalidate DBG output
       uart_driver_delete(_uart_nr);
     }
-
-    uartEnd(_uart_nr);
-    _uart = 0;
-    _destroyEventTask();
+    _destroyEventTask(); // when IDF uart driver is deleted, _eventTask must finish too
+    _uart = NULL;
 }
 
 void HardwareSerial::setDebugOutput(bool en)

cores/esp32/esp32-hal-i2c.c

@@ -30,6 +30,13 @@
 #include "driver/i2c.h"
 #include "esp32-hal-periman.h"
 
+#if SOC_I2C_SUPPORT_APB || SOC_I2C_SUPPORT_XTAL
+#include "esp_private/esp_clk.h"
+#endif
+#if SOC_I2C_SUPPORT_RTC
+#include "clk_ctrl_os.h"
+#endif
+
 typedef volatile struct {
     bool initialized;
     uint32_t frequency;
@@ -303,11 +310,6 @@ esp_err_t i2cSetClock(uint8_t i2c_num, uint32_t frequency){
     } else if(frequency > 1000000UL){
         frequency = 1000000UL;
     }
-    // Freq limitation when using different clock sources
-    #define I2C_CLK_LIMIT_REF_TICK            (1 * 1000 * 1000 / 20)    /*!< Limited by REF_TICK, no more than REF_TICK/20*/
-    #define I2C_CLK_LIMIT_APB                 (80 * 1000 * 1000 / 20)   /*!< Limited by APB, no more than APB/20*/
-    #define I2C_CLK_LIMIT_RTC                 (20 * 1000 * 1000 / 20)   /*!< Limited by RTC, no more than RTC/20*/
-    #define I2C_CLK_LIMIT_XTAL                (40 * 1000 * 1000 / 20)   /*!< Limited by RTC, no more than XTAL/20*/
 
     typedef struct {
         soc_module_clk_t clk;       /*!< I2C source clock */
@@ -332,22 +334,22 @@ esp_err_t i2cSetClock(uint8_t i2c_num, uint32_t frequency){
     } i2c_sclk_t;
 
     // i2c clock characteristic, The order is the same as i2c_sclk_t.
-    static i2c_clk_alloc_t i2c_clk_alloc[I2C_SCLK_MAX] = {
+    i2c_clk_alloc_t i2c_clk_alloc[I2C_SCLK_MAX] = {
         {0, 0},
     #if SOC_I2C_SUPPORT_APB
-        {SOC_MOD_CLK_APB, I2C_CLK_LIMIT_APB},          /*!< I2C APB clock characteristic*/
+        {SOC_MOD_CLK_APB, esp_clk_apb_freq()},          /*!< I2C APB clock characteristic*/
     #endif
     #if SOC_I2C_SUPPORT_XTAL
-        {SOC_MOD_CLK_XTAL, I2C_CLK_LIMIT_XTAL},        /*!< I2C XTAL characteristic*/
+        {SOC_MOD_CLK_XTAL, esp_clk_xtal_freq()},        /*!< I2C XTAL characteristic*/
     #endif
     #if SOC_I2C_SUPPORT_RTC
-        {SOC_MOD_CLK_RC_FAST, I2C_CLK_LIMIT_RTC},      /*!< I2C 20M RTC characteristic*/
+        {SOC_MOD_CLK_RC_FAST, periph_rtc_dig_clk8m_get_freq()},      /*!< I2C 20M RTC characteristic*/
     #endif
     #if SOC_I2C_SUPPORT_REF_TICK
-        {SOC_MOD_CLK_REF_TICK, I2C_CLK_LIMIT_REF_TICK},/*!< I2C REF_TICK characteristic*/
+        {SOC_MOD_CLK_REF_TICK, REF_CLK_FREQ},/*!< I2C REF_TICK characteristic*/
     #endif
     };
-
+    
     i2c_sclk_t src_clk = I2C_SCLK_DEFAULT;
     ret = ESP_OK;
     for (i2c_sclk_t clk = I2C_SCLK_DEFAULT + 1; clk < I2C_SCLK_MAX; clk++) {
@@ -367,6 +369,11 @@ esp_err_t i2cSetClock(uint8_t i2c_num, uint32_t frequency){
     } else {
         i2c_hal_context_t hal;
         hal.dev = I2C_LL_GET_HW(i2c_num);
+#if SOC_I2C_SUPPORT_RTC
+        if(src_clk == I2C_SCLK_RTC){
+            periph_rtc_dig_clk8m_enable();
+        }
+#endif
         i2c_hal_set_bus_timing(&(hal), frequency, i2c_clk_alloc[src_clk].clk, i2c_clk_alloc[src_clk].clk_freq);
         bus[i2c_num].frequency = frequency;
         //Clock Stretching Timeout: 20b:esp32, 5b:esp32-c3, 24b:esp32-s2

cores/esp32/esp32-hal-uart.c

@@ -884,32 +884,29 @@ void uartStartDetectBaudrate(uart_t *uart) {
         return;
     }
 
-#if CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
+// Baud rate detection only works for ESP32 and ESP32S2
+#if CONFIG_IDF_TARGET_ESP32 || CONFIG_IDF_TARGET_ESP32S2
+    uart_dev_t *hw = UART_LL_GET_HW(uart->num);
+    hw->auto_baud.glitch_filt = 0x08;
+    hw->auto_baud.en = 0;
+    hw->auto_baud.en = 1;
+#else
 
     // ESP32-C3 requires further testing
     // Baud rate detection returns wrong values 
 
-    log_e("ESP32-C3 baud rate detection is not supported.");
+    log_e("baud rate detection for this SoC is not supported.");
     return;
 
     // Code bellow for C3 kept for future recall
     //hw->rx_filt.glitch_filt = 0x08;
     //hw->rx_filt.glitch_filt_en = 1;
     //hw->conf0.autobaud_en = 0;
     //hw->conf0.autobaud_en = 1;
-#elif CONFIG_IDF_TARGET_ESP32S3
-    log_e("ESP32-S3 baud rate detection is not supported.");
-    return;
-#else
-    uart_dev_t *hw = UART_LL_GET_HW(uart->num);
-    hw->auto_baud.glitch_filt = 0x08;
-    hw->auto_baud.en = 0;
-    hw->auto_baud.en = 1;
 #endif
 }
 
-unsigned long
-uartDetectBaudrate(uart_t *uart)
+unsigned long uartDetectBaudrate(uart_t *uart)
 {
     if(uart == NULL) {
         return 0;
@@ -955,11 +952,7 @@ uartDetectBaudrate(uart_t *uart)
 
     return default_rates[i];
 #else
-#if CONFIG_IDF_TARGET_ESP32C3 || CONFIG_IDF_TARGET_ESP32C6 || CONFIG_IDF_TARGET_ESP32H2
-    log_e("ESP32-C3 baud rate detection is not supported.");
-#else
-    log_e("ESP32-S3 baud rate detection is not supported.");
-#endif
+    log_e("baud rate detection this SoC is not supported.");
     return 0;
 #endif
 }

libraries/BLE/examples/Beacon_Scanner/Beacon_Scanner.ino

@@ -111,9 +111,9 @@ void setup()
 void loop()
 {
   // put your main code here, to run repeatedly:
-  BLEScanResults foundDevices = pBLEScan->start(scanTime, false);
+  BLEScanResults *foundDevices = pBLEScan->start(scanTime, false);
   Serial.print("Devices found: ");
-  Serial.println(foundDevices.getCount());
+  Serial.println(foundDevices->getCount());
   Serial.println("Scan done!");
   pBLEScan->clearResults(); // delete results fromBLEScan buffer to release memory
   delay(2000);

libraries/BLE/examples/Scan/Scan.ino

@@ -31,9 +31,9 @@ void setup() {
 
 void loop() {
   // put your main code here, to run repeatedly:
-  BLEScanResults foundDevices = pBLEScan->start(scanTime, false);
+  BLEScanResults *foundDevices = pBLEScan->start(scanTime, false);
   Serial.print("Devices found: ");
-  Serial.println(foundDevices.getCount());
+  Serial.println(foundDevices->getCount());
   Serial.println("Scan done!");
   pBLEScan->clearResults();   // delete results fromBLEScan buffer to release memory
   delay(2000);

libraries/BLE/src/BLEScan.cpp

@@ -426,11 +426,11 @@ bool BLEScan::start(uint32_t duration, void (*scanCompleteCB)(BLEScanResults), b
  * @param [in] duration The duration in seconds for which to scan.
  * @return The BLEScanResults.
  */
-BLEScanResults BLEScan::start(uint32_t duration, bool is_continue) {
+BLEScanResults* BLEScan::start(uint32_t duration, bool is_continue) {
 	if(start(duration, nullptr, is_continue)) {
 		m_semaphoreScanEnd.wait("start");   // Wait for the semaphore to release.
 	}
-	return m_scanResults;
+	return &m_scanResults;
 } // start
 
 
@@ -500,8 +500,8 @@ BLEAdvertisedDevice BLEScanResults::getDevice(uint32_t i) {
 	return dev;
 }
 
-BLEScanResults BLEScan::getResults() {
-	return m_scanResults;
+BLEScanResults* BLEScan::getResults() {
+	return &m_scanResults;
 }
 
 void BLEScan::clearResults() {

libraries/BLE/src/BLEScan.h

@@ -71,10 +71,10 @@ class BLEScan {
 	void           setInterval(uint16_t intervalMSecs);
 	void           setWindow(uint16_t windowMSecs);
 	bool           start(uint32_t duration, void (*scanCompleteCB)(BLEScanResults), bool is_continue = false);
-	BLEScanResults start(uint32_t duration, bool is_continue = false);
+	BLEScanResults* start(uint32_t duration, bool is_continue = false);
 	void           stop();
 	void 		   erase(BLEAddress address);
-	BLEScanResults getResults();
+	BLEScanResults* getResults();
 	void			clearResults();
 
 #ifdef SOC_BLE_50_SUPPORTED

libraries/ESP32/examples/Serial/BaudRateDetect_Demo/BaudRateDetect_Demo.ino

@@ -0,0 +1,37 @@
+/*
+   This Sketch demonstrates how to detect and set the baud rate when the UART0 is connected to
+   some port that is sending data. It can be used with the Arduino IDE Serial Monitor to send the data.
+
+   Serial.begin(0) will start the baud rate detection. Valid range is 300 to 230400 baud.
+   It will try to detect for 20 seconds, by default, while reading RX.
+   This timeout of 20 seconds can be changed in the begin() function through <<timeout_ms>> parameter:
+   
+   void HardwareSerial::begin(baud, config, rxPin, txPin, invert, <<timeout_ms>>, rxfifo_full_thrhd)
+
+   It is necessary that the other end sends some data within <<timeout_ms>>, otherwise the detection won't work.
+
+   IMPORTANT NOTE: baud rate detection seem to only work with ESP32 and ESP32-S2. 
+   In other other SoCs, it doesn't work.
+
+*/
+
+// Open the Serial Monitor with testing baud start typing and sending caracters
+void setup() {
+  Serial.begin(0); // it will try to detect the baud rate for 20 seconds
+  
+  Serial.print("\n==>The baud rate is ");
+  Serial.println(Serial.baudRate()); 
+  
+  //after 20 seconds timeout, when not detected, it will return zero - in this case, we set it back to 115200.
+  if (Serial.baudRate() == 0) {
+    // Trying to set Serial to a safe state at 115200
+    Serial.end();
+    Serial.begin(115200);
+    Serial.setDebugOutput(true);
+    delay(1000);
+    log_e("Baud rate detection failed.");
+  }
+ }
+
+void loop() {
+}

libraries/LittleFS/src/LittleFS.cpp

@@ -82,7 +82,8 @@ bool LittleFSFS::begin(bool formatOnFail, const char * basePath, uint8_t maxOpen
       .base_path = basePath,
       .partition_label = partitionLabel_,
       .format_if_mount_failed = false,
-      .dont_mount = false
+      .dont_mount = false,
+      .grow_on_mount = true
     };
 
     esp_err_t err = esp_vfs_littlefs_register(&conf);