Merge branch 'master' into usbhid_semaphore

Author: SuGlider

boards.txt

@@ -30,6 +30,7 @@ extern "C" {
 }
 #include <MD5Builder.h>
 
+#include "soc/spi_reg.h"
 #include "esp_system.h"
 #ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
 #if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
@@ -55,6 +56,14 @@ extern "C" {
 #define ESP_FLASH_IMAGE_BASE 0x1000
 #endif
 
+// REG_SPI_BASE is not defined for S3/C3 ??
+
+#if CONFIG_IDF_TARGET_ESP32S3 || CONFIG_IDF_TARGET_ESP32C3
+  #ifndef REG_SPI_BASE
+  #define REG_SPI_BASE(i)     (DR_REG_SPI1_BASE + (((i)>1) ? (((i)* 0x1000) + 0x20000) : (((~(i)) & 1)* 0x1000 )))
+  #endif // REG_SPI_BASE
+#endif // TARGET
+
 /**
  * User-defined Literals
  *  usage:
@@ -192,7 +201,7 @@ static uint32_t sketchSize(sketchSize_t response) {
         return data.image_len;
     }
 }
-    
+
 uint32_t EspClass::getSketchSize () {
     return sketchSize(SKETCH_SIZE_TOTAL);
 }
@@ -305,13 +314,17 @@ const char * EspClass::getSdkVersion(void)
     return esp_get_idf_version();
 }
 
+uint32_t ESP_getFlashChipId(void)
+{
+  uint32_t id = g_rom_flashchip.device_id;
+  id = ((id & 0xff) << 16) | ((id >> 16) & 0xff) | (id & 0xff00);
+  return id;
+}
+
 uint32_t EspClass::getFlashChipSize(void)
 {
-    esp_image_header_t fhdr;
-    if(flashRead(ESP_FLASH_IMAGE_BASE, (uint32_t*)&fhdr, sizeof(esp_image_header_t)) && fhdr.magic != ESP_IMAGE_HEADER_MAGIC) {
-        return 0;
-    }
-    return magicFlashChipSize(fhdr.spi_size);
+  uint32_t id = (ESP_getFlashChipId() >> 16) & 0xFF;
+  return 2 << (id - 1);
 }
 
 uint32_t EspClass::getFlashChipSpeed(void)
@@ -325,11 +338,26 @@ uint32_t EspClass::getFlashChipSpeed(void)
 
 FlashMode_t EspClass::getFlashChipMode(void)
 {
-    esp_image_header_t fhdr;
-    if(flashRead(ESP_FLASH_IMAGE_BASE, (uint32_t*)&fhdr, sizeof(esp_image_header_t)) && fhdr.magic != ESP_IMAGE_HEADER_MAGIC) {
-        return FM_UNKNOWN;
-    }
-    return magicFlashChipMode(fhdr.spi_mode);
+   #if CONFIG_IDF_TARGET_ESP32S2
+   uint32_t spi_ctrl = REG_READ(PERIPHS_SPI_FLASH_CTRL);
+   #else
+   uint32_t spi_ctrl = REG_READ(SPI_CTRL_REG(0));
+   #endif
+   /* Not all of the following constants are already defined in older versions of spi_reg.h, so do it manually for now*/
+   if (spi_ctrl & BIT(24)) { //SPI_FREAD_QIO
+       return (FM_QIO);
+   } else if (spi_ctrl & BIT(20)) { //SPI_FREAD_QUAD
+       return (FM_QOUT);
+   } else if (spi_ctrl &  BIT(23)) { //SPI_FREAD_DIO
+       return (FM_DIO);
+   } else if (spi_ctrl & BIT(14)) { // SPI_FREAD_DUAL
+       return (FM_DOUT);
+   } else if (spi_ctrl & BIT(13)) { //SPI_FASTRD_MODE
+       return (FM_FAST_READ);
+   } else {
+       return (FM_SLOW_READ);
+   }
+   return (FM_DOUT);
 }
 
 uint32_t EspClass::magicFlashChipSize(uint8_t byte)

cores/esp32/Esp.cpp

@@ -8,7 +8,7 @@ Development Boards
 You will need a development board or a custom board with the ESP32 (see Supported SoC's) to start playing.
 There is a bunch of different types and models widely available on the Internet. You need to choose one that covers all your requirements.
 
-To help you on this selection, we point out some facts about choosing the proper boardsto help you to save money and time.
+To help you on this selection, we point out some facts about choosing the proper boards to help you to save money and time.
 
 **One ESP32 to rule them all!**
 
@@ -112,4 +112,4 @@ Resources
 
 .. |board_lolin_d32_pro| raw:: html
 
-  <a href="https://www.wemos.cc/en/latest/d32/d32_pro.html" target="_blank">LOLIN D32 Pro</a>
+  <a href="https://www.wemos.cc/en/latest/d32/d32_pro.html" target="_blank">LOLIN D32 Pro</a>

docs/source/boards/boards.rst

@@ -11,3 +11,7 @@ To use the arduino-esp32 core with a modified sdkconfig option, you need to use
 
 Note that modifying ``sdkconfig`` or ``sdkconfig.h`` files found in the arduino-esp32 project tree **does not** result in changes to these options. This is because ESP-IDF libraries are included into the arduino-esp32 project tree as pre-built libraries.
 
+How to compile libs with different debug level?
+-----------------------------------------------
+
+The short answer is ``esp32-arduino-lib-builder/configs/defconfig.common:44``. A guide explaining the process can be found here <guides/core_debug>

docs/source/faq.rst

@@ -0,0 +1,41 @@
+##################################
+Compile Arduino libs with ESP_LOGx
+##################################
+
+There are 2 primary approaches and both of them involve editing file ``configs/defconfig.common``.
+Edit the file directly and then build.
+Later you can ``git restore configs/defconfig.common`` to go back.
+Copy the file ``cp configs/defconfig.common configs/defconfig.debug`` and edit the debug version.
+
+``vim configs/defconfig.common`` or ``vim configs/defconfig.debug``
+
+Edit **line 44** containing by default ``CONFIG_LOG_DEFAULT_LEVEL_ERROR=y`` to one of the following lines depending on your desired log level:
+
+.. code-block:: bash
+
+   CONFIG_LOG_DEFAULT_LEVEL_NONE=y # No output
+   CONFIG_LOG_DEFAULT_LEVEL_ERROR=y # Errors - default
+   CONFIG_LOG_DEFAULT_LEVEL_WARN=y # Warnings
+   CONFIG_LOG_DEFAULT_LEVEL_INFO=y # Info
+   CONFIG_LOG_DEFAULT_LEVEL_DEBUG=y # Debug
+   CONFIG_LOG_DEFAULT_LEVEL_VERBOSE=y # Verbose
+
+Then simply build the libs for all SoCs or one specific SoC. Note that building for all SoCs takes a lot of time, so if you are working only with specific SoC(s), build only for those.
+
+.. note::
+   If you have copied the ``defconfig`` file and the debug settings are in file ``configs/defconfig.debug`` add flag ``debug`` to compilation command.
+   Example : ``./build.sh debug``
+
+   - **Option 1**: Build for all SoCs: ``./build.sh``
+   - **Option 2**: Build for one SoC: ``./build.sh -t <soc>``. The exact text to choose the SoC:
+
+      - ``esp32``
+      - ``esp32s2``
+      - ``esp32c3``
+      - ``esp32s3``
+      - Example: ``./build.sh -t esp32``
+      - A wrong format or non-existing SoC will result in the error sed: can't read sdkconfig: No such file or directory
+   - **Option 3**: Build for multiple SoCs (not all) - simply write them down separated with space: ``./build.sh -t <soc1> <soc2> <soc3>``
+
+      - Example: ``./build.sh -t esp32 esp32-c3``
+

docs/source/guides/core_debug.rst

@@ -0,0 +1,165 @@
+/*
+  This example smothly blinks GPIO_2 using different frequencies changed after Deep Sleep Time
+  The PWM and control of blink frequency is done by ULP exclusively
+  This is an example about how to program the ULP using Arduino
+  It also demonstrates use of RTM MEMORY to persist data and states
+*/
+
+#include <Arduino.h>
+#include "esp32/ulp.h"
+#include "driver/rtc_io.h"
+
+// RTC Memory used for ULP internal variable and Sketch interfacing
+#define RTC_dutyMeter 0
+#define RTC_dir       4
+#define RTC_fadeDelay 12
+// *fadeCycleDelay is used to pass values to ULP and change its behaviour
+uint32_t *fadeCycleDelay = &RTC_SLOW_MEM[RTC_fadeDelay];
+#define ULP_START_OFFSET 32
+
+// For ESP32 Arduino, it is usually at offeset 512, defined in sdkconfig
+RTC_DATA_ATTR uint32_t ULP_Started = 0; // 0 or 1
+
+//Time-to-Sleep
+#define uS_TO_S_FACTOR 1000000ULL  /* Conversion factor for micro seconds to seconds */
+#define TIME_TO_SLEEP  5           /* Time ESP32 will go to sleep (in microseconds); multiplied by above conversion to achieve seconds*/
+
+
+void ulp_setup() {
+  if (ULP_Started) {
+    return;
+  }
+  *fadeCycleDelay = 5; // 5..200 works fine for a full Fade In + Out cycle
+  ULP_Started = 1;
+
+  // GPIO2 initialization (set to output and initial value is 0)
+  const gpio_num_t MeterPWMPin = GPIO_NUM_2;
+  rtc_gpio_init(MeterPWMPin);
+  rtc_gpio_set_direction(MeterPWMPin, RTC_GPIO_MODE_OUTPUT_ONLY);
+  rtc_gpio_set_level(MeterPWMPin, 0);
+
+  // if LED is connected to GPIO2 (specify by +RTC_GPIO_OUT_DATA_S : ESP32 is 14, S2/S3 is 10)
+  const uint32_t MeterPWMBit = rtc_io_number_get(MeterPWMPin) + RTC_GPIO_OUT_DATA_S;
+
+  enum labels {
+    INIFINITE_LOOP,
+    RUN_PWM,
+    NEXT_PWM_CYCLE,
+    PWM_ON,
+    PWM_OFF,
+    END_PWM_CYCLE,
+    POSITIVE_DIR,
+    DEC_DUTY,
+    INC_DUTY,
+  };
+  
+  // Define ULP program
+  const ulp_insn_t ulp_prog[] = {
+    // Initial Value setup
+    I_MOVI(R0, 0),                // R0 = 0
+    I_ST(R0, R0, RTC_dutyMeter),  // RTC_SLOW_MEM[RTC_dutyMeter] = 0
+    I_MOVI(R1, 1),                // R1 = 1
+    I_ST(R1, R0, RTC_dir),        // RTC_SLOW_MEM[RTC_dir] = 1
+
+    M_LABEL(INIFINITE_LOOP),      // while(1) {
+
+    // run certain PWM Duty for about (RTC_fadeDelay x 100) microseconds
+    I_MOVI(R3, 0),                //   R3 = 0
+    I_LD(R3, R3, RTC_fadeDelay),  //   R3 = RTC_SLOW_MEM[RTC_fadeDelay]
+    M_LABEL(RUN_PWM),             //   do {  // repeat RTC_fadeDelay times:
+
+    // execute about 10KHz PWM on GPIO2 using as duty cycle = RTC_SLOW_MEM[RTC_dutyMeter]
+    I_MOVI(R0, 0),                //     R0 = 0
+    I_LD(R0, R0, RTC_dutyMeter),  //     R0 = RTC_SLOW_MEM[RTC_dutyMeter]
+    M_BL(NEXT_PWM_CYCLE, 1),      //     if (R0 > 0) turn on LED
+    I_WR_REG(RTC_GPIO_OUT_W1TS_REG, MeterPWMBit, MeterPWMBit, 1), // W1TS set bit to clear GPIO - GPIO2 on
+    M_LABEL(PWM_ON),              //     while (R0 > 0) // repeat RTC_dutyMeter times:
+    M_BL(NEXT_PWM_CYCLE, 1),      //     {
+    //I_DELAY(8),                 //       // 8 is about 1 microsecond based on 8MHz
+    I_SUBI(R0, R0, 1),            //       R0 = R0 - 1
+    M_BX(PWM_ON),                 //     }
+    M_LABEL(NEXT_PWM_CYCLE),      //     // toggle GPIO_2
+    I_MOVI(R0, 0),                //     R0 = 0
+    I_LD(R0, R0, RTC_dutyMeter),  //     R0 = RTC_SLOW_MEM[RTC_dutyMeter]
+    I_MOVI(R1, 100),              //     R1 = 100
+    I_SUBR(R0, R1, R0),           //     R0 = 100 - dutyMeter
+    M_BL(END_PWM_CYCLE, 1),       //     if (R0 > 0) turn off LED
+    I_WR_REG(RTC_GPIO_OUT_W1TC_REG, MeterPWMBit, MeterPWMBit, 1), // W1TC set bit to clear GPIO - GPIO2 off
+    M_LABEL(PWM_OFF),             //     while (R0 > 0)  // repeat (100 - RTC_dutyMeter) times:
+    M_BL(END_PWM_CYCLE, 1),       //     {
+    //I_DELAY(8),                 //       // 8 is about 1us: ULP fetch+execution time
+    I_SUBI(R0, R0, 1),            //       R0 = R0 - 1
+    M_BX(PWM_OFF),                //     }
+    M_LABEL(END_PWM_CYCLE),       //
+
+    I_SUBI(R3, R3, 1),            //     R3 = R3 - 1  // RTC_fadeDelay
+    I_MOVR(R0, R3),               //     R0 = R3      // only R0 can be used to compare and branch
+    M_BGE(RUN_PWM, 1),            //   } while (R3 > 0)  // ESP32 repeatinf RTC_fadeDelay times
+
+    // increase/decrease DutyMeter to apply Fade In/Out loop
+    I_MOVI(R1, 0),                //   R1 = 0
+    I_LD(R1, R1, RTC_dutyMeter),  //   R1 = RTC_SLOW_MEM[RTC_dutyMeter]
+    I_MOVI(R0, 0),                //   R0 = 0
+    I_LD(R0, R0, RTC_dir),        //   R0 = RTC_SLOW_MEM[RTC_dir]
+
+    M_BGE(POSITIVE_DIR, 1),                  //   if(dir == 0) { // decrease duty by 2
+    // Dir is 0, means decrease Duty by 2
+    I_MOVR(R0, R1),               //     R0 = Duty
+    M_BGE(DEC_DUTY, 1),                  //     if (duty == 0) { // change direction and increase duty
+    I_MOVI(R3, 0),                //       R3 = 0
+    I_MOVI(R2, 1),                //       R2 = 1
+    I_ST(R2, R3, RTC_dir),        //       RTC_SLOW_MEM[RTC_dir] = 1   // increasing direction
+    M_BX(INC_DUTY),                      //       goto "increase Duty"
+    M_LABEL(DEC_DUTY),                   //     } "decrease Duty":
+    I_SUBI(R0, R0, 2),            //     Duty -= 2
+    I_MOVI(R2, 0),                //     R2 = 0
+    I_ST(R0, R2, RTC_dutyMeter),  //     RTC_SLOW_MEM[RTC_dutyMeter] += 2
+    M_BX(INIFINITE_LOOP),         // }
+
+    M_LABEL(POSITIVE_DIR),        //   else { // dir == 1 // increase duty by 2
+    // Dir is 1, means increase Duty by 2
+    I_MOVR(R0, R1),               //     R0 = Duty
+    M_BL(INC_DUTY, 100),          //     if (duty == 100) { // change direction and decrease duty
+    I_MOVI(R2, 0),                //       R2 = 0
+    I_ST(R2, R2, RTC_dir),        //       RTC_SLOW_MEM[RTC_dir] = 0  // decreasing direction
+    M_BX(DEC_DUTY),               //       goto "decrease Duty"
+    M_LABEL(INC_DUTY),            //     } "increase Duty":
+    I_ADDI(R0, R0, 2),            //     Duty += 2
+    I_MOVI(R2, 0),                //     R2 = 0
+    I_ST(R0, R2, RTC_dutyMeter),  //     RTC_SLOW_MEM[RTC_dutyMeter] -= 2
+                                  //   } // if (dir == 0)
+    M_BX(INIFINITE_LOOP),         // } // while(1)
+  };
+  // Run ULP program
+  size_t size = sizeof(ulp_prog) / sizeof(ulp_insn_t);
+  ulp_process_macros_and_load(ULP_START_OFFSET, ulp_prog, &size);
+  esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
+  ulp_run(ULP_START_OFFSET);
+}
+
+
+void setup() {
+  Serial.begin(115200);
+  while (!Serial) {}  // wait for Serial to start
+
+  ulp_setup(); // it really only runs on the first ESP32 boot
+  Serial.printf("\nStarted smooth blink with delay %d\n", *fadeCycleDelay);
+
+  // *fadeCycleDelay resides in RTC_SLOW_MEM and persists along deep sleep waking up
+  // it is used as a delay time parameter for smooth blinking, in the ULP processing code
+  if (*fadeCycleDelay < 195) {
+    *fadeCycleDelay += 10;
+  } else {
+    *fadeCycleDelay = 5; // 5..200 works fine for a full Fade In + Out cycle
+  }
+  Serial.println("Entering in Deep Sleep");
+  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR /*/ 4*/); // time set with variable above
+  esp_deep_sleep_start();
+  // From this point on, no code is executed in DEEP SLEEP mode
+}
+
+
+void loop() {
+  // It never reaches this code because it enters in Deep Sleep mode at the end of setup()
+}
+

libraries/ESP32/examples/DeepSleep/SmoothBlink_ULP_Code/.skip.esp32c3

@@ -31,6 +31,7 @@
 
 #include <esp_now.h>
 #include <WiFi.h>
+#include <esp_wifi.h> // only for esp_wifi_set_channel()
 
 // Global copy of slave
 esp_now_peer_info_t slave;
@@ -55,7 +56,7 @@ void InitESPNow() {
 
 // Scan for slaves in AP mode
 void ScanForSlave() {
-  int8_t scanResults = WiFi.scanNetworks();
+  int16_t scanResults = WiFi.scanNetworks(false, false, false, 300, CHANNEL); // Scan only on one channel
   // reset on each scan
   bool slaveFound = 0;
   memset(&slave, 0, sizeof(slave));
@@ -222,9 +223,11 @@ void setup() {
   Serial.begin(115200);
   //Set device in STA mode to begin with
   WiFi.mode(WIFI_STA);
+  esp_wifi_set_channel(CHANNEL, WIFI_SECOND_CHAN_NONE);
   Serial.println("ESPNow/Basic/Master Example");
   // This is the mac address of the Master in Station Mode
   Serial.print("STA MAC: "); Serial.println(WiFi.macAddress());
+  Serial.print("STA CHANNEL "); Serial.println(WiFi.channel());
   // Init ESPNow with a fallback logic
   InitESPNow();
   // Once ESPNow is successfully Init, we will register for Send CB to

libraries/ESP32/examples/DeepSleep/SmoothBlink_ULP_Code/.skip.esp32s2

@@ -57,6 +57,7 @@ void configDeviceAP() {
     Serial.println("AP Config failed.");
   } else {
     Serial.println("AP Config Success. Broadcasting with AP: " + String(SSID));
+    Serial.print("AP CHANNEL "); Serial.println(WiFi.channel());
   }
 }
 

libraries/ESP32/examples/DeepSleep/SmoothBlink_ULP_Code/.skip.esp32s3

@@ -50,7 +50,7 @@ Node RMakerClass::initNode(const char *name, const char *type)
 
 esp_err_t RMakerClass::start()
 {
-    err = esp_rmaker_start();    
+    err = esp_rmaker_start();
     if(err != ESP_OK){
         log_e("ESP RainMaker core task failed");
     }
@@ -106,6 +106,7 @@ esp_err_t RMakerClass::enableOTA(ota_type_t type, const char *cert)
 {
     esp_rmaker_ota_config_t ota_config;
     ota_config.server_cert = cert;
+    ota_config.ota_cb = NULL;
     err = esp_rmaker_ota_enable(&ota_config, type);
     if(err != ESP_OK) {
         log_e("OTA enable failed");

libraries/ESP32/examples/DeepSleep/SmoothBlink_ULP_Code/SmoothBlink_ULP_Code.ino

@@ -310,7 +310,21 @@ bool USBHID::ready(void){
     return tud_hid_n_ready(0);
 }
 
-void tud_hid_report_complete_cb(uint8_t instance, uint8_t const* report, uint8_t len){
+// TinyUSB is in the process of changing the type of the last argument to
+// tud_hid_report_complete_cb(), so extract the type from the version of TinyUSB that we're
+// compiled with.
+template <class F> struct ArgType;
+
+template <class R, class T1, class T2, class T3>
+struct ArgType<R(*)(T1, T2, T3)> {
+	typedef T1 type1;
+	typedef T2 type2;
+	typedef T3 type3;
+};
+
+typedef ArgType<decltype(&tud_hid_report_complete_cb)>::type3 tud_hid_report_complete_cb_len_t;
+
+void tud_hid_report_complete_cb(uint8_t instance, uint8_t const* report, tud_hid_report_complete_cb_len_t len){
     if (tinyusb_hid_device_input_sem) {
         xSemaphoreGive(tinyusb_hid_device_input_sem);
     }