Merge branch 'master' into feat/p4_ble

Author: me-no-dev

.github/workflows/pre-commit-status.yml

@@ -131,3 +131,24 @@ jobs:
           gh pr edit ${{ steps.pr-info.outputs.pr_number }} --repo ${{ github.repository }} --remove-label 'Status: Pre-commit fixes required ⚠️'
         env:
           GH_TOKEN: ${{ github.token }}
+
+      - name: Comment on PR about pre-commit failures
+        if: |
+          steps.pr-info.outputs.artifacts_found == 'true' &&
+          steps.pr-info.outputs.pre_commit_outcome == 'failure' &&
+          steps.pr-info.outputs.pending_commit == '0'
+        uses: thollander/actions-comment-pull-request@24bffb9b452ba05a4f3f77933840a6a841d1b32b # v3.0.1
+        with:
+          pr-number: ${{ steps.pr-info.outputs.pr_number }}
+          message: |
+            ## ⚠️ Pre-commit Hooks Failed
+
+            Some pre-commit hooks failed and require manual fixes. Please see the detailed error report below.
+
+            **What to do:**
+            1. 📋 [**View the detailed error report**](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.event.workflow_run.id }}) to see which hooks failed
+            2. 🔧 Fix the issues locally in your code
+            3. 💾 Commit and push your changes
+            4. 🔄 The hooks will run again automatically
+
+            **Need help?** Ask in the comments below.

cores/esp32/Arduino.h

@@ -222,12 +222,36 @@ size_t getArduinoLoopTaskStackSize(void);
     return sz;                           \
   }
 
+#define ESP32_USB_MIDI_DEFAULT_NAME "TinyUSB MIDI"
+/**
+* @brief Set the current device name
+* 1. Name set via constructor (if any)
+* 2. Name set via SET_USB_MIDI_DEVICE_NAME() macro (if defined)
+* 3. Default name "TinyUSB MIDI"
+* If device name is set as "", it will be ignored
+*/
+#define SET_USB_MIDI_DEVICE_NAME(name)        \
+  const char *getUSBMIDIDefaultDeviceName() { \
+    if (!name || strlen(name) == 0) {         \
+      return ESP32_USB_MIDI_DEFAULT_NAME;     \
+    }                                         \
+    return name;                              \
+  }
+
 bool shouldPrintChipDebugReport(void);
 #define ENABLE_CHIP_DEBUG_REPORT          \
   bool shouldPrintChipDebugReport(void) { \
     return true;                          \
   }
 
+// macro SET_TIME_BEFORE_STARTING_SKETCH_MS(time_ms) can set a time in milliseconds
+// before the sketch would start its execution. It gives the user time to open the Serial Monitor
+uint64_t getArduinoSetupWaitTime_ms(void);
+#define SET_TIME_BEFORE_STARTING_SKETCH_MS(time_ms) \
+  uint64_t getArduinoSetupWaitTime_ms() {           \
+    return (time_ms);                               \
+  }
+
 // allows user to bypass esp_spiram_test()
 bool esp_psram_extram_test(void);
 #define BYPASS_SPIRAM_TEST(bypass)    \

cores/esp32/esp32-hal-rmt.c

@@ -285,7 +285,7 @@ bool rmtDeinit(int pin) {
   return false;
 }
 
-static bool _rmtWrite(int pin, rmt_data_t *data, size_t num_rmt_symbols, bool blocking, bool loop, uint32_t timeout_ms) {
+static bool _rmtWrite(int pin, rmt_data_t *data, size_t num_rmt_symbols, bool blocking, uint32_t loop, uint32_t timeout_ms) {
   rmt_bus_handle_t bus = _rmtGetBus(pin, __FUNCTION__);
   if (bus == NULL) {
     return false;
@@ -303,11 +303,21 @@ static bool _rmtWrite(int pin, rmt_data_t *data, size_t num_rmt_symbols, bool bl
     }
   }
 
+#if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_VERBOSE
   log_v("GPIO: %d - Request: %d RMT Symbols - %s - Timeout: %d", pin, num_rmt_symbols, blocking ? "Blocking" : "Non-Blocking", timeout_ms);
-  log_v(
-    "GPIO: %d - Currently in Loop Mode: [%s] | Asked to Loop: %s, LoopCancel: %s", pin, bus->rmt_ch_is_looping ? "YES" : "NO", loop ? "YES" : "NO",
-    loopCancel ? "YES" : "NO"
-  );
+  // loop parameter semantics:
+  //   loop == 0: no looping (single transmission)
+  //   loop == 1: infinite looping
+  //   loop > 1: transmit the data 'loop' times
+  {
+    char buf[17];  // placeholder for up to maximum uint32_t value (4294967295) = 10 digits + " times" (6 chars) + null terminator (17 bytes)
+    snprintf(buf, sizeof(buf), "%lu times", loop);
+    log_v(
+      "GPIO: %d - Currently in Loop Mode: [%s] | Loop Request: [%s], LoopCancel: [%s]", pin, bus->rmt_ch_is_looping ? "YES" : "NO",
+      loop == 0 ? "NO" : (loop == 1 ? "FOREVER" : buf), loopCancel ? "YES" : "NO"
+    );
+  }
+#endif
 
   if ((xEventGroupGetBits(bus->rmt_events) & RMT_FLAG_TX_DONE) == 0) {
     log_v("GPIO %d - RMT Write still pending to be completed.", pin);
@@ -336,8 +346,8 @@ static bool _rmtWrite(int pin, rmt_data_t *data, size_t num_rmt_symbols, bool bl
     bus->rmt_ch_is_looping = false;
   } else {  // new writing | looping request
     // looping | Writing over a previous looping state is valid
-    if (loop) {
-      transmit_cfg.loop_count = -1;  // enable infinite loop mode
+    if (loop > 0) {
+      transmit_cfg.loop_count = (loop == 1) ? -1 : loop;
       // keeps RMT_FLAG_TX_DONE set - it never changes
     } else {
       // looping mode never sets this flag (IDF 5.1) in the callback
@@ -348,8 +358,10 @@ static bool _rmtWrite(int pin, rmt_data_t *data, size_t num_rmt_symbols, bool bl
       retCode = false;
       log_w("GPIO %d - RMT Transmission failed.", pin);
     } else {  // transmit OK
-      if (loop) {
-        bus->rmt_ch_is_looping = true;  // for ever... until a channel canceling or new writing
+      if (loop > 0) {
+        // rmt_ch_is_looping is used as a flag to indicate that RMT is in looping execution in order to
+        // be canceled whenever a new _rmtWrite() is executed while it is looping
+        bus->rmt_ch_is_looping = true;
       } else {
         if (blocking) {
           // wait for transmission confirmation | timeout
@@ -402,15 +414,36 @@ static bool _rmtRead(int pin, rmt_data_t *data, size_t *num_rmt_symbols, bool wa
 }
 
 bool rmtWrite(int pin, rmt_data_t *data, size_t num_rmt_symbols, uint32_t timeout_ms) {
-  return _rmtWrite(pin, data, num_rmt_symbols, true /*blocks*/, false /*looping*/, timeout_ms);
+  return _rmtWrite(pin, data, num_rmt_symbols, true /*blocks*/, 0 /*looping*/, timeout_ms);
 }
 
 bool rmtWriteAsync(int pin, rmt_data_t *data, size_t num_rmt_symbols) {
-  return _rmtWrite(pin, data, num_rmt_symbols, false /*blocks*/, false /*looping*/, 0 /*N/A*/);
+  return _rmtWrite(pin, data, num_rmt_symbols, false /*blocks*/, 0 /*looping*/, 0 /*N/A*/);
 }
 
 bool rmtWriteLooping(int pin, rmt_data_t *data, size_t num_rmt_symbols) {
-  return _rmtWrite(pin, data, num_rmt_symbols, false /*blocks*/, true /*looping*/, 0 /*N/A*/);
+  return _rmtWrite(pin, data, num_rmt_symbols, false /*blocks*/, 1 /*looping*/, 0 /*N/A*/);
+}
+
+// Same as rmtWriteLooping(...) but it transmits the data a fixed number of times ("loop_count").
+// loop_count == 0 is invalid (no transmission); loop_count == 1 transmits once (no looping); loop_count > 1 transmits the data repeatedly (looping).
+bool rmtWriteRepeated(int pin, rmt_data_t *data, size_t num_rmt_symbols, uint32_t loop_count) {
+  if (loop_count == 0) {
+    log_e("RMT TX GPIO %d : Invalid loop_count (%u). Must be at least 1.", pin, loop_count);
+    return false;
+  }
+  if (loop_count == 1) {
+    // send the RMT symbols once using non-blocking write (single non-looping transmission)
+    return _rmtWrite(pin, data, num_rmt_symbols, false /*blocks*/, 0 /*looping*/, 0 /*N/A*/);
+  } else {
+    // write the RMT symbols for loop_count times
+#if SOC_RMT_SUPPORT_TX_LOOP_COUNT
+    return _rmtWrite(pin, data, num_rmt_symbols, false /*blocks*/, loop_count /*looping*/, 0 /*N/A*/);
+#else
+    log_e("RMT TX GPIO %d : Loop Count is not supported. Writing failed.", pin);
+    return false;
+#endif
+  }
 }
 
 bool rmtTransmitCompleted(int pin) {

cores/esp32/esp32-hal-rmt.h

@@ -124,7 +124,9 @@ bool rmtWrite(int pin, rmt_data_t *data, size_t num_rmt_symbols, uint32_t timeou
 bool rmtWriteAsync(int pin, rmt_data_t *data, size_t num_rmt_symbols);
 
 /**
-     Writing data up to the reserved memsize, looping continuously
+     Writing data up to the reserved memsize, looping continuously (rmtWriteLooping()) or fixed
+     number of <loop_count> times (rmtWriteRepeated())
+
      <rmt_symbol> is a 32 bits structure as defined by rmt_data_t type.
      It is possible to use the macro RMT_SYMBOLS_OF(data), if data is an array of rmt_data_t
 
@@ -133,9 +135,11 @@ bool rmtWriteAsync(int pin, rmt_data_t *data, size_t num_rmt_symbols);
      Non-Blocking mode - returns right after execution
      Returns <true> on execution success, <false> otherwise
 
-     <bool rmtTransmitCompleted(int pin)> will return always <true> while it is looping.
+     <bool rmtTransmitCompleted(int pin)> will return always <true> while it is looping mode.
+     looping mode is active for rmtWriteLooping() and for rmtWriteRepeated() when loop_count > 1.
 */
 bool rmtWriteLooping(int pin, rmt_data_t *data, size_t num_rmt_symbols);
+bool rmtWriteRepeated(int pin, rmt_data_t *data, size_t num_rmt_symbols, uint32_t loop_count);
 
 /**
      Checks if transmission is completed and the rmtChannel ready for transmitting new data.

cores/esp32/esp32-hal-uart.c

@@ -59,7 +59,7 @@ struct uart_struct_t {
   uint16_t _rx_buffer_size, _tx_buffer_size;  // UART RX and TX buffer sizes
   bool _inverted;                             // UART inverted signal
   uint8_t _rxfifo_full_thrhd;                 // UART RX FIFO full threshold
-  int8_t _uart_clock_source;                  // UART Clock Source used when it is started using uartBegin()
+  int8_t _uart_clock_source;                  // UART Clock Source that should be used if user defines an specific one with setClockSource()
 };
 
 #if CONFIG_DISABLE_HAL_LOCKS
@@ -820,7 +820,7 @@ uart_t *uartBegin(
   uart_config.baud_rate = baudrate;
 #if SOC_UART_LP_NUM >= 1
   if (uart_nr >= SOC_UART_HP_NUM) {  // it is a LP UART NUM
-    if (uart->_uart_clock_source > 0) {
+    if (uart->_uart_clock_source >= 0) {
       uart_config.lp_source_clk = (soc_periph_lp_uart_clk_src_t)uart->_uart_clock_source;  // use user defined LP UART clock
       log_v("Setting UART%d to user defined LP clock source (%d) ", uart_nr, uart->_uart_clock_source);
     } else {
@@ -881,14 +881,7 @@ uart_t *uartBegin(
     uart->_tx_buffer_size = tx_buffer_size;
     uart->has_peek = false;
     uart->peek_byte = 0;
-#if SOC_UART_LP_NUM >= 1
-    if (uart_nr >= SOC_UART_HP_NUM) {
-      uart->_uart_clock_source = uart_config.lp_source_clk;
-    } else
-#endif
-    {
-      uart->_uart_clock_source = uart_config.source_clk;
-    }
+    // uart->_uart_clock_source can only change by explicit user API request/call
   }
   UART_MUTEX_UNLOCK();
 
@@ -1149,10 +1142,9 @@ bool uartSetBaudRate(uart_t *uart, uint32_t baud_rate) {
   }
   bool retCode = true;
   soc_module_clk_t newClkSrc = UART_SCLK_DEFAULT;
-  int8_t previousClkSrc = uart->_uart_clock_source;
 #if SOC_UART_LP_NUM >= 1
   if (uart->num >= SOC_UART_HP_NUM) {  // it is a LP UART NUM
-    if (uart->_uart_clock_source > 0) {
+    if (uart->_uart_clock_source >= 0) {
       newClkSrc = (soc_periph_lp_uart_clk_src_t)uart->_uart_clock_source;  // use user defined LP UART clock
       log_v("Setting UART%d to user defined LP clock source (%d) ", uart->num, newClkSrc);
     } else {
@@ -1187,13 +1179,10 @@ bool uartSetBaudRate(uart_t *uart, uint32_t baud_rate) {
     }
   }
   UART_MUTEX_LOCK();
-  // if necessary, set the correct UART Clock Source before changing the baudrate
-  if (previousClkSrc < 0 || previousClkSrc != newClkSrc) {
-    HP_UART_SRC_CLK_ATOMIC() {
-      uart_ll_set_sclk(UART_LL_GET_HW(uart->num), newClkSrc);
-    }
-    uart->_uart_clock_source = newClkSrc;
+  HP_UART_SRC_CLK_ATOMIC() {
+    uart_ll_set_sclk(UART_LL_GET_HW(uart->num), newClkSrc);
   }
+  // uart->_uart_clock_source can only change by explicit user API request/call
   if (uart_set_baudrate(uart->num, baud_rate) == ESP_OK) {
     log_v("Setting UART%d baud rate to %ld.", uart->num, baud_rate);
     uart->_baudrate = baud_rate;
@@ -1312,7 +1301,7 @@ bool uartSetClockSource(uint8_t uartNum, uart_sclk_t clkSrc) {
   {
     uart->_uart_clock_source = clkSrc;
   }
-  //log_i("UART%d set clock source to %d", uart->num, uart->_uart_clock_source);
+  log_v("UART%d set clock source to %d", uart->num, uart->_uart_clock_source);
   return true;
 }
 

cores/esp32/main.cpp

@@ -44,10 +44,18 @@ __attribute__((weak)) bool shouldPrintChipDebugReport(void) {
   return false;
 }
 
+// this function can be changed by the sketch using the macro SET_TIME_BEFORE_STARTING_SKETCH_MS(time_ms)
+__attribute__((weak)) uint64_t getArduinoSetupWaitTime_ms(void) {
+  return 0;
+}
+
 void loopTask(void *pvParameters) {
 #if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_SERIAL)
   // sets UART0 (default console) RX/TX pins as already configured in boot or as defined in variants/pins_arduino.h
   Serial0.setPins(gpioNumberToDigitalPin(SOC_RX0), gpioNumberToDigitalPin(SOC_TX0));
+  // time in ms that the sketch may wait before starting its execution - default is zero
+  // usually done for opening the Serial Monitor and seeing all debug messages
+  delay(getArduinoSetupWaitTime_ms());
 #endif
 #if ARDUHAL_LOG_LEVEL >= ARDUHAL_LOG_LEVEL_DEBUG
   printBeforeSetupInfo();

libraries/BLE/src/BLE2902.h

@@ -55,9 +55,6 @@ This class will be removed in a future version.")]] BLE2902 : public BLEDescript
     bool getIndications();
     void setNotifications(bool flag);
     void setIndications(bool flag);
-
-  private:
-    friend class BLECharacteristic;
   };  // BLE2902
 
 #endif /* CONFIG_BLUEDROID_ENABLED || CONFIG_NIMBLE_ENABLED */

libraries/BLE/src/BLE2904.h

@@ -94,8 +94,6 @@ class BLE2904 : public BLEDescriptor {
   void setUnit(uint16_t unit);
 
 private:
-  friend class BLECharacteristic;
-
   /***************************************************************************
    *                         Common private properties                         *
    ***************************************************************************/

libraries/BLE/src/BLEAddress.cpp

@@ -58,13 +58,8 @@ BLEAddress::BLEAddress() {
  * @param [in] otherAddress The other address to compare against.
  * @return True if the addresses are equal.
  */
-bool BLEAddress::equals(BLEAddress otherAddress) {
-#if defined(CONFIG_NIMBLE_ENABLED)
-  if (m_addrType != otherAddress.m_addrType) {
-    return false;
-  }
-#endif
-  return memcmp(otherAddress.getNative(), m_address, ESP_BD_ADDR_LEN) == 0;
+bool BLEAddress::equals(const BLEAddress &otherAddress) const {
+  return *this == otherAddress;
 }
 
 bool BLEAddress::operator==(const BLEAddress &otherAddress) const {
@@ -115,9 +110,9 @@ uint8_t *BLEAddress::getNative() {
  *
  * @return The string representation of the address.
  */
-String BLEAddress::toString() {
-  auto size = 18;
-  char *res = (char *)malloc(size);
+String BLEAddress::toString() const {
+  constexpr size_t size = 18;
+  char res[size];
 
 #if defined(CONFIG_BLUEDROID_ENABLED)
   snprintf(res, size, "%02x:%02x:%02x:%02x:%02x:%02x", m_address[0], m_address[1], m_address[2], m_address[3], m_address[4], m_address[5]);
@@ -128,7 +123,6 @@ String BLEAddress::toString() {
 #endif
 
   String ret(res);
-  free(res);
   return ret;
 }
 
@@ -157,7 +151,7 @@ BLEAddress::BLEAddress(esp_bd_addr_t address) {
  *
  * @param [in] stringAddress The hex representation of the address.
  */
-BLEAddress::BLEAddress(String stringAddress) {
+BLEAddress::BLEAddress(const String &stringAddress) {
   if (stringAddress.length() != 17) {
     return;
   }
@@ -192,7 +186,7 @@ BLEAddress::BLEAddress(ble_addr_t address) {
   m_addrType = address.type;
 }
 
-uint8_t BLEAddress::getType() {
+uint8_t BLEAddress::getType() const {
   return m_addrType;
 }
 
@@ -208,7 +202,7 @@ uint8_t BLEAddress::getType() {
  * @param [in] stringAddress The hex representation of the address.
  * @param [in] type The address type.
  */
-BLEAddress::BLEAddress(String stringAddress, uint8_t type) {
+BLEAddress::BLEAddress(const String &stringAddress, uint8_t type) {
   if (stringAddress.length() != 17) {
     return;
   }

libraries/BLE/src/BLEAddress.h

@@ -64,23 +64,23 @@ class BLEAddress {
    ***************************************************************************/
 
   BLEAddress();
-  bool equals(BLEAddress otherAddress);
+  bool equals(const BLEAddress &otherAddress) const;
   bool operator==(const BLEAddress &otherAddress) const;
   bool operator!=(const BLEAddress &otherAddress) const;
   bool operator<(const BLEAddress &otherAddress) const;
   bool operator<=(const BLEAddress &otherAddress) const;
   bool operator>(const BLEAddress &otherAddress) const;
   bool operator>=(const BLEAddress &otherAddress) const;
   uint8_t *getNative();
-  String toString();
+  String toString() const;
 
   /***************************************************************************
    *                       Bluedroid public declarations                     *
    ***************************************************************************/
 
 #if defined(CONFIG_BLUEDROID_ENABLED)
   BLEAddress(esp_bd_addr_t address);
-  BLEAddress(String stringAddress);
+  BLEAddress(const String &stringAddress);
 #endif
 
   /***************************************************************************
@@ -89,9 +89,9 @@ class BLEAddress {
 
 #if defined(CONFIG_NIMBLE_ENABLED)
   BLEAddress(ble_addr_t address);
-  BLEAddress(String stringAddress, uint8_t type = BLE_ADDR_PUBLIC);
+  BLEAddress(const String &stringAddress, uint8_t type = BLE_ADDR_PUBLIC);
   BLEAddress(uint8_t address[ESP_BD_ADDR_LEN], uint8_t type = BLE_ADDR_PUBLIC);
-  uint8_t getType();
+  uint8_t getType() const;
 #endif
 
 private: