Merge branch 'main' of https://github.com/4dsystems/arduino-esp32

Author: cruzjuniel

.github/scripts/get_affected.py

@@ -222,6 +222,123 @@ def detect_universal_ctags() -> bool:
     except Exception:
         return False
 
+def normalize_function_signature(signature: str) -> str:
+    """
+    Normalize a function signature by removing parameter names, keeping only types.
+
+    This handles cases where header declarations and implementations have different parameter names.
+    Uses a simple heuristic: the last word in each parameter is typically the parameter name.
+
+    For example:
+    - "ltoa(long val, char *s, int radix)" -> "ltoa(long,char *,int)"
+    - "ltoa(long value, char *result, int base)" -> "ltoa(long,char *,int)"
+
+    Args:
+        signature: The function signature string, e.g., "(long val, char *s, int radix)"
+
+    Returns:
+        Normalized signature with parameter names removed, e.g., "(long,char *,int)"
+    """
+    if not signature:
+        return signature
+
+    # Normalize signatures: treat (void) and () as equivalent (both mean no parameters)
+    if signature == "(void)":
+        return "()"
+
+    if not (signature.startswith("(") and signature.endswith(")")):
+        return signature
+
+    # Handle const qualifier at the end (e.g., "(int i) const")
+    const_qualifier = ""
+    if signature.endswith(" const"):
+        signature = signature[:-6]  # Remove " const"
+        const_qualifier = " const"
+
+    # Extract parameter list without parentheses
+    param_list = signature[1:-1]
+    if not param_list.strip():
+        return "()" + const_qualifier
+
+    # Split by comma and process each parameter
+    params = []
+    for param in param_list.split(","):
+        param = param.strip()
+        if not param:
+            continue
+
+        # Handle default parameters (e.g., "int x = 5")
+        if "=" in param:
+            param = param.split("=")[0].strip()
+
+        # Try simple approach first: remove the last word
+        # This works for most cases: "int x" -> "int", "MyStruct s" -> "MyStruct"
+        import re
+
+        # Handle arrays first: "int arr[10]" -> "int [10]", "char *argv[]" -> "char *[]"
+        array_match = re.match(r'^(.+?)\s+(\w+)((?:\[\d*\])+)$', param)
+        if array_match:
+            type_part = array_match.group(1).strip()
+            array_brackets = array_match.group(3)
+            params.append(type_part + array_brackets)
+        else:
+            # Handle function pointers: "int (*func)(int, char)" -> "int (*)(int, char)"
+            func_ptr_match = re.match(r'^(.+?)\s*\(\s*\*\s*(\w+)\s*\)\s*\((.+?)\)\s*$', param)
+            if func_ptr_match:
+                return_type = func_ptr_match.group(1).strip()
+                inner_params = func_ptr_match.group(3).strip()
+                # Recursively normalize the inner parameters
+                if inner_params:
+                    inner_normalized = normalize_function_signature(f"({inner_params})")
+                    inner_normalized = inner_normalized[1:-1]  # Remove outer parentheses
+                else:
+                    inner_normalized = ""
+                params.append(f"{return_type} (*)({inner_normalized})")
+            else:
+                # Try simple approach: remove the last word
+                simple_match = re.match(r'^(.+)\s+(\w+)$', param)
+                if simple_match:
+                    # Simple case worked - just remove the last word
+                    type_part = simple_match.group(1).strip()
+                    params.append(type_part)
+                else:
+                    # Fallback to complex regex for edge cases with pointers
+                    # First, try to match cases with pointers/references (including multiple *)
+                    # Pattern: (everything before) (one or more * or &) (space) (parameter name)
+                    m = re.match(r'^(.+?)(\s*[*&]+\s+)(\w+)$', param)
+                    if m:
+                        # Keep everything before the pointers, plus the pointers (without the space before param name)
+                        type_part = m.group(1) + m.group(2).rstrip()
+                        params.append(type_part.strip())
+                    else:
+                        # Try to match cases without space between type and pointer: "char*ptr", "char**ptr"
+                        m = re.match(r'^(.+?)([*&]+)(\w+)$', param)
+                        if m:
+                            # Keep everything before the pointers, plus the pointers
+                            type_part = m.group(1) + m.group(2)
+                            params.append(type_part.strip())
+                        else:
+                            # Single word - assume it's a type
+                            params.append(param.strip())
+
+        # Normalize spacing around pointers to ensure consistent output
+        # This ensures "char *" and "char*" both become "char *"
+        if params:
+            last_param = params[-1]
+            # Normalize spacing around * and & symbols
+            # Replace multiple spaces with single space, ensure space before * and &
+            normalized = re.sub(r'\s+', ' ', last_param)  # Collapse multiple spaces
+            normalized = re.sub(r'\s*([*&]+)', r' \1', normalized)  # Ensure space before * and &
+            normalized = re.sub(r'([*&]+)\s*', r'\1 ', normalized)  # Ensure space after * and &
+            normalized = re.sub(r'\s+', ' ', normalized).strip()  # Clean up extra spaces
+            params[-1] = normalized
+
+    result = "(" + ",".join(params) + ")"
+    if const_qualifier:
+        result += const_qualifier
+
+    return result
+
 def build_qname_from_tag(tag: dict) -> str:
     """
     Compose a qualified name for a function/method using scope + name + signature.
@@ -231,9 +348,8 @@ def build_qname_from_tag(tag: dict) -> str:
     name = tag.get("name") or ""
     signature = tag.get("signature") or ""
 
-    # Normalize signatures: treat (void) and () as equivalent (both mean no parameters)
-    if signature == "(void)":
-        signature = "()"
+    # Normalize the signature to remove parameter names
+    signature = normalize_function_signature(signature)
 
     qparts = []
     if scope:

.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.

boards.txt

@@ -36597,9 +36597,15 @@ XIAO_ESP32S3.menu.PartitionScheme.max_app_8MB.build.partitions=max_app_8MB
 XIAO_ESP32S3.menu.PartitionScheme.max_app_8MB.upload.maximum_size=8257536
 XIAO_ESP32S3.menu.PartitionScheme.tinyuf2=TinyUF2 8MB (2MB APP/3.7MB FFAT)
 XIAO_ESP32S3.menu.PartitionScheme.tinyuf2.build.custom_bootloader=bootloader-tinyuf2
-XIAO_ESP32S3.menu.PartitionScheme.tinyuf2.build.custom_partitions=partitions-8MB-tinyuf2
+XIAO_ESP32S3.menu.PartitionScheme.tinyuf2.build.partitions=tinyuf2-partitions-8MB
 XIAO_ESP32S3.menu.PartitionScheme.tinyuf2.upload.maximum_size=2097152
 XIAO_ESP32S3.menu.PartitionScheme.tinyuf2.upload.extra_flags=0x410000 "{runtime.platform.path}/variants/{build.variant}/tinyuf2.bin"
+XIAO_ESP32S3.menu.PartitionScheme.tinyuf2_noota=TinyUF2 8MB No OTA (4MB APP/3.7MB FFAT)
+XIAO_ESP32S3.menu.PartitionScheme.tinyuf2_noota.build.custom_bootloader=bootloader-tinyuf2
+XIAO_ESP32S3.menu.PartitionScheme.tinyuf2_noota.build.partitions=tinyuf2-partitions-8MB-noota
+XIAO_ESP32S3.menu.PartitionScheme.tinyuf2_noota.upload.maximum_size=4194304
+XIAO_ESP32S3.menu.PartitionScheme.tinyuf2_noota.upload.extra_flags=0x410000 "{runtime.platform.path}/variants/{build.variant}/tinyuf2.bin"
+
 
 XIAO_ESP32S3.menu.CPUFreq.240=240MHz (WiFi)
 XIAO_ESP32S3.menu.CPUFreq.240.build.f_cpu=240000000L

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.