[pull] master from espressif:master

.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/ESP32/examples/ArduinoWaitTimeBeforeStartingSketch/ArduinoWaitTimeBeforeStartingSketch.ino

@@ -0,0 +1,13 @@
+// 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
+
+// This will force the Sketch execution to wait for 5 seconds before starting it execution
+// setup() will be executed only after this time
+SET_TIME_BEFORE_STARTING_SKETCH_MS(5000);
+
+void setup() {
+ Serial.begin(115200);
+ Serial.println("After 5 seconds... this message will be seen in the Serial Monitor.");
+}
+
+void loop() {}

libraries/ESP32/examples/RMT/RMT_LED_Blink/RMT_LED_Blink.ino

@@ -276,6 +276,30 @@ void RMT_Loop_Write_Blink() {
  delay(2000);
 }
 
+void RMT_Repeated_Write_Blink() {
+ Serial.println("Using RMT Writing repeated N times to blink an LED.");
+ Serial.println("Blinking at 1s on + 1s off :: 2 blinks");
+ // repeating blink_1s_rmt_data (1s on + 1s off) 2 times for 2 blinks
+ if (!rmtWriteRepeated(BLINK_GPIO, blink_1s_rmt_data, RMT_SYMBOLS_OF(blink_1s_rmt_data), 2)) {
+ Serial.println("===> rmtWrite Blink 1s Error!");
+ }
+ delay(4000 + 1000); // it should blink 2 times and stop automatically
+ Serial.println("Blinking at 500ms on + 500ms off :: 4 blinks");
+ // repeating blink_500ms_rmt_data (500ms on + 500ms off) 4 times for 4 blinks
+ if (!rmtWriteRepeated(BLINK_GPIO, blink_500ms_rmt_data, RMT_SYMBOLS_OF(blink_500ms_rmt_data), 4)) {
+ Serial.println("===> rmtWrite Blink 0.5s Error!");
+ }
+ delay(4000 + 1000); // it should blink 4 times and stop automatically
+ Serial.println("Blinking at 250ms on + 250ms off :: 8 blinks");
+ // repeating blink_250ms_rmt_data (250ms on + 250ms off) 8 times for 8 blinks
+ if (!rmtWriteRepeated(BLINK_GPIO, blink_250ms_rmt_data, RMT_SYMBOLS_OF(blink_250ms_rmt_data), 8)) {
+ Serial.println("===> rmtWrite Blink 0.25s Error!");
+ }
+ delay(4000 + 1000); // it should blink 8 times and stop automatically
+ Serial.println("Blinking is OFF for 2 seconds");
+ delay(2000);
+}
+
 void RMT_Single_Write_Blocking_Blink() {
  Serial.println("Using RMT Writing and its Completion to blink an LED.");
  Serial.println("Blinking at 1s on + 1s off :: 2 blinks");
@@ -356,6 +380,7 @@ void setup() {
 void loop() {
  RMT_Write_Aync_Non_Blocking_Blink();
  RMT_Loop_Write_Blink();
+ RMT_Repeated_Write_Blink();
  RMT_Single_Write_Blocking_Blink();
  Serial.println("\nStarting OVER...\n");
 }