Add ALPN support to WiFiClientSecure (#5633 )

This adds a function to WiFiClientSecure to set the ALPN protocol. This is required for an MQTT client to connect to AWS IoT when using an AWS Custom Authorizer, as described here. Example code snippet: ... WiFiClientSecure wiFiClient; // ALPN protocol, needed with AWS custom authorizer const char *aws_protos[] = {"mqtt", NULL}; void setup() { wiFiClient.setCACert(AWSCAPEM); wiFiClient.setAlpnProtocols(aws_protos); } ...
remove _user_defined_size from EEPROM (#5775 )
2021-10-25 09:20:47 +03:00 · 2021-10-25 09:15:47 +03:00 · 2021-10-25 09:13:48 +03:00 · 2021-10-25 09:12:37 +03:00 · 2021-10-24 13:01:05 +03:00 · 2021-10-23 11:34:00 -03:00
1730 changed files with 106856 additions and 54855 deletions
--- a/.github/workflows/test_selfhosted_runner.yml
+++ b/.github/workflows/test_selfhosted_runner.yml
@ -0,0 +1,27 @@
+name: Test Github action on self hosted RPI runnes
+
+on:
+  push:
+    branches:
+    - master
+  pull_request:
+
+jobs:
+  build:
+    name: Dummy test - self hosted GHR
+    runs-on: self-hosted
+    steps:
+      - name: Check out repo
+        uses: actions/checkout@v2
+      - name: Test message 1
+        run: echo "This is test message"
+      - name: Test message 2
+        run: echo "This is test message2"
+      - name: List directory
+        run: ls
+      - name: Create copy of README
+        run: cp README.md README2.md
+      - name: Read README2
+        run: cat README2.md
+      - name: Delete README2
+        run: rm README2.md
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -7,6 +7,7 @@ set(CORE_SRCS
  cores/esp32/esp32-hal-dac.c
  cores/esp32/esp32-hal-gpio.c
  cores/esp32/esp32-hal-i2c.c
+  cores/esp32/esp32-hal-i2c-slave.c
  cores/esp32/esp32-hal-ledc.c
  cores/esp32/esp32-hal-matrix.c
  cores/esp32/esp32-hal-misc.c
@ -174,7 +175,7 @@ set(includedirs
 set(srcs ${CORE_SRCS} ${LIBRARY_SRCS} ${BLE_SRCS})
 set(priv_includes cores/esp32/libb64)
 set(requires spi_flash mbedtls mdns esp_adc_cal wifi_provisioning nghttp)
-set(priv_requires fatfs nvs_flash app_update spiffs bootloader_support openssl bt esp_ipc)
+set(priv_requires fatfs nvs_flash app_update spiffs bootloader_support openssl bt esp_ipc esp_hid)

 idf_component_register(INCLUDE_DIRS ${includedirs} PRIV_INCLUDE_DIRS ${priv_includes} SRCS ${srcs} REQUIRES ${requires} PRIV_REQUIRES ${priv_requires})

--- a/README.md
+++ b/README.md
@ -43,7 +43,7 @@ You can use [Arduino-ESP32 Online Documentation](https://docs.espressif.com/proj
 You can use [EspExceptionDecoder](https://github.com/me-no-dev/EspExceptionDecoder) to get meaningful call trace.

 ### Issue/Bug report template
-Before reporting an issue, make sure you've searched for similar one that was already created. Also make sure to go through all the issues labelled as [for reference](https://github.com/espressif/arduino-esp32/issues?utf8=%E2%9C%93&q=is%3Aissue%20label%3A%22for%20reference%22%20).
+Before reporting an issue, make sure you've searched for similar one that was already created. Also make sure to go through all the issues labelled as [Type: For reference](https://github.com/espressif/arduino-esp32/issues?q=is%3Aissue+label%3A%22Type%3A+For+reference%22+).

 Finally, if you are sure no one else had the issue, follow the [issue template](docs/ISSUE_TEMPLATE.md) while reporting any issue.

--- a/boards.txt
+++ b/boards.txt
@ -57,13 +57,6 @@ esp32c3.menu.CDCOnBoot.default.build.cdc_on_boot=0
 esp32c3.menu.CDCOnBoot.cdc=Enabled
 esp32c3.menu.CDCOnBoot.cdc.build.cdc_on_boot=1

-esp32c3.menu.UploadMode.default=UART0
-esp32c3.menu.UploadMode.default.upload.use_1200bps_touch=false
-esp32c3.menu.UploadMode.default.upload.wait_for_upload_port=false
-esp32c3.menu.UploadMode.cdc=Internal USB
-esp32c3.menu.UploadMode.cdc.upload.use_1200bps_touch=true
-esp32c3.menu.UploadMode.cdc.upload.wait_for_upload_port=true
-
 esp32c3.menu.PartitionScheme.default=Default 4MB with spiffs (1.2MB APP/1.5MB SPIFFS)
 esp32c3.menu.PartitionScheme.default.build.partitions=default
 esp32c3.menu.PartitionScheme.defaultffat=Default 4MB with ffat (1.2MB APP/1.5MB FATFS)
@ -2071,6 +2064,122 @@ ttgo-t7-v14-mini32.menu.DebugLevel.verbose.build.code_debug=5

 ##############################################################

+ttgo-t-oi-plus.name=TTGO T-OI PLUS RISC-V ESP32-C3
+
+ttgo-t-oi-plus.upload.tool=esptool_py
+ttgo-t-oi-plus.upload.maximum_size=1310720
+ttgo-t-oi-plus.upload.maximum_data_size=327680
+ttgo-t-oi-plus.upload.flags=
+ttgo-t-oi-plus.upload.extra_flags=
+
+ttgo-t-oi-plus.serial.disableDTR=false
+ttgo-t-oi-plus.serial.disableRTS=false
+
+ttgo-t-oi-plus.build.tarch=riscv32
+ttgo-t-oi-plus.build.target=esp
+ttgo-t-oi-plus.build.mcu=esp32c3
+ttgo-t-oi-plus.build.core=esp32
+ttgo-t-oi-plus.build.variant=ttgo-t-oi-plus
+ttgo-t-oi-plus.build.board=TTGO-T-OI-PLUS_DEV
+ttgo-t-oi-plus.build.bootloader_addr=0x0
+
+ttgo-t-oi-plus.build.cdc_on_boot=0
+ttgo-t-oi-plus.build.f_cpu=160000000L
+ttgo-t-oi-plus.build.flash_size=4MB
+ttgo-t-oi-plus.build.flash_freq=80m
+ttgo-t-oi-plus.build.flash_mode=qio
+ttgo-t-oi-plus.build.boot=qio
+ttgo-t-oi-plus.build.partitions=default
+ttgo-t-oi-plus.build.defines=
+
+ttgo-t-oi-plus.menu.PartitionScheme.default=Default 4MB with spiffs (1.2MB APP/1.5MB SPIFFS)
+ttgo-t-oi-plus.menu.PartitionScheme.default.build.partitions=default
+ttgo-t-oi-plus.menu.PartitionScheme.defaultffat=Default 4MB with ffat (1.2MB APP/1.5MB FATFS)
+ttgo-t-oi-plus.menu.PartitionScheme.defaultffat.build.partitions=default_ffat
+ttgo-t-oi-plus.menu.PartitionScheme.minimal=Minimal (1.3MB APP/700KB SPIFFS)
+ttgo-t-oi-plus.menu.PartitionScheme.minimal.build.partitions=minimal
+ttgo-t-oi-plus.menu.PartitionScheme.no_ota=No OTA (2MB APP/2MB SPIFFS)
+ttgo-t-oi-plus.menu.PartitionScheme.no_ota.build.partitions=no_ota
+ttgo-t-oi-plus.menu.PartitionScheme.no_ota.upload.maximum_size=2097152
+ttgo-t-oi-plus.menu.PartitionScheme.noota_3g=No OTA (1MB APP/3MB SPIFFS)
+ttgo-t-oi-plus.menu.PartitionScheme.noota_3g.build.partitions=noota_3g
+ttgo-t-oi-plus.menu.PartitionScheme.noota_3g.upload.maximum_size=1048576
+ttgo-t-oi-plus.menu.PartitionScheme.noota_ffat=No OTA (2MB APP/2MB FATFS)
+ttgo-t-oi-plus.menu.PartitionScheme.noota_ffat.build.partitions=noota_ffat
+ttgo-t-oi-plus.menu.PartitionScheme.noota_ffat.upload.maximum_size=2097152
+ttgo-t-oi-plus.menu.PartitionScheme.noota_3gffat=No OTA (1MB APP/3MB FATFS)
+ttgo-t-oi-plus.menu.PartitionScheme.noota_3gffat.build.partitions=noota_3gffat
+ttgo-t-oi-plus.menu.PartitionScheme.noota_3gffat.upload.maximum_size=1048576
+ttgo-t-oi-plus.menu.PartitionScheme.huge_app=Huge APP (3MB No OTA/1MB SPIFFS)
+ttgo-t-oi-plus.menu.PartitionScheme.huge_app.build.partitions=huge_app
+ttgo-t-oi-plus.menu.PartitionScheme.huge_app.upload.maximum_size=3145728
+ttgo-t-oi-plus.menu.PartitionScheme.min_spiffs=Minimal SPIFFS (1.9MB APP with OTA/190KB SPIFFS)
+ttgo-t-oi-plus.menu.PartitionScheme.min_spiffs.build.partitions=min_spiffs
+ttgo-t-oi-plus.menu.PartitionScheme.min_spiffs.upload.maximum_size=1966080
+
+
+ttgo-t-oi-plus.menu.CPUFreq.160=160MHz (WiFi)
+ttgo-t-oi-plus.menu.CPUFreq.160.build.f_cpu=160000000L
+ttgo-t-oi-plus.menu.CPUFreq.80=80MHz (WiFi)
+ttgo-t-oi-plus.menu.CPUFreq.80.build.f_cpu=80000000L
+ttgo-t-oi-plus.menu.CPUFreq.40=40MHz
+ttgo-t-oi-plus.menu.CPUFreq.40.build.f_cpu=40000000L
+ttgo-t-oi-plus.menu.CPUFreq.20=20MHz
+ttgo-t-oi-plus.menu.CPUFreq.20.build.f_cpu=20000000L
+ttgo-t-oi-plus.menu.CPUFreq.10=10MHz
+ttgo-t-oi-plus.menu.CPUFreq.10.build.f_cpu=10000000L
+
+ttgo-t-oi-plus.menu.FlashMode.qio=QIO
+ttgo-t-oi-plus.menu.FlashMode.qio.build.flash_mode=dio
+ttgo-t-oi-plus.menu.FlashMode.qio.build.boot=qio
+ttgo-t-oi-plus.menu.FlashMode.dio=DIO
+ttgo-t-oi-plus.menu.FlashMode.dio.build.flash_mode=dio
+ttgo-t-oi-plus.menu.FlashMode.dio.build.boot=dio
+ttgo-t-oi-plus.menu.FlashMode.qout=QOUT
+ttgo-t-oi-plus.menu.FlashMode.qout.build.flash_mode=dout
+ttgo-t-oi-plus.menu.FlashMode.qout.build.boot=qout
+ttgo-t-oi-plus.menu.FlashMode.dout=DOUT
+ttgo-t-oi-plus.menu.FlashMode.dout.build.flash_mode=dout
+ttgo-t-oi-plus.menu.FlashMode.dout.build.boot=dout
+
+ttgo-t-oi-plus.menu.FlashFreq.80=80MHz
+ttgo-t-oi-plus.menu.FlashFreq.80.build.flash_freq=80m
+ttgo-t-oi-plus.menu.FlashFreq.40=40MHz
+ttgo-t-oi-plus.menu.FlashFreq.40.build.flash_freq=40m
+
+ttgo-t-oi-plus.menu.FlashSize.4M=4MB (32Mb)
+ttgo-t-oi-plus.menu.FlashSize.4M.build.flash_size=4MB
+
+ttgo-t-oi-plus.menu.UploadSpeed.921600=921600
+ttgo-t-oi-plus.menu.UploadSpeed.921600.upload.speed=921600
+ttgo-t-oi-plus.menu.UploadSpeed.115200=115200
+ttgo-t-oi-plus.menu.UploadSpeed.115200.upload.speed=115200
+ttgo-t-oi-plus.menu.UploadSpeed.256000.windows=256000
+ttgo-t-oi-plus.menu.UploadSpeed.256000.upload.speed=256000
+ttgo-t-oi-plus.menu.UploadSpeed.230400.windows.upload.speed=256000
+ttgo-t-oi-plus.menu.UploadSpeed.230400=230400
+ttgo-t-oi-plus.menu.UploadSpeed.230400.upload.speed=230400
+ttgo-t-oi-plus.menu.UploadSpeed.460800.linux=460800
+ttgo-t-oi-plus.menu.UploadSpeed.460800.macosx=460800
+ttgo-t-oi-plus.menu.UploadSpeed.460800.upload.speed=460800
+ttgo-t-oi-plus.menu.UploadSpeed.512000.windows=512000
+ttgo-t-oi-plus.menu.UploadSpeed.512000.upload.speed=512000
+
+ttgo-t-oi-plus.menu.DebugLevel.none=None
+ttgo-t-oi-plus.menu.DebugLevel.none.build.code_debug=0
+ttgo-t-oi-plus.menu.DebugLevel.error=Error
+ttgo-t-oi-plus.menu.DebugLevel.error.build.code_debug=1
+ttgo-t-oi-plus.menu.DebugLevel.warn=Warn
+ttgo-t-oi-plus.menu.DebugLevel.warn.build.code_debug=2
+ttgo-t-oi-plus.menu.DebugLevel.info=Info
+ttgo-t-oi-plus.menu.DebugLevel.info.build.code_debug=3
+ttgo-t-oi-plus.menu.DebugLevel.debug=Debug
+ttgo-t-oi-plus.menu.DebugLevel.debug.build.code_debug=4
+ttgo-t-oi-plus.menu.DebugLevel.verbose=Verbose
+ttgo-t-oi-plus.menu.DebugLevel.verbose.build.code_debug=5
+
+##############################################################
+
 cw02.name=XinaBox CW02

 cw02.upload.tool=esptool_py
@ -3801,6 +3910,13 @@ adafruit_metro_esp32s2.menu.DFUOnBoot.default.build.dfu_on_boot=0
 adafruit_metro_esp32s2.menu.DFUOnBoot.dfu=Enabled
 adafruit_metro_esp32s2.menu.DFUOnBoot.dfu.build.dfu_on_boot=1

+adafruit_metro_esp32s2.menu.UploadMode.cdc=Internal USB
+adafruit_metro_esp32s2.menu.UploadMode.cdc.upload.use_1200bps_touch=true
+adafruit_metro_esp32s2.menu.UploadMode.cdc.upload.wait_for_upload_port=true
+adafruit_metro_esp32s2.menu.UploadMode.default=UART0
+adafruit_metro_esp32s2.menu.UploadMode.default.upload.use_1200bps_touch=false
+adafruit_metro_esp32s2.menu.UploadMode.default.upload.wait_for_upload_port=false
+
 adafruit_metro_esp32s2.menu.PSRAM.enabled=Enabled
 adafruit_metro_esp32s2.menu.PSRAM.enabled.build.defines=-DBOARD_HAS_PSRAM
 adafruit_metro_esp32s2.menu.PSRAM.disabled=Disabled
@ -3915,11 +4031,11 @@ adafruit_metro_esp32s2.menu.DebugLevel.verbose.build.code_debug=5

 adafruit_magtag29_esp32s2.name=Adafruit MagTag 2.9"
 adafruit_magtag29_esp32s2.vid.0=0x239A
-adafruit_magtag29_esp32s2.pid.0=0x80DF
+adafruit_magtag29_esp32s2.pid.0=0x80E5
 adafruit_magtag29_esp32s2.vid.1=0x239A
-adafruit_magtag29_esp32s2.pid.1=0x00DF
+adafruit_magtag29_esp32s2.pid.1=0x00E5
 adafruit_magtag29_esp32s2.vid.1=0x239A
-adafruit_magtag29_esp32s2.pid.1=0x80E0
+adafruit_magtag29_esp32s2.pid.1=0x80E6

 adafruit_magtag29_esp32s2.upload.tool=esptool_py
 adafruit_magtag29_esp32s2.upload.maximum_size=1310720
@ -3966,6 +4082,13 @@ adafruit_magtag29_esp32s2.menu.DFUOnBoot.default.build.dfu_on_boot=0
 adafruit_magtag29_esp32s2.menu.DFUOnBoot.dfu=Enabled
 adafruit_magtag29_esp32s2.menu.DFUOnBoot.dfu.build.dfu_on_boot=1

+adafruit_magtag29_esp32s2.menu.UploadMode.cdc=Internal USB
+adafruit_magtag29_esp32s2.menu.UploadMode.cdc.upload.use_1200bps_touch=true
+adafruit_magtag29_esp32s2.menu.UploadMode.cdc.upload.wait_for_upload_port=true
+adafruit_magtag29_esp32s2.menu.UploadMode.default=UART0
+adafruit_magtag29_esp32s2.menu.UploadMode.default.upload.use_1200bps_touch=false
+adafruit_magtag29_esp32s2.menu.UploadMode.default.upload.wait_for_upload_port=false
+
 adafruit_magtag29_esp32s2.menu.PSRAM.enabled=Enabled
 adafruit_magtag29_esp32s2.menu.PSRAM.enabled.build.defines=-DBOARD_HAS_PSRAM
 adafruit_magtag29_esp32s2.menu.PSRAM.disabled=Disabled
@ -4131,6 +4254,13 @@ adafruit_funhouse_esp32s2.menu.DFUOnBoot.default.build.dfu_on_boot=0
 adafruit_funhouse_esp32s2.menu.DFUOnBoot.dfu=Enabled
 adafruit_funhouse_esp32s2.menu.DFUOnBoot.dfu.build.dfu_on_boot=1

+adafruit_funhouse_esp32s2.menu.UploadMode.cdc=Internal USB
+adafruit_funhouse_esp32s2.menu.UploadMode.cdc.upload.use_1200bps_touch=true
+adafruit_funhouse_esp32s2.menu.UploadMode.cdc.upload.wait_for_upload_port=true
+adafruit_funhouse_esp32s2.menu.UploadMode.default=UART0
+adafruit_funhouse_esp32s2.menu.UploadMode.default.upload.use_1200bps_touch=false
+adafruit_funhouse_esp32s2.menu.UploadMode.default.upload.wait_for_upload_port=false
+
 adafruit_funhouse_esp32s2.menu.PSRAM.enabled=Enabled
 adafruit_funhouse_esp32s2.menu.PSRAM.enabled.build.defines=-DBOARD_HAS_PSRAM
 adafruit_funhouse_esp32s2.menu.PSRAM.disabled=Disabled
@ -9386,19 +9516,32 @@ atmegazero_esp32s2.build.core=esp32
 atmegazero_esp32s2.build.variant=atmegazero_esp32s2
 atmegazero_esp32s2.build.board=atmegazero_esp32s2

+atmegazero_esp32s2.build.cdc_on_boot=1
+atmegazero_esp32s2.build.msc_on_boot=0
+atmegazero_esp32s2.build.dfu_on_boot=0
 atmegazero_esp32s2.build.serial=0
 atmegazero_esp32s2.build.f_cpu=240000000L
-atmegazero_esp32s2.build.flash_size=4MB
-atmegazero_esp32s2.build.flash_freq=80m
+atmegazero_esp32s2.build.flash_size=16MB
+atmegazero_esp32s2.build.flash_freq=40m
 atmegazero_esp32s2.build.flash_mode=qio
 atmegazero_esp32s2.build.boot=qio
 atmegazero_esp32s2.build.partitions=default
 atmegazero_esp32s2.build.defines=

-atmegazero_esp32s2.menu.SerialMode.cdc=USB CDC
-atmegazero_esp32s2.menu.SerialMode.cdc.build.serial=1
-atmegazero_esp32s2.menu.SerialMode.default=UART0
-atmegazero_esp32s2.menu.SerialMode.default.build.serial=0
+atmegazero_esp32s2.menu.CDCOnBoot.cdc=Enabled
+atmegazero_esp32s2.menu.CDCOnBoot.cdc.build.cdc_on_boot=1
+atmegazero_esp32s2.menu.CDCOnBoot.default=Disabled
+atmegazero_esp32s2.menu.CDCOnBoot.default.build.cdc_on_boot=0
+
+atmegazero_esp32s2.menu.MSCOnBoot.default=Disabled
+atmegazero_esp32s2.menu.MSCOnBoot.default.build.msc_on_boot=0
+atmegazero_esp32s2.menu.MSCOnBoot.msc=Enabled
+atmegazero_esp32s2.menu.MSCOnBoot.msc.build.msc_on_boot=1
+
+atmegazero_esp32s2.menu.DFUOnBoot.default=Disabled
+atmegazero_esp32s2.menu.DFUOnBoot.default.build.dfu_on_boot=0
+atmegazero_esp32s2.menu.DFUOnBoot.dfu=Enabled
+atmegazero_esp32s2.menu.DFUOnBoot.dfu.build.dfu_on_boot=1

 atmegazero_esp32s2.menu.PSRAM.disabled=Disabled
 atmegazero_esp32s2.menu.PSRAM.disabled.build.defines=
@ -9544,10 +9687,10 @@ deneyapmini.build.boot=qio
 deneyapmini.build.partitions=default
 deneyapmini.build.defines=

-deneyapmini.menu.SerialMode.default=USB_CDC
-deneyapmini.menu.SerialMode.default.build.serial=1
-deneyapmini.menu.SerialMode.uart=UART0
-deneyapmini.menu.SerialMode.uart.build.serial=0
+deneyapmini.menu.CDCOnBoot.default=Disabled
+deneyapmini.menu.CDCOnBoot.default.build.cdc_on_boot=0
+deneyapmini.menu.CDCOnBoot.cdc=Enabled
+deneyapmini.menu.CDCOnBoot.cdc.build.cdc_on_boot=1

 deneyapmini.menu.PSRAM.disabled=Disabled
 deneyapmini.menu.PSRAM.disabled.build.defines=
--- a/cores/esp32/Esp.cpp
+++ b/cores/esp32/Esp.cpp
@ -38,6 +38,7 @@ extern "C" {
 #define ESP_FLASH_IMAGE_BASE 0x1000     // Flash offset containing flash size and spi mode
 #elif CONFIG_IDF_TARGET_ESP32S2
 #include "esp32s2/rom/spi_flash.h"
+#include "soc/efuse_reg.h"
 #define ESP_FLASH_IMAGE_BASE 0x1000
 #elif CONFIG_IDF_TARGET_ESP32C3
 #include "esp32c3/rom/spi_flash.h"
@ -270,7 +271,17 @@ const char * EspClass::getChipModel(void)
            return "Unknown";
    }
 #elif CONFIG_IDF_TARGET_ESP32S2
+    uint32_t pkg_ver = REG_GET_FIELD(EFUSE_RD_MAC_SPI_SYS_3_REG, EFUSE_PKG_VERSION);
+    switch (pkg_ver) {
+    case 0:
      return "ESP32-S2";
+    case 1:
+      return "ESP32-S2FH16";
+    case 2:
+      return "ESP32-S2FH32";
+    default:
+      return "ESP32-S2 (Unknown)";
+    }
 #elif CONFIG_IDF_TARGET_ESP32S3
    return "ESP32-S3";
 #elif CONFIG_IDF_TARGET_ESP32C3
--- a/cores/esp32/FirmwareMSC.cpp
+++ b/cores/esp32/FirmwareMSC.cpp
@ -113,6 +113,7 @@ static size_t msc_update_get_required_disk_sectors(){
    log_d("USING FAT12");
    mcs_is_fat16 = false;
  }
+  log_d("FAT sector size: %u", DISK_SECTOR_SIZE);
  log_d("FAT data sectors: %u", data_sectors);
  log_d("FAT table sectors: %u", msc_table_sectors);
  log_d("FAT total sectors: %u (%uKB)", total_sectors, (total_sectors * DISK_SECTOR_SIZE) / 1024);
@ -227,7 +228,7 @@ static esp_err_t msc_update_write(const esp_partition_t *partition, uint32_t off
 //called when error was encountered while updating
 static void msc_update_error(){
  log_e("UPDATE_ERROR: %u", msc_update_bytes_written);
-  arduino_firmware_msc_event_data_t p = {0};
+  arduino_firmware_msc_event_data_t p;
  p.error.size = msc_update_bytes_written;
  arduino_usb_event_post(ARDUINO_FIRMWARE_MSC_EVENTS, ARDUINO_FIRMWARE_MSC_ERROR_EVENT, &p, sizeof(arduino_firmware_msc_event_data_t), portMAX_DELAY);
  msc_update_state = MSC_UPDATE_IDLE;
@ -251,7 +252,7 @@ static void msc_update_end(){
    msc_update_error();
    return;
  }
-  arduino_firmware_msc_event_data_t p = {0};
+  arduino_firmware_msc_event_data_t p;
  p.end.size = msc_update_entry->file_size;
  arduino_usb_event_post(ARDUINO_FIRMWARE_MSC_EVENTS, ARDUINO_FIRMWARE_MSC_END_EVENT, &p, sizeof(arduino_firmware_msc_event_data_t), portMAX_DELAY);
 }
@ -289,7 +290,7 @@ static int32_t msc_write(uint32_t lba, uint32_t offset, uint8_t* buffer, uint32_
    }
  } else if(msc_ota_partition && lba >= msc_update_start_sector){
    //handle writes to the region where the new firmware will be uploaded
-    arduino_firmware_msc_event_data_t p = {0};
+    arduino_firmware_msc_event_data_t p;
    if(msc_update_state <= MSC_UPDATE_STARTING && buffer[0] == 0xE9){
      msc_update_state = MSC_UPDATE_RUNNING;
      msc_update_start_sector = lba;
@ -345,7 +346,7 @@ static int32_t msc_read(uint32_t lba, uint32_t offset, void* buffer, uint32_t bu

 static bool msc_start_stop(uint8_t power_condition, bool start, bool load_eject){
  //log_d("power: %u, start: %u, eject: %u", power_condition, start, load_eject);
-  arduino_firmware_msc_event_data_t p = {0};
+  arduino_firmware_msc_event_data_t p;
  p.power.power_condition = power_condition;
  p.power.start = start;
  p.power.load_eject = load_eject;
--- a/cores/esp32/HWCDC.cpp
+++ b/cores/esp32/HWCDC.cpp
@ -24,15 +24,47 @@
 #include "soc/periph_defs.h"
 #include "hal/usb_serial_jtag_ll.h"

+ESP_EVENT_DEFINE_BASE(ARDUINO_HW_CDC_EVENTS);
+
 static RingbufHandle_t tx_ring_buf = NULL;
 static xQueueHandle rx_queue = NULL;
 static uint8_t rx_data_buf[64];
 static intr_handle_t intr_handle = NULL;
 static volatile bool initial_empty = false;
+static xSemaphoreHandle tx_lock = NULL;
+static uint32_t tx_timeout_ms = 200;
+static esp_event_loop_handle_t arduino_hw_cdc_event_loop_handle = NULL;
+
+static esp_err_t arduino_hw_cdc_event_post(esp_event_base_t event_base, int32_t event_id, void *event_data, size_t event_data_size, BaseType_t *task_unblocked){
+    if(arduino_hw_cdc_event_loop_handle == NULL){
+        return ESP_FAIL;
+    }
+    return esp_event_isr_post_to(arduino_hw_cdc_event_loop_handle, event_base, event_id, event_data, event_data_size, task_unblocked);
+}
+
+static esp_err_t arduino_hw_cdc_event_handler_register_with(esp_event_base_t event_base, int32_t event_id, esp_event_handler_t event_handler, void *event_handler_arg){
+    if (!arduino_hw_cdc_event_loop_handle) {
+        esp_event_loop_args_t event_task_args = {
+            .queue_size = 5,
+            .task_name = "arduino_hw_cdc_events",
+            .task_priority = 5,
+            .task_stack_size = 2048,
+            .task_core_id = tskNO_AFFINITY
+        };
+        if (esp_event_loop_create(&event_task_args, &arduino_hw_cdc_event_loop_handle) != ESP_OK) {
+            log_e("esp_event_loop_create failed");
+        }
+    }
+    if(arduino_hw_cdc_event_loop_handle == NULL){
+        return ESP_FAIL;
+    }
+    return esp_event_handler_register_with(arduino_hw_cdc_event_loop_handle, event_base, event_id, event_handler, event_handler_arg);
+}

 static void hw_cdc_isr_handler(void *arg) {
    portBASE_TYPE xTaskWoken = 0;
    uint32_t usbjtag_intr_status = 0;
+    arduino_hw_cdc_event_data_t event = {0};
    usbjtag_intr_status = usb_serial_jtag_ll_get_intsts_mask();

    if (usbjtag_intr_status & USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY) {
@ -45,6 +77,7 @@ static void hw_cdc_isr_handler(void *arg) {
                initial_empty = true;
                //send event?
                //ets_printf("CONNECTED\n");
+                arduino_hw_cdc_event_post(ARDUINO_HW_CDC_EVENTS, ARDUINO_HW_CDC_CONNECTED_EVENT, &event, sizeof(arduino_hw_cdc_event_data_t), &xTaskWoken);
            }
            size_t queued_size;
            uint8_t *queued_buff = (uint8_t *)xRingbufferReceiveUpToFromISR(tx_ring_buf, &queued_size, 64);
@ -58,6 +91,8 @@ static void hw_cdc_isr_handler(void *arg) {
                usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
                //send event?
                //ets_printf("TX:%u\n", queued_size);
+                event.tx.len = queued_size;
+                arduino_hw_cdc_event_post(ARDUINO_HW_CDC_EVENTS, ARDUINO_HW_CDC_TX_EVENT, &event, sizeof(arduino_hw_cdc_event_data_t), &xTaskWoken);
            }
        } else {
            usb_serial_jtag_ll_clr_intsts_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
@ -77,6 +112,8 @@ static void hw_cdc_isr_handler(void *arg) {
        }
        //send event?
        //ets_printf("RX:%u/%u\n", i, rx_fifo_len);
+        event.rx.len = i;
+        arduino_hw_cdc_event_post(ARDUINO_HW_CDC_EVENTS, ARDUINO_HW_CDC_RX_EVENT, &event, sizeof(arduino_hw_cdc_event_data_t), &xTaskWoken);
    }

    if (usbjtag_intr_status & USB_SERIAL_JTAG_INTR_BUS_RESET) {
@ -84,6 +121,7 @@ static void hw_cdc_isr_handler(void *arg) {
        initial_empty = false;
        usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
        //ets_printf("BUS_RESET\n");
+        arduino_hw_cdc_event_post(ARDUINO_HW_CDC_EVENTS, ARDUINO_HW_CDC_BUS_RESET_EVENT, &event, sizeof(arduino_hw_cdc_event_data_t), &xTaskWoken);
    }

    if (xTaskWoken == pdTRUE) {
@ -95,7 +133,7 @@ static void ARDUINO_ISR_ATTR cdc0_write_char(char c) {
    if(xPortInIsrContext()){
        xRingbufferSendFromISR(tx_ring_buf, (void*) (&c), 1, NULL);
    } else {
-        xRingbufferSend(tx_ring_buf, (void*) (&c), 1, 0);
+        xRingbufferSend(tx_ring_buf, (void*) (&c), 1, tx_timeout_ms / portTICK_PERIOD_MS);
    }
    usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
 }
@ -113,16 +151,28 @@ HWCDC::operator bool() const
    return initial_empty;
 }

+void HWCDC::onEvent(esp_event_handler_t callback){
+    onEvent(ARDUINO_HW_CDC_ANY_EVENT, callback);
+}
+
+void HWCDC::onEvent(arduino_hw_cdc_event_t event, esp_event_handler_t callback){
+    arduino_hw_cdc_event_handler_register_with(ARDUINO_HW_CDC_EVENTS, event, callback, this);
+}
+
 void HWCDC::begin(unsigned long baud)
 {
+    if(tx_lock == NULL) {
+        tx_lock = xSemaphoreCreateMutex();
+    }
    setRxBufferSize(256);//default if not preset
    setTxBufferSize(256);//default if not preset

    usb_serial_jtag_ll_clr_intsts_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY | USB_SERIAL_JTAG_INTR_SERIAL_OUT_RECV_PKT | USB_SERIAL_JTAG_INTR_BUS_RESET);
    usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY | USB_SERIAL_JTAG_INTR_SERIAL_OUT_RECV_PKT | USB_SERIAL_JTAG_INTR_BUS_RESET);
-    if(!intr_handle && esp_intr_alloc(ETS_USB_INTR_SOURCE/*ETS_USB_SERIAL_JTAG_INTR_SOURCE*/, 0, hw_cdc_isr_handler, NULL, &intr_handle) != ESP_OK){
+    if(!intr_handle && esp_intr_alloc(ETS_USB_SERIAL_JTAG_INTR_SOURCE, 0, hw_cdc_isr_handler, NULL, &intr_handle) != ESP_OK){
        isr_log_e("HW USB CDC failed to init interrupts");
        end();
+        return;
    }
 }

@ -132,8 +182,19 @@ void HWCDC::end()
    usb_serial_jtag_ll_disable_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY | USB_SERIAL_JTAG_INTR_SERIAL_OUT_RECV_PKT | USB_SERIAL_JTAG_INTR_BUS_RESET);
    esp_intr_free(intr_handle);
    intr_handle = NULL;
+    if(tx_lock != NULL) {
+        vSemaphoreDelete(tx_lock);
+    }
    setRxBufferSize(0);
    setTxBufferSize(0);
+    if (arduino_hw_cdc_event_loop_handle) {
+        esp_event_loop_delete(arduino_hw_cdc_event_loop_handle);
+        arduino_hw_cdc_event_loop_handle = NULL;
+    }
+}
+
+void HWCDC::setTxTimeoutMs(uint32_t timeout){
+    tx_timeout_ms = timeout;
 }

 /*
@ -157,21 +218,57 @@ size_t HWCDC::setTxBufferSize(size_t tx_queue_len){

 int HWCDC::availableForWrite(void)
 {
-    if(tx_ring_buf == NULL){
-        return -1;
+    if(tx_ring_buf == NULL || tx_lock == NULL){
+        return 0;
    }
-    return xRingbufferGetCurFreeSize(tx_ring_buf);
+    if(xSemaphoreTake(tx_lock, tx_timeout_ms / portTICK_PERIOD_MS) != pdPASS){
+        return 0;
+    }
+    size_t a = xRingbufferGetCurFreeSize(tx_ring_buf);
+    xSemaphoreGive(tx_lock);
+    return a;
 }

 size_t HWCDC::write(const uint8_t *buffer, size_t size)
 {
-    // Blocking method, Sending data to ringbuffer, and handle the data in ISR.
-    if(xRingbufferSend(tx_ring_buf, (void*) (buffer), size, 200 / portTICK_PERIOD_MS) != pdTRUE){
-        log_e("Write Failed");
+    if(buffer == NULL || size == 0 || tx_ring_buf == NULL || tx_lock == NULL){
        return 0;
    }
+    if(xSemaphoreTake(tx_lock, tx_timeout_ms / portTICK_PERIOD_MS) != pdPASS){
+        return 0;
+    }
+    size_t max_size = xRingbufferGetMaxItemSize(tx_ring_buf);
+    size_t space = xRingbufferGetCurFreeSize(tx_ring_buf);
+    size_t to_send = size, so_far = 0;
+
+    if(space > size){
+        space = size;
+    }
+    // Non-Blocking method, Sending data to ringbuffer, and handle the data in ISR.
+    if(xRingbufferSend(tx_ring_buf, (void*) (buffer), space, 0) != pdTRUE){
+        size = 0;
+    } else {
+        to_send -= space;
+        so_far += space;
        // Now trigger the ISR to read data from the ring buffer.
        usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
+
+        while(to_send){
+            if(max_size > to_send){
+                max_size = to_send;
+            }
+            // Blocking method, Sending data to ringbuffer, and handle the data in ISR.
+            if(xRingbufferSend(tx_ring_buf, (void*) (buffer+so_far), max_size, tx_timeout_ms / portTICK_PERIOD_MS) != pdTRUE){
+                size = so_far;
+                break;
+            }
+            so_far += max_size;
+            to_send -= max_size;
+            // Now trigger the ISR to read data from the ring buffer.
+            usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
+        }
+    }
+    xSemaphoreGive(tx_lock);
    return size;
 }

@ -182,15 +279,23 @@ size_t HWCDC::write(uint8_t c)

 void HWCDC::flush(void)
 {
-    if(tx_ring_buf == NULL){
+    if(tx_ring_buf == NULL || tx_lock == NULL){
+        return;
+    }
+    if(xSemaphoreTake(tx_lock, tx_timeout_ms / portTICK_PERIOD_MS) != pdPASS){
        return;
    }
    UBaseType_t uxItemsWaiting = 0;
    vRingbufferGetInfo(tx_ring_buf, NULL, NULL, NULL, NULL, &uxItemsWaiting);
+    if(uxItemsWaiting){
+        // Now trigger the ISR to read data from the ring buffer.
+        usb_serial_jtag_ll_ena_intr_mask(USB_SERIAL_JTAG_INTR_SERIAL_IN_EMPTY);
+    }
    while(uxItemsWaiting){
        delay(5);
        vRingbufferGetInfo(tx_ring_buf, NULL, NULL, NULL, NULL, &uxItemsWaiting);
    }
+    xSemaphoreGive(tx_lock);
 }

 /*
--- a/cores/esp32/HWCDC.h
+++ b/cores/esp32/HWCDC.h
@ -17,16 +17,41 @@
 #if CONFIG_IDF_TARGET_ESP32C3

 #include <inttypes.h>
+#include "esp_event.h"
 #include "Stream.h"

+ESP_EVENT_DECLARE_BASE(ARDUINO_HW_CDC_EVENTS);
+
+typedef enum {
+    ARDUINO_HW_CDC_ANY_EVENT = ESP_EVENT_ANY_ID,
+    ARDUINO_HW_CDC_CONNECTED_EVENT = 0,
+    ARDUINO_HW_CDC_BUS_RESET_EVENT,
+    ARDUINO_HW_CDC_RX_EVENT,
+    ARDUINO_HW_CDC_TX_EVENT,
+    ARDUINO_HW_CDC_MAX_EVENT,
+} arduino_hw_cdc_event_t;
+
+typedef union {
+    struct {
+            size_t len;
+    } rx;
+    struct {
+            size_t len;
+    } tx;
+} arduino_hw_cdc_event_data_t;
+
 class HWCDC: public Stream
 {
 public:
    HWCDC();
    ~HWCDC();

+    void onEvent(esp_event_handler_t callback);
+    void onEvent(arduino_hw_cdc_event_t event, esp_event_handler_t callback);
+
    size_t setRxBufferSize(size_t);
    size_t setTxBufferSize(size_t);
+    void setTxTimeoutMs(uint32_t timeout);
    void begin(unsigned long baud=0);
    void end();
    
--- a/cores/esp32/HardwareSerial.cpp
+++ b/cores/esp32/HardwareSerial.cpp
@ -87,7 +87,6 @@ HardwareSerial Serial1(1);
 #if SOC_UART_NUM > 2
 HardwareSerial Serial2(2);
 #endif
-#endif

 void serialEventRun(void)
 {
@ -105,6 +104,7 @@ void serialEventRun(void)
    if(Serial2.available()) serialEvent2();
 #endif
 }
+#endif


 HardwareSerial::HardwareSerial(int uart_nr) : _uart_nr(uart_nr), _uart(NULL), _rxBufferSize(256) {}
--- a/cores/esp32/USB.cpp
+++ b/cores/esp32/USB.cpp
@ -15,6 +15,7 @@

 #if CONFIG_TINYUSB_ENABLED

+#include "pins_arduino.h"
 #include "esp32-hal.h"
 #include "esp32-hal-tinyusb.h"
 #include "common/tusb_common.h"
@ -85,14 +86,14 @@ static bool tinyusb_device_suspended = false;
 // Invoked when device is mounted (configured)
 void tud_mount_cb(void){
    tinyusb_device_mounted = true;
-    arduino_usb_event_data_t p = {0};
+    arduino_usb_event_data_t p;
    arduino_usb_event_post(ARDUINO_USB_EVENTS, ARDUINO_USB_STARTED_EVENT, &p, sizeof(arduino_usb_event_data_t), portMAX_DELAY);
 }

 // Invoked when device is unmounted
 void tud_umount_cb(void){
    tinyusb_device_mounted = false;
-    arduino_usb_event_data_t p = {0};
+    arduino_usb_event_data_t p;
    arduino_usb_event_post(ARDUINO_USB_EVENTS, ARDUINO_USB_STOPPED_EVENT, &p, sizeof(arduino_usb_event_data_t), portMAX_DELAY);
 }

@ -100,7 +101,7 @@ void tud_umount_cb(void){
 // Within 7ms, device must draw an average of current less than 2.5 mA from bus
 void tud_suspend_cb(bool remote_wakeup_en){
    tinyusb_device_suspended = true;
-    arduino_usb_event_data_t p = {0};
+    arduino_usb_event_data_t p;
    p.suspend.remote_wakeup_en = remote_wakeup_en;
    arduino_usb_event_post(ARDUINO_USB_EVENTS, ARDUINO_USB_SUSPEND_EVENT, &p, sizeof(arduino_usb_event_data_t), portMAX_DELAY);
 }
@ -108,7 +109,7 @@ void tud_suspend_cb(bool remote_wakeup_en){
 // Invoked when usb bus is resumed
 void tud_resume_cb(void){
    tinyusb_device_suspended = false;
-    arduino_usb_event_data_t p = {0};
+    arduino_usb_event_data_t p;
    arduino_usb_event_post(ARDUINO_USB_EVENTS, ARDUINO_USB_RESUME_EVENT, &p, sizeof(arduino_usb_event_data_t), portMAX_DELAY);
 }

--- a/cores/esp32/USBCDC.cpp
+++ b/cores/esp32/USBCDC.cpp
@ -62,63 +62,40 @@ void tud_cdc_rx_cb(uint8_t itf)

 // Invoked when received send break
 void tud_cdc_send_break_cb(uint8_t itf, uint16_t duration_ms){
-    //isr_log_v("itf: %u, duration_ms: %u", itf, duration_ms);
+    //log_v("itf: %u, duration_ms: %u", itf, duration_ms);
 }

 // Invoked when space becomes available in TX buffer
 void tud_cdc_tx_complete_cb(uint8_t itf){
-    if(itf < MAX_USB_CDC_DEVICES && devices[itf] != NULL && devices[itf]->tx_sem != NULL){
-        xSemaphoreGive(devices[itf]->tx_sem);
+    if(itf < MAX_USB_CDC_DEVICES && devices[itf] != NULL){
        devices[itf]->_onTX();
    }
 }

-static size_t tinyusb_cdc_write(uint8_t itf, const uint8_t *buffer, size_t size){
-    if(itf >= MAX_USB_CDC_DEVICES || devices[itf] == NULL || devices[itf]->tx_sem == NULL){
-        return 0;
+static void ARDUINO_ISR_ATTR cdc0_write_char(char c){
+    if(devices[0] != NULL){
+        devices[0]->write(c);
    }
-    if(!tud_cdc_n_connected(itf)){
-        return 0;
-    }
-    size_t tosend = size, sofar = 0;
-    while(tosend){
-        uint32_t space = tud_cdc_n_write_available(itf);
-        if(!space){
-            //make sure that we do not get previous semaphore
-            xSemaphoreTake(devices[itf]->tx_sem, 0);
-            //wait for tx_complete
-            if(xSemaphoreTake(devices[itf]->tx_sem, 200 / portTICK_PERIOD_MS) == pdTRUE){
-                space = tud_cdc_n_write_available(itf);
-            }
-            if(!space){
-                return sofar;
-            }
-        }
-        if(tosend < space){
-            space = tosend;
-        }
-        uint32_t sent = tud_cdc_n_write(itf, buffer + sofar, space);
-        if(!sent){
-            return sofar;
-        }
-        sofar += sent;
-        tosend -= sent;
-        tud_cdc_n_write_flush(itf);
-        //xSemaphoreTake(devices[itf]->tx_sem, portMAX_DELAY);
-    }
-    return sofar;
-}
-
-static void ARDUINO_ISR_ATTR cdc0_write_char(char c)
-{
-    tinyusb_cdc_write(0, (const uint8_t *)&c, 1);
 }

 static void usb_unplugged_cb(void* arg, esp_event_base_t event_base, int32_t event_id, void* event_data){
    ((USBCDC*)arg)->_onUnplugged();
 }

-USBCDC::USBCDC(uint8_t itfn) : itf(itfn), bit_rate(0), stop_bits(0), parity(0), data_bits(0), dtr(false),  rts(false), connected(false), reboot_enable(true), rx_queue(NULL), tx_sem(NULL) {
+USBCDC::USBCDC(uint8_t itfn) 
+: itf(itfn)
+, bit_rate(0)
+, stop_bits(0)
+, parity(0)
+, data_bits(0)
+, dtr(false)
+, rts(false)
+, connected(false)
+, reboot_enable(true)
+, rx_queue(NULL)
+, tx_lock(NULL)
+, tx_timeout_ms(250)
+{
    tinyusb_enable_interface(USB_INTERFACE_CDC, TUD_CDC_DESC_LEN, load_cdc_descriptor);
    if(itf < MAX_USB_CDC_DEVICES){
        arduino_usb_event_handler_register_with(ARDUINO_USB_EVENTS, ARDUINO_USB_STOPPED_EVENT, usb_unplugged_cb, this);
@ -153,9 +130,8 @@ size_t USBCDC::setRxBufferSize(size_t rx_queue_len){

 void USBCDC::begin(unsigned long baud)
 {
-    if(tx_sem == NULL){
-        tx_sem = xSemaphoreCreateBinary();
-        xSemaphoreTake(tx_sem, 0);
+    if(tx_lock == NULL) {
+        tx_lock = xSemaphoreCreateMutex();
    }
    setRxBufferSize(256);//default if not preset
    devices[itf] = this;
@ -166,18 +142,21 @@ void USBCDC::end()
    connected = false;
    devices[itf] = NULL;
    setRxBufferSize(0);
-    if (tx_sem != NULL) {
-        vSemaphoreDelete(tx_sem);
-        tx_sem = NULL;
+    if(tx_lock != NULL) {
+        vSemaphoreDelete(tx_lock);
    }
 }

+void USBCDC::setTxTimeoutMs(uint32_t timeout){
+    tx_timeout_ms = timeout;
+}
+
 void USBCDC::_onUnplugged(void){
    if(connected){
        connected = false;
        dtr = false;
        rts = false;
-        arduino_usb_cdc_event_data_t p = {0};
+        arduino_usb_cdc_event_data_t p;
        arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_DISCONNECTED_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
    }
 }
@ -199,7 +178,7 @@ void USBCDC::_onLineState(bool _dtr, bool _rts){
                lineState++;
                if(connected){
                    connected = false;
-                    arduino_usb_cdc_event_data_t p = {0};
+                    arduino_usb_cdc_event_data_t p;
                    arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_DISCONNECTED_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
                }
            } else {
@ -229,14 +208,14 @@ void USBCDC::_onLineState(bool _dtr, bool _rts){
    if(lineState == CDC_LINE_IDLE){
        if(dtr && rts && !connected){
            connected = true;
-            arduino_usb_cdc_event_data_t p = {0};
+            arduino_usb_cdc_event_data_t p;
            arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_CONNECTED_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
        } else if(!dtr && connected){
            connected = false;
-            arduino_usb_cdc_event_data_t p = {0};
+            arduino_usb_cdc_event_data_t p;
            arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_DISCONNECTED_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
        }
-        arduino_usb_cdc_event_data_t l = {0};
+        arduino_usb_cdc_event_data_t l;
        l.line_state.dtr = dtr;
        l.line_state.rts = rts;
        arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_LINE_STATE_EVENT, &l, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
@ -254,7 +233,7 @@ void USBCDC::_onLineCoding(uint32_t _bit_rate, uint8_t _stop_bits, uint8_t _pari
            data_bits = _data_bits;
            stop_bits = _stop_bits;
            parity = _parity;
-            arduino_usb_cdc_event_data_t p = {0};
+            arduino_usb_cdc_event_data_t p;
            p.line_coding.bit_rate = bit_rate;
            p.line_coding.data_bits = data_bits;
            p.line_coding.stop_bits = stop_bits;
@ -272,13 +251,13 @@ void USBCDC::_onRX(){
            return;
        }
    }
-    arduino_usb_cdc_event_data_t p = {0};
+    arduino_usb_cdc_event_data_t p;
    p.rx.len = count;
    arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_RX_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
 }

 void USBCDC::_onTX(){
-    arduino_usb_cdc_event_data_t p = {0};
+    arduino_usb_cdc_event_data_t p;
    arduino_usb_event_post(ARDUINO_USB_CDC_EVENTS, ARDUINO_USB_CDC_TX_EVENT, &p, sizeof(arduino_usb_cdc_event_data_t), portMAX_DELAY);
 }

@ -336,23 +315,73 @@ size_t USBCDC::read(uint8_t *buffer, size_t size)

 void USBCDC::flush(void)
 {
-    if(itf >= MAX_USB_CDC_DEVICES || tx_sem == NULL){
+    if(itf >= MAX_USB_CDC_DEVICES || tx_lock == NULL || !tud_cdc_n_connected(itf)){
+        return;
+    }
+    if(xSemaphoreTake(tx_lock, tx_timeout_ms / portTICK_PERIOD_MS) != pdPASS){
        return;
    }
    tud_cdc_n_write_flush(itf);
+    xSemaphoreGive(tx_lock);
 }

 int USBCDC::availableForWrite(void)
 {
-    if(itf >= MAX_USB_CDC_DEVICES || tx_sem == NULL){
-        return -1;
+    if(itf >= MAX_USB_CDC_DEVICES || tx_lock == NULL || !tud_cdc_n_connected(itf)){
+        return 0;
    }
-    return tud_cdc_n_write_available(itf);
+    if(xSemaphoreTake(tx_lock, tx_timeout_ms / portTICK_PERIOD_MS) != pdPASS){
+        return 0;
+    }
+    size_t a = tud_cdc_n_write_available(itf);
+    xSemaphoreGive(tx_lock);
+    return a;
 }

 size_t USBCDC::write(const uint8_t *buffer, size_t size)
 {
-    return tinyusb_cdc_write(itf, buffer, size);
+    if(itf >= MAX_USB_CDC_DEVICES || tx_lock == NULL || buffer == NULL || size == 0 || !tud_cdc_n_connected(itf)){
+        return 0;
+    }
+    if(xPortInIsrContext()){
+        BaseType_t taskWoken = false;
+        if(xSemaphoreTakeFromISR(tx_lock, &taskWoken) != pdPASS){
+            return 0;
+        }
+    } else if(xSemaphoreTake(tx_lock, tx_timeout_ms / portTICK_PERIOD_MS) != pdPASS){
+        return 0;
+    }
+    size_t to_send = size, so_far = 0;
+    while(to_send){
+        if(!tud_cdc_n_connected(itf)){
+            size = so_far;
+            break;
+        }
+        size_t space = tud_cdc_n_write_available(itf);
+        if(!space){
+            tud_cdc_n_write_flush(itf);
+            continue;
+        }
+        if(space > to_send){
+            space = to_send;
+        }
+        size_t sent = tud_cdc_n_write(itf, buffer+so_far, space);
+        if(sent){
+            so_far += sent;
+            to_send -= sent;
+            tud_cdc_n_write_flush(itf);
+        } else {
+            size = so_far;
+            break;
+        }
+    }
+    if(xPortInIsrContext()){
+        BaseType_t taskWoken = false;
+        xSemaphoreGiveFromISR(tx_lock, &taskWoken);
+    } else {
+        xSemaphoreGive(tx_lock);
+    }
+    return size;
 }

 size_t USBCDC::write(uint8_t c)
--- a/cores/esp32/USBCDC.h
+++ b/cores/esp32/USBCDC.h
@ -18,6 +18,9 @@

 #include <inttypes.h>
 #include "esp_event.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/queue.h"
+#include "freertos/semphr.h"
 #include "Stream.h"

 ESP_EVENT_DECLARE_BASE(ARDUINO_USB_CDC_EVENTS);
@ -58,7 +61,8 @@ public:
    void onEvent(esp_event_handler_t callback);
    void onEvent(arduino_usb_cdc_event_t event, esp_event_handler_t callback);

-    size_t setRxBufferSize(size_t);
+    size_t setRxBufferSize(size_t size);
+    void setTxTimeoutMs(uint32_t timeout);
    void begin(unsigned long baud=0);
    void end();
    
@ -113,7 +117,6 @@ public:
    void _onRX(void);
    void _onTX(void);
    void _onUnplugged(void);
-    xSemaphoreHandle tx_sem;
    
 protected:
    uint8_t  itf;
@ -126,6 +129,8 @@ protected:
    bool     connected;
    bool     reboot_enable;
    xQueueHandle rx_queue;
+    xSemaphoreHandle tx_lock;
+    uint32_t tx_timeout_ms;
    
 };

--- a/cores/esp32/esp32-hal-adc.c
+++ b/cores/esp32/esp32-hal-adc.c
@ -46,10 +46,23 @@ static uint8_t __analogVRefPin = 0;
 #endif

 static uint8_t __analogAttenuation = 3;//11db
-static uint8_t __analogWidth = 3;//12 bits
+static uint8_t __analogWidth = ADC_WIDTH_MAX - 1; //3 for ESP32/ESP32C3; 4 for ESP32S2
+static uint8_t __analogReturnedWidth = SOC_ADC_MAX_BITWIDTH; //12 for ESP32/ESP32C3; 13 for ESP32S2
 static uint8_t __analogClockDiv = 1;
 static adc_attenuation_t __pin_attenuation[SOC_GPIO_PIN_COUNT];

+static inline uint16_t mapResolution(uint16_t value)
+{
+    uint8_t from = __analogWidth + 9;
+    if (from == __analogReturnedWidth) {
+        return value;
+    }
+    if (from > __analogReturnedWidth) {
+        return value >> (from  - __analogReturnedWidth);
+    }
+    return value << (__analogReturnedWidth - from);
+}
+
 void __analogSetClockDiv(uint8_t clockDiv){
    if(!clockDiv){
        clockDiv = 1;
@ -146,6 +159,7 @@ void __analogReadResolution(uint8_t bits)
    if(!bits || bits > 16){
        return;
    }
+    __analogReturnedWidth = bits;
 #if CONFIG_IDF_TARGET_ESP32
    __analogSetWidth(bits);         // hadware from 9 to 12
 #endif
@ -165,7 +179,7 @@ uint16_t __analogRead(uint8_t pin)
        channel -= 10;
        r = adc2_get_raw( channel, __analogWidth, &value);
        if ( r == ESP_OK ) {
-            return value;
+            return mapResolution(value);
        } else if ( r == ESP_ERR_INVALID_STATE ) {
            log_e("GPIO%u: %s: ADC2 not initialized yet.", pin, esp_err_to_name(r));
        } else if ( r == ESP_ERR_TIMEOUT ) {
@ -174,9 +188,10 @@ uint16_t __analogRead(uint8_t pin)
            log_e("GPIO%u: %s", pin, esp_err_to_name(r));
        }
    } else {
-        return adc1_get_raw(channel);
+        value = adc1_get_raw(channel);
+        return mapResolution(value);
    }
-    return value;
+    return mapResolution(value);
 }

 uint32_t __analogReadMilliVolts(uint8_t pin){
--- a/cores/esp32/esp32-hal-i2c-slave.c
+++ b/cores/esp32/esp32-hal-i2c-slave.c
@ -0,0 +1,848 @@
+// Copyright 2015-2021 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <stdint.h>
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <inttypes.h>
+#include <string.h>
+#include <math.h>
+
+#include "sdkconfig.h"
+#include "esp_attr.h"
+#include "rom/gpio.h"
+#include "soc/gpio_sig_map.h"
+#include "hal/gpio_types.h"
+#include "driver/gpio.h"
+#include "esp_err.h"
+
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/queue.h"
+#include "freertos/semphr.h"
+#include "freertos/ringbuf.h"
+
+#include "esp_intr_alloc.h"
+#include "driver/periph_ctrl.h"
+#include "soc/i2c_reg.h"
+#include "soc/i2c_struct.h"
+#include "hal/i2c_ll.h"
+#include "esp32-hal-log.h"
+#include "esp32-hal-i2c-slave.h"
+
+#define I2C_SLAVE_USE_RX_QUEUE 0 // 1: Queue, 0: RingBuffer
+
+#if SOC_I2C_NUM > 1
+#define I2C_SCL_IDX(p)  ((p==0)?I2CEXT0_SCL_OUT_IDX:((p==1)?I2CEXT1_SCL_OUT_IDX:0))
+#define I2C_SDA_IDX(p) ((p==0)?I2CEXT0_SDA_OUT_IDX:((p==1)?I2CEXT1_SDA_OUT_IDX:0))
+#else
+#define I2C_SCL_IDX(p)  I2CEXT0_SCL_OUT_IDX
+#define I2C_SDA_IDX(p) I2CEXT0_SDA_OUT_IDX
+#endif
+
+#if CONFIG_IDF_TARGET_ESP32
+    #define I2C_TXFIFO_WM_INT_ENA    I2C_TXFIFO_EMPTY_INT_ENA
+    #define I2C_RXFIFO_WM_INT_ENA     I2C_RXFIFO_FULL_INT_ENA
+#endif
+
+enum {
+    I2C_SLAVE_EVT_RX, I2C_SLAVE_EVT_TX
+};
+
+typedef struct i2c_slave_struct_t {
+    i2c_dev_t * dev;
+    uint8_t num;
+    int8_t sda;
+    int8_t scl;
+    i2c_slave_request_cb_t request_callback;
+    i2c_slave_receive_cb_t receive_callback;
+    void * arg;
+    intr_handle_t intr_handle;
+    TaskHandle_t task_handle;
+    xQueueHandle event_queue;
+#if I2C_SLAVE_USE_RX_QUEUE
+    xQueueHandle rx_queue;
+#else
+    RingbufHandle_t rx_ring_buf;
+#endif
+    xQueueHandle tx_queue;
+    uint32_t rx_data_count;
+#if !CONFIG_DISABLE_HAL_LOCKS
+    xSemaphoreHandle lock;
+#endif
+} i2c_slave_struct_t;
+
+typedef union {
+    struct {
+        uint32_t event : 2;
+        uint32_t stop : 1;
+        uint32_t param : 29;
+    };
+    uint32_t val;
+} i2c_slave_queue_event_t;
+
+static i2c_slave_struct_t _i2c_bus_array[SOC_I2C_NUM] = {
+    { &I2C0, 0, -1, -1, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0
+#if !CONFIG_DISABLE_HAL_LOCKS
+    , NULL
+#endif
+    },
+#if SOC_I2C_NUM > 1
+    { &I2C1, 1, -1, -1, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, 0
+#if !CONFIG_DISABLE_HAL_LOCKS
+    , NULL
+#endif
+    }
+#endif
+};
+
+#if CONFIG_DISABLE_HAL_LOCKS
+#define I2C_SLAVE_MUTEX_LOCK()
+#define I2C_SLAVE_MUTEX_UNLOCK()
+#else
+#define I2C_SLAVE_MUTEX_LOCK()    if(i2c->lock){xSemaphoreTake(i2c->lock, portMAX_DELAY);}
+#define I2C_SLAVE_MUTEX_UNLOCK()  if(i2c->lock){xSemaphoreGive(i2c->lock);}
+#endif
+
+//-------------------------------------- HAL_LL (Missing Functions) ------------------------------------------------
+typedef enum {
+    I2C_STRETCH_CAUSE_MASTER_READ,
+    I2C_STRETCH_CAUSE_TX_FIFO_EMPTY,
+    I2C_STRETCH_CAUSE_RX_FIFO_FULL,
+    I2C_STRETCH_CAUSE_MAX
+} i2c_stretch_cause_t;
+
+static inline i2c_stretch_cause_t i2c_ll_stretch_cause(i2c_dev_t *hw)
+{
+#if CONFIG_IDF_TARGET_ESP32C3
+    return hw->sr.stretch_cause;
+#elif CONFIG_IDF_TARGET_ESP32S2
+    return hw->status_reg.stretch_cause;
+#else
+    return I2C_STRETCH_CAUSE_MAX;
+#endif
+}
+
+static inline void i2c_ll_set_stretch(i2c_dev_t *hw, uint16_t time)
+{
+#ifndef CONFIG_IDF_TARGET_ESP32
+    typeof(hw->scl_stretch_conf) scl_stretch_conf;
+    scl_stretch_conf.val = 0;
+    scl_stretch_conf.slave_scl_stretch_en = (time > 0);
+    scl_stretch_conf.stretch_protect_num = time;
+    scl_stretch_conf.slave_scl_stretch_clr = 1;
+    hw->scl_stretch_conf.val = scl_stretch_conf.val;
+    if(time > 0){
+        //enable interrupt
+        hw->int_ena.val |= I2C_SLAVE_STRETCH_INT_ENA;
+    } else {
+        //disable interrupt
+        hw->int_ena.val &= (~I2C_SLAVE_STRETCH_INT_ENA);
+    }
+#endif
+}
+
+static inline void i2c_ll_stretch_clr(i2c_dev_t *hw)
+{
+#ifndef CONFIG_IDF_TARGET_ESP32
+    hw->scl_stretch_conf.slave_scl_stretch_clr = 1;
+#endif
+}
+
+static inline bool i2c_ll_slave_addressed(i2c_dev_t *hw)
+{
+#if CONFIG_IDF_TARGET_ESP32C3
+    return hw->sr.slave_addressed;
+#else
+    return hw->status_reg.slave_addressed;
+#endif
+}
+
+static inline bool i2c_ll_slave_rw(i2c_dev_t *hw)//not exposed by hal_ll
+{
+#if CONFIG_IDF_TARGET_ESP32C3
+    return hw->sr.slave_rw;
+#else
+    return hw->status_reg.slave_rw;
+#endif
+}
+
+//-------------------------------------- PRIVATE (Function Prototypes) ------------------------------------------------
+static void i2c_slave_free_resources(i2c_slave_struct_t * i2c);
+static void i2c_slave_delay_us(uint64_t us);
+static void i2c_slave_gpio_mode(int8_t pin, gpio_mode_t mode);
+static bool i2c_slave_check_line_state(int8_t sda, int8_t scl);
+static bool i2c_slave_attach_gpio(i2c_slave_struct_t * i2c, int8_t sda, int8_t scl);
+static bool i2c_slave_detach_gpio(i2c_slave_struct_t * i2c);
+static bool i2c_slave_set_frequency(i2c_slave_struct_t * i2c, uint32_t clk_speed);
+static bool i2c_slave_send_event(i2c_slave_struct_t * i2c, i2c_slave_queue_event_t* event);
+static bool i2c_slave_handle_tx_fifo_empty(i2c_slave_struct_t * i2c);
+static bool i2c_slave_handle_rx_fifo_full(i2c_slave_struct_t * i2c, uint32_t len);
+static size_t i2c_slave_read_rx(i2c_slave_struct_t * i2c, uint8_t * data, size_t len);
+static void i2c_slave_isr_handler(void* arg);
+static void i2c_slave_task(void *pv_args);
+
+
+//=====================================================================================================================
+//-------------------------------------- Public Functions -------------------------------------------------------------
+//=====================================================================================================================
+
+esp_err_t i2cSlaveAttachCallbacks(uint8_t num, i2c_slave_request_cb_t request_callback, i2c_slave_receive_cb_t receive_callback, void * arg){
+    if(num >= SOC_I2C_NUM){
+        log_e("Invalid port num: %u", num);
+        return ESP_ERR_INVALID_ARG;
+    }
+    i2c_slave_struct_t * i2c = &_i2c_bus_array[num];
+    I2C_SLAVE_MUTEX_LOCK();
+    i2c->request_callback = request_callback;
+    i2c->receive_callback = receive_callback;
+    i2c->arg = arg;
+    I2C_SLAVE_MUTEX_UNLOCK();
+    return ESP_OK;
+}
+
+esp_err_t i2cSlaveInit(uint8_t num, int sda, int scl, uint16_t slaveID, uint32_t frequency, size_t rx_len, size_t tx_len) {
+    if(num >= SOC_I2C_NUM){
+        log_e("Invalid port num: %u", num);
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if (sda < 0 || scl < 0) {
+        log_e("invalid pins sda=%d, scl=%d", sda, scl);
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    if(!frequency){
+        frequency = 100000;
+    } else if(frequency > 1000000){
+        frequency = 1000000;
+    }
+
+    log_i("Initialising I2C Slave: sda=%d scl=%d freq=%d, addr=0x%x", sda, scl, frequency, slaveID);
+
+    i2c_slave_struct_t * i2c = &_i2c_bus_array[num];
+    esp_err_t ret = ESP_OK;
+
+#if !CONFIG_DISABLE_HAL_LOCKS
+    if(!i2c->lock){
+        i2c->lock = xSemaphoreCreateMutex();
+        if (i2c->lock == NULL) {
+            log_e("RX queue create failed");
+            return ESP_ERR_NO_MEM;
+        }
+    }
+#endif
+
+    I2C_SLAVE_MUTEX_LOCK();
+    i2c_slave_free_resources(i2c);
+
+#if I2C_SLAVE_USE_RX_QUEUE
+    i2c->rx_queue = xQueueCreate(rx_len, sizeof(uint8_t));
+    if (i2c->rx_queue == NULL) {
+        log_e("RX queue create failed");
+        ret = ESP_ERR_NO_MEM;
+        goto fail;
+    }
+#else
+    i2c->rx_ring_buf = xRingbufferCreate(rx_len, RINGBUF_TYPE_BYTEBUF);
+    if (i2c->rx_ring_buf == NULL) {
+        log_e("RX RingBuf create failed");
+        ret = ESP_ERR_NO_MEM;
+        goto fail;
+    }
+#endif
+
+    i2c->tx_queue = xQueueCreate(tx_len, sizeof(uint8_t));
+    if (i2c->tx_queue == NULL) {
+        log_e("TX queue create failed");
+        ret = ESP_ERR_NO_MEM;
+        goto fail;
+    }
+
+    i2c->event_queue = xQueueCreate(16, sizeof(i2c_slave_queue_event_t));
+    if (i2c->event_queue == NULL) {
+        log_e("Event queue create failed");
+        ret = ESP_ERR_NO_MEM;
+        goto fail;
+    }
+
+    xTaskCreate(i2c_slave_task, "i2c_slave_task", 4096, i2c, 20, &i2c->task_handle);
+    if(i2c->task_handle == NULL){
+        log_e("Event thread create failed");
+        ret = ESP_ERR_NO_MEM;
+        goto fail;
+    }
+
+    if (frequency == 0) {
+        frequency = 100000L;
+    }
+    frequency = (frequency * 5) / 4;
+
+    if (i2c->num == 0) {
+        periph_module_enable(PERIPH_I2C0_MODULE);
+#if SOC_I2C_NUM > 1
+    } else {
+        periph_module_enable(PERIPH_I2C1_MODULE);
+#endif
+    }
+    
+    i2c_ll_slave_init(i2c->dev);
+    i2c_ll_set_fifo_mode(i2c->dev, true);
+    i2c_ll_set_slave_addr(i2c->dev, slaveID, false);
+    i2c_ll_set_tout(i2c->dev, 32000);
+    i2c_slave_set_frequency(i2c, frequency);
+
+    if (!i2c_slave_check_line_state(sda, scl)) {
+        log_e("bad pin state");
+        ret = ESP_FAIL;
+        goto fail;
+    }
+
+    i2c_slave_attach_gpio(i2c, sda, scl);
+
+    if (i2c_ll_is_bus_busy(i2c->dev)) {
+        log_w("Bus busy, reinit");
+        ret = ESP_FAIL;
+        goto fail;
+    }
+
+    i2c_ll_disable_intr_mask(i2c->dev, I2C_LL_INTR_MASK);
+    i2c_ll_clr_intsts_mask(i2c->dev, I2C_LL_INTR_MASK);
+    i2c_ll_set_fifo_mode(i2c->dev, true);
+
+    if (!i2c->intr_handle) {
+        uint32_t flags = ESP_INTR_FLAG_LOWMED | ESP_INTR_FLAG_SHARED;
+        if(i2c->num == 0) {
+            ret = esp_intr_alloc(ETS_I2C_EXT0_INTR_SOURCE, flags, &i2c_slave_isr_handler, i2c, &i2c->intr_handle);
+#if SOC_I2C_NUM > 1
+        } else {
+            ret = esp_intr_alloc(ETS_I2C_EXT1_INTR_SOURCE, flags, &i2c_slave_isr_handler, i2c, &i2c->intr_handle);
+#endif
+        }
+
+        if (ret != ESP_OK) {
+            log_e("install interrupt handler Failed=%d", ret);
+            goto fail;
+        }
+    }
+    
+    i2c_ll_txfifo_rst(i2c->dev);
+    i2c_ll_rxfifo_rst(i2c->dev);
+    i2c_ll_slave_enable_rx_it(i2c->dev);
+    i2c_ll_set_stretch(i2c->dev, 0x3FF);
+    i2c_ll_update(i2c->dev);
+    I2C_SLAVE_MUTEX_UNLOCK();
+    return ret;
+
+fail:
+    i2c_slave_free_resources(i2c);
+    I2C_SLAVE_MUTEX_UNLOCK();
+    return ret;
+}
+
+esp_err_t i2cSlaveDeinit(uint8_t num){
+    if(num >= SOC_I2C_NUM){
+        log_e("Invalid port num: %u", num);
+        return ESP_ERR_INVALID_ARG;
+    }
+
+    i2c_slave_struct_t * i2c = &_i2c_bus_array[num];
+    if(!i2c->lock){
+        log_e("Lock is not initialized! Did you call i2c_slave_init()?");
+        return ESP_ERR_NO_MEM;
+    }
+    I2C_SLAVE_MUTEX_LOCK();
+    i2c_slave_free_resources(i2c);
+    I2C_SLAVE_MUTEX_UNLOCK();
+    return ESP_OK;
+}
+
+size_t i2cSlaveWrite(uint8_t num, const uint8_t *buf, uint32_t len, uint32_t timeout_ms) {
+    if(num >= SOC_I2C_NUM){
+        log_e("Invalid port num: %u", num);
+        return 0;
+    }
+    size_t to_queue = 0, to_fifo = 0;
+    i2c_slave_struct_t * i2c = &_i2c_bus_array[num];
+    if(!i2c->lock){
+        log_e("Lock is not initialized! Did you call i2c_slave_init()?");
+        return ESP_ERR_NO_MEM;
+    }
+    if(!i2c->tx_queue){
+        return 0;
+    }
+    I2C_SLAVE_MUTEX_LOCK();
+#if CONFIG_IDF_TARGET_ESP32
+    //make sure that tx is idle
+    uint64_t tout_at = esp_timer_get_time() + (timeout_ms * 1000);
+    while(i2c_ll_slave_addressed(i2c->dev) && i2c_ll_slave_rw(i2c->dev)) {
+        // ongoing MASTER READ
+        //wait up to timeout_ms for current transaction to finish
+        vTaskDelay(2);
+        if((uint64_t)esp_timer_get_time() >= tout_at){
+            log_e("TX IDLE WAIT TIMEOUT!");
+            I2C_SLAVE_MUTEX_UNLOCK();
+            return 0;
+        }
+    }
+    i2c_ll_slave_disable_tx_it(i2c->dev);
+    if (i2c_ll_get_txfifo_len(i2c->dev) < SOC_I2C_FIFO_LEN) {
+        i2c_ll_txfifo_rst(i2c->dev);
+    }
+#endif
+    to_fifo = i2c_ll_get_txfifo_len(i2c->dev);
+    if(len < to_fifo){
+        to_fifo = len;
+    }
+    i2c_ll_write_txfifo(i2c->dev, (uint8_t*)buf, to_fifo);
+    buf += to_fifo;
+    len -= to_fifo;
+    //reset tx_queue
+    xQueueReset(i2c->tx_queue);
+    //write the rest of the bytes to the queue
+    if(len){
+        to_queue = uxQueueSpacesAvailable(i2c->tx_queue);
+        if(len < to_queue){
+            to_queue = len;
+        }
+        for (size_t i = 0; i < to_queue; i++) {
+            if (xQueueSend(i2c->tx_queue, &buf[i], timeout_ms / portTICK_RATE_MS) != pdTRUE) {
+                xQueueReset(i2c->tx_queue);
+                to_queue = 0;
+                break;
+            }
+        }
+        //no need to enable TX_EMPTY if tx_queue is empty
+        if(to_queue){
+            i2c_ll_slave_enable_tx_it(i2c->dev);
+        }
+    }
+    I2C_SLAVE_MUTEX_UNLOCK();
+    return to_queue + to_fifo;
+}
+
+//=====================================================================================================================
+//-------------------------------------- Private Functions ------------------------------------------------------------
+//=====================================================================================================================
+
+static void i2c_slave_free_resources(i2c_slave_struct_t * i2c){
+    i2c_slave_detach_gpio(i2c);
+    i2c_ll_set_slave_addr(i2c->dev, 0, false);
+    i2c_ll_disable_intr_mask(i2c->dev, I2C_LL_INTR_MASK);
+    i2c_ll_clr_intsts_mask(i2c->dev, I2C_LL_INTR_MASK);
+
+    if (i2c->intr_handle) {
+        esp_intr_free(i2c->intr_handle);
+        i2c->intr_handle = NULL;
+    }
+
+    if(i2c->task_handle){
+        vTaskDelete(i2c->task_handle);
+        i2c->task_handle = NULL;
+    }
+
+#if I2C_SLAVE_USE_RX_QUEUE
+    if (i2c->rx_queue) {
+        vQueueDelete(i2c->rx_queue);
+        i2c->rx_queue = NULL;
+    }
+#else
+    if (i2c->rx_ring_buf) {
+        vRingbufferDelete(i2c->rx_ring_buf);
+        i2c->rx_ring_buf = NULL;
+    }
+#endif
+
+    if (i2c->tx_queue) {
+        vQueueDelete(i2c->tx_queue);
+        i2c->tx_queue = NULL;
+    }
+
+    if (i2c->event_queue) {
+        vQueueDelete(i2c->event_queue);
+        i2c->event_queue = NULL;
+    }
+
+    i2c->rx_data_count = 0;
+}
+
+static bool i2c_slave_set_frequency(i2c_slave_struct_t * i2c, uint32_t clk_speed)
+{
+    if (i2c == NULL) {
+        log_e("no control buffer");
+        return false;
+    }
+    if(clk_speed > 1100000UL){
+        clk_speed = 1100000UL;
+    }
+
+    // Adjust Fifo thresholds based on frequency
+    uint32_t a = (clk_speed / 50000L) + 2;
+    log_d("Fifo thresholds: rx_fifo_full = %d, tx_fifo_empty = %d", SOC_I2C_FIFO_LEN - a, a);
+
+    i2c_clk_cal_t clk_cal;
+#if SOC_I2C_SUPPORT_APB
+    i2c_ll_cal_bus_clk(APB_CLK_FREQ, clk_speed, &clk_cal);
+    i2c_ll_set_source_clk(i2c->dev, I2C_SCLK_APB);            /*!< I2C source clock from APB, 80M*/
+#elif SOC_I2C_SUPPORT_XTAL
+    i2c_ll_cal_bus_clk(XTAL_CLK_FREQ, clk_speed, &clk_cal);
+    i2c_ll_set_source_clk(i2c->dev, I2C_SCLK_XTAL);           /*!< I2C source clock from XTAL, 40M */
+#endif
+    i2c_ll_set_txfifo_empty_thr(i2c->dev, a);
+    i2c_ll_set_rxfifo_full_thr(i2c->dev, SOC_I2C_FIFO_LEN - a);
+    i2c_ll_set_bus_timing(i2c->dev, &clk_cal);
+    i2c_ll_set_filter(i2c->dev, 3);
+    return true;
+}
+
+static void i2c_slave_delay_us(uint64_t us)
+{
+    uint64_t m = esp_timer_get_time();
+    if (us) {
+        uint64_t e = (m + us);
+        if (m > e) { //overflow
+            while ((uint64_t)esp_timer_get_time() > e);
+        }
+        while ((uint64_t)esp_timer_get_time() < e);
+    }
+}
+
+static void i2c_slave_gpio_mode(int8_t pin, gpio_mode_t mode)
+{
+    gpio_config_t conf = {
+        .pin_bit_mask = 1LL << pin,
+        .mode = mode,
+        .pull_up_en = GPIO_PULLUP_ENABLE,
+        .pull_down_en = GPIO_PULLDOWN_DISABLE,
+        .intr_type = GPIO_INTR_DISABLE
+    };
+    gpio_config(&conf);
+}
+
+static bool i2c_slave_check_line_state(int8_t sda, int8_t scl)
+{
+    if (sda < 0 || scl < 0) {
+        return false;//return false since there is nothing to do
+    }
+    // if the bus is not 'clear' try the cycling SCL until SDA goes High or 9 cycles
+    gpio_set_level(sda, 1);
+    gpio_set_level(scl, 1);
+    i2c_slave_gpio_mode(sda, GPIO_MODE_INPUT | GPIO_MODE_DEF_OD);
+    i2c_slave_gpio_mode(scl, GPIO_MODE_INPUT | GPIO_MODE_DEF_OD);
+    gpio_set_level(scl, 1);
+
+    if (!gpio_get_level(sda) || !gpio_get_level(scl)) { // bus in busy state
+        log_w("invalid state sda(%d)=%d, scl(%d)=%d", sda, gpio_get_level(sda), scl, gpio_get_level(scl));
+        for (uint8_t a=0; a<9; a++) {
+            i2c_slave_delay_us(5);
+            if (gpio_get_level(sda) && gpio_get_level(scl)) { // bus recovered
+                log_w("Recovered after %d Cycles",a);
+                gpio_set_level(sda,0); // start
+                i2c_slave_delay_us(5);
+                for (uint8_t a=0;a<9; a++) {
+                    gpio_set_level(scl,1);
+                    i2c_slave_delay_us(5);
+                    gpio_set_level(scl,0);
+                    i2c_slave_delay_us(5);
+                }
+                gpio_set_level(scl,1);
+                i2c_slave_delay_us(5);
+                gpio_set_level(sda,1); // stop
+                break;
+            }
+            gpio_set_level(scl, 0);
+            i2c_slave_delay_us(5);
+            gpio_set_level(scl, 1);
+        }
+    }
+
+    if (!gpio_get_level(sda) || !gpio_get_level(scl)) { // bus in busy state
+        log_e("Bus Invalid State, Can't init sda=%d, scl=%d",gpio_get_level(sda),gpio_get_level(scl));
+        return false; // bus is busy
+    }
+    return true;
+}
+
+static bool i2c_slave_attach_gpio(i2c_slave_struct_t * i2c, int8_t sda, int8_t scl)
+{
+    if (i2c == NULL) {
+        log_e("no control block");
+        return false;
+    }
+    
+    if ((sda < 0)||( scl < 0)) {
+        log_e("bad pins sda=%d, scl=%d",sda,scl);
+        return false;
+    }
+
+    i2c->scl = scl;
+    gpio_set_level(scl, 1);
+    i2c_slave_gpio_mode(scl, GPIO_MODE_INPUT_OUTPUT_OD);
+    gpio_matrix_out(scl, I2C_SCL_IDX(i2c->num), false, false);
+    gpio_matrix_in(scl, I2C_SCL_IDX(i2c->num), false);
+
+    i2c->sda = sda;
+    gpio_set_level(sda, 1);
+    i2c_slave_gpio_mode(sda, GPIO_MODE_INPUT_OUTPUT_OD);
+    gpio_matrix_out(sda, I2C_SDA_IDX(i2c->num), false, false);
+    gpio_matrix_in(sda, I2C_SDA_IDX(i2c->num), false);
+
+    return true;
+}
+
+static bool i2c_slave_detach_gpio(i2c_slave_struct_t * i2c)
+{
+    if (i2c == NULL) {
+        log_e("no control Block");
+        return false;
+    }
+    if (i2c->scl >= 0) {
+        gpio_matrix_out(i2c->scl, 0x100, false, false);
+        gpio_matrix_in(0x30, I2C_SCL_IDX(i2c->num), false);
+        i2c_slave_gpio_mode(i2c->scl, GPIO_MODE_INPUT);
+        i2c->scl = -1; // un attached
+    }
+    if (i2c->sda >= 0) {
+        gpio_matrix_out(i2c->sda, 0x100, false, false);
+        gpio_matrix_in(0x30, I2C_SDA_IDX(i2c->num), false);
+        i2c_slave_gpio_mode(i2c->sda, GPIO_MODE_INPUT);
+        i2c->sda = -1; // un attached
+    }
+    return true;
+}
+
+static bool i2c_slave_send_event(i2c_slave_struct_t * i2c, i2c_slave_queue_event_t* event)
+{
+    bool pxHigherPriorityTaskWoken = false;
+    if(i2c->event_queue) {
+        if(xQueueSendFromISR(i2c->event_queue, event, (BaseType_t * const)&pxHigherPriorityTaskWoken) != pdTRUE){
+            //log_e("event_queue_full");
+        }
+    }
+    return pxHigherPriorityTaskWoken;
+}
+
+static bool i2c_slave_handle_tx_fifo_empty(i2c_slave_struct_t * i2c)
+{
+    bool pxHigherPriorityTaskWoken = false;
+    uint32_t d = 0, moveCnt = i2c_ll_get_txfifo_len(i2c->dev);
+    while (moveCnt > 0) { // read tx queue until Fifo is full or queue is empty
+        if(xQueueReceiveFromISR(i2c->tx_queue, &d, (BaseType_t * const)&pxHigherPriorityTaskWoken) == pdTRUE){
+            i2c_ll_write_txfifo(i2c->dev, (uint8_t*)&d, 1);
+            moveCnt--;
+        } else {
+            i2c_ll_slave_disable_tx_it(i2c->dev);
+            break;
+        }
+    }
+    return pxHigherPriorityTaskWoken;
+}
+
+static bool i2c_slave_handle_rx_fifo_full(i2c_slave_struct_t * i2c, uint32_t len)
+{
+#if I2C_SLAVE_USE_RX_QUEUE
+    uint32_t d = 0;
+#else
+    uint8_t data[SOC_I2C_FIFO_LEN];
+#endif
+    bool pxHigherPriorityTaskWoken = false;
+#if I2C_SLAVE_USE_RX_QUEUE
+    while (len > 0) {
+        i2c_ll_read_rxfifo(i2c->dev, (uint8_t*)&d, 1);
+        if(xQueueSendFromISR(i2c->rx_queue, &d, (BaseType_t * const)&pxHigherPriorityTaskWoken) != pdTRUE){
+            log_e("rx_queue_full");
+        } else {
+            i2c->rx_data_count++;
+        }
+        if (--len == 0) {
+            len = i2c_ll_get_rxfifo_cnt(i2c->dev);
+        }
+#else
+    if(len){
+        i2c_ll_read_rxfifo(i2c->dev, data, len);
+        if(xRingbufferSendFromISR(i2c->rx_ring_buf, (void*) data, len, (BaseType_t * const)&pxHigherPriorityTaskWoken) != pdTRUE){
+            log_e("rx_ring_buf_full");
+        } else {
+            i2c->rx_data_count += len;
+        }
+#endif
+    }
+    return pxHigherPriorityTaskWoken;
+}
+
+static void i2c_slave_isr_handler(void* arg)
+{
+    bool pxHigherPriorityTaskWoken = false;
+    i2c_slave_struct_t * i2c = (i2c_slave_struct_t *) arg; // recover data
+
+    uint32_t activeInt = i2c_ll_get_intsts_mask(i2c->dev);
+    i2c_ll_clr_intsts_mask(i2c->dev, activeInt);
+    uint8_t rx_fifo_len = i2c_ll_get_rxfifo_cnt(i2c->dev);
+    uint8_t tx_fifo_len = SOC_I2C_FIFO_LEN - i2c_ll_get_txfifo_len(i2c->dev);
+    bool slave_rw = i2c_ll_slave_rw(i2c->dev);
+
+    if(activeInt & I2C_RXFIFO_WM_INT_ENA){ // RX FiFo Full
+        pxHigherPriorityTaskWoken |= i2c_slave_handle_rx_fifo_full(i2c, rx_fifo_len);
+        i2c_ll_slave_enable_rx_it(i2c->dev);//is this necessary?
+    }
+
+    if(activeInt & I2C_TRANS_COMPLETE_INT_ENA){ // STOP
+        if(rx_fifo_len){ //READ RX FIFO
+            pxHigherPriorityTaskWoken |= i2c_slave_handle_rx_fifo_full(i2c, rx_fifo_len);
+        }
+        if(i2c->rx_data_count){ //WRITE or RepeatedStart
+            //SEND RX Event
+            i2c_slave_queue_event_t event;
+            event.event = I2C_SLAVE_EVT_RX;
+            event.stop = !slave_rw;
+            event.param = i2c->rx_data_count;
+            pxHigherPriorityTaskWoken |= i2c_slave_send_event(i2c, &event);
+            //Zero RX count
+            i2c->rx_data_count = 0;
+        }
+        if(slave_rw){ // READ
+#if CONFIG_IDF_TARGET_ESP32
+            //SEND TX Event
+            i2c_slave_queue_event_t event;
+            event.event = I2C_SLAVE_EVT_TX;
+            pxHigherPriorityTaskWoken |= i2c_slave_send_event(i2c, &event);
+#else
+            //reset TX data
+            i2c_ll_txfifo_rst(i2c->dev);
+            uint8_t d;
+            while (xQueueReceiveFromISR(i2c->tx_queue, &d, (BaseType_t * const)&pxHigherPriorityTaskWoken) == pdTRUE) ;//flush partial write
+#endif
+        }
+    }
+
+#ifndef CONFIG_IDF_TARGET_ESP32
+    if(activeInt & I2C_SLAVE_STRETCH_INT_ENA){ // STRETCH
+        i2c_stretch_cause_t cause = i2c_ll_stretch_cause(i2c->dev);
+        if(cause == I2C_STRETCH_CAUSE_MASTER_READ){
+            //on C3 RX data dissapears with repeated start, so we need to get it here
+            if(rx_fifo_len){
+                pxHigherPriorityTaskWoken |= i2c_slave_handle_rx_fifo_full(i2c, rx_fifo_len);
+            }
+            //SEND TX Event
+            i2c_slave_queue_event_t event;
+            event.event = I2C_SLAVE_EVT_TX;
+            pxHigherPriorityTaskWoken |= i2c_slave_send_event(i2c, &event);
+            //will clear after execution
+        } else if(cause == I2C_STRETCH_CAUSE_TX_FIFO_EMPTY){
+            pxHigherPriorityTaskWoken |= i2c_slave_handle_tx_fifo_empty(i2c);
+            i2c_ll_stretch_clr(i2c->dev);
+        } else if(cause == I2C_STRETCH_CAUSE_RX_FIFO_FULL){
+            pxHigherPriorityTaskWoken |= i2c_slave_handle_rx_fifo_full(i2c, rx_fifo_len);
+            i2c_ll_stretch_clr(i2c->dev);
+        }
+    }
+#endif
+
+    if(activeInt & I2C_TXFIFO_WM_INT_ENA){ // TX FiFo Empty
+        pxHigherPriorityTaskWoken |= i2c_slave_handle_tx_fifo_empty(i2c);
+    }
+
+    if(pxHigherPriorityTaskWoken){
+        portYIELD_FROM_ISR();
+    }
+}
+
+static size_t i2c_slave_read_rx(i2c_slave_struct_t * i2c, uint8_t * data, size_t len){
+    if(!len){
+        return 0;
+    }
+#if I2C_SLAVE_USE_RX_QUEUE
+    uint8_t d = 0;
+    BaseType_t res = pdTRUE;
+    for(size_t i=0; i<len; i++) {
+        if(data){
+            res = xQueueReceive(i2c->rx_queue, &data[i], 0);
+        } else {
+            res = xQueueReceive(i2c->rx_queue, &d, 0);
+        }
+        if (res != pdTRUE) {
+            log_e("Read Queue(%u) Failed", i);
+            len = i;
+            break;
+        }
+    }
+    return (data)?len:0;
+#else
+    size_t  dlen = 0, 
+            to_read = len, 
+            so_far = 0, 
+            available = 0;
+    uint8_t * rx_data = NULL;
+
+    vRingbufferGetInfo(i2c->rx_ring_buf, NULL, NULL, NULL, NULL, &available);
+    if(available < to_read){
+        log_e("Less available than requested. %u < %u", available, len);
+        to_read = available;
+    }
+
+    while(to_read){
+        dlen = 0;
+        rx_data = (uint8_t *)xRingbufferReceiveUpTo(i2c->rx_ring_buf, &dlen, 0, to_read);
+        if(!rx_data){
+            log_e("Receive %u Failed", to_read);
+            return so_far;
+        }
+        if(data){
+            memcpy(data+so_far, rx_data, dlen);
+        }
+        vRingbufferReturnItem(i2c->rx_ring_buf, rx_data);
+        so_far+=dlen;
+        to_read-=dlen;
+    }
+    return (data)?so_far:0;
+#endif
+}
+
+static void i2c_slave_task(void *pv_args)
+{
+    i2c_slave_struct_t * i2c = (i2c_slave_struct_t *)pv_args;
+    i2c_slave_queue_event_t event;
+    size_t len = 0;
+    bool stop = false;
+    uint8_t * data = NULL;
+    for(;;){
+        if(xQueueReceive(i2c->event_queue, &event, portMAX_DELAY) == pdTRUE){
+            // Write
+            if(event.event == I2C_SLAVE_EVT_RX){
+                len = event.param;
+                stop = event.stop;
+                data = (len > 0)?(uint8_t*)malloc(len):NULL;
+
+                if(len && data == NULL){
+                    log_e("Malloc (%u) Failed", len);
+                }
+                len = i2c_slave_read_rx(i2c, data, len);
+                if(i2c->receive_callback){
+                    i2c->receive_callback(i2c->num, data, len, stop, i2c->arg);
+                }
+                free(data);
+
+            // Read
+            } else if(event.event == I2C_SLAVE_EVT_TX){
+                if(i2c->request_callback){
+                    i2c->request_callback(i2c->num, i2c->arg);
+                }
+                i2c_ll_stretch_clr(i2c->dev);
+            }
+        }
+    }
+    vTaskDelete(NULL);
+}
--- a/cores/esp32/esp32-hal-i2c-slave.h
+++ b/cores/esp32/esp32-hal-i2c-slave.h
@ -0,0 +1,35 @@
+// Copyright 2015-2021 Espressif Systems (Shanghai) PTE LTD
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "stdint.h"
+#include "stddef.h"
+#include "esp_err.h"
+
+typedef void (*i2c_slave_request_cb_t) (uint8_t num, void * arg);
+typedef void (*i2c_slave_receive_cb_t) (uint8_t num, uint8_t * data, size_t len, bool stop, void * arg);
+esp_err_t i2cSlaveAttachCallbacks(uint8_t num, i2c_slave_request_cb_t request_callback, i2c_slave_receive_cb_t receive_callback, void * arg);
+
+esp_err_t i2cSlaveInit(uint8_t num, int sda, int scl, uint16_t slaveID, uint32_t frequency, size_t rx_len, size_t tx_len);
+esp_err_t i2cSlaveDeinit(uint8_t num);
+size_t i2cSlaveWrite(uint8_t num, const uint8_t *buf, uint32_t len, uint32_t timeout_ms);
+
+#ifdef __cplusplus
+}
+#endif
--- a/cores/esp32/esp32-hal-i2c.c
+++ b/cores/esp32/esp32-hal-i2c.c
--- a/cores/esp32/esp32-hal-i2c.h
+++ b/cores/esp32/esp32-hal-i2c.h
@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 // modified Nov 2017 by Chuck Todd <StickBreaker> to support Interrupt Driven I/O
+// modified Nov 2021 by Hristo Gochkov <Me-No-Dev> to support ESP-IDF API

 #ifndef _ESP32_HAL_I2C_H_
 #define _ESP32_HAL_I2C_H_
@ -22,58 +23,16 @@ extern "C" {

 #include <stdint.h>
 #include <stdbool.h>
-#include "freertos/FreeRTOS.h"
-#include "freertos/event_groups.h"
+#include <esp_err.h>

-// External Wire.h equivalent error Codes
-typedef enum {
-    I2C_ERROR_OK=0,
-    I2C_ERROR_DEV,
-    I2C_ERROR_ACK,
-    I2C_ERROR_TIMEOUT,
-    I2C_ERROR_BUS,
-    I2C_ERROR_BUSY,
-    I2C_ERROR_MEMORY,
-    I2C_ERROR_CONTINUE,
-    I2C_ERROR_NO_BEGIN
-} i2c_err_t;
-
-struct i2c_struct_t;
-typedef struct i2c_struct_t i2c_t;
-
-i2c_t * i2cInit(uint8_t i2c_num, int8_t sda, int8_t scl, uint32_t clk_speed);
-void i2cRelease(i2c_t *i2c); // free ISR, Free DQ, Power off peripheral clock.  Must call i2cInit() to recover
-i2c_err_t i2cWrite(i2c_t * i2c, uint16_t address, uint8_t* buff, uint16_t size, bool sendStop, uint16_t timeOutMillis);
-i2c_err_t i2cRead(i2c_t * i2c, uint16_t address, uint8_t* buff, uint16_t size, bool sendStop, uint16_t timeOutMillis, uint32_t *readCount);
-i2c_err_t i2cFlush(i2c_t *i2c);
-i2c_err_t i2cSetFrequency(i2c_t * i2c, uint32_t clk_speed);
-uint32_t i2cGetFrequency(i2c_t * i2c);
-uint32_t i2cGetStatus(i2c_t * i2c); // Status register of peripheral
-
-//Functions below should be used only if well understood
-//Might be deprecated and removed in future
-i2c_err_t i2cAttachSCL(i2c_t * i2c, int8_t scl);
-i2c_err_t i2cDetachSCL(i2c_t * i2c, int8_t scl);
-i2c_err_t i2cAttachSDA(i2c_t * i2c, int8_t sda);
-i2c_err_t i2cDetachSDA(i2c_t * i2c, int8_t sda);
-
-//Stickbreakers ISR Support
-i2c_err_t i2cProcQueue(i2c_t *i2c, uint32_t *readCount, uint16_t timeOutMillis);
-i2c_err_t i2cAddQueueWrite(i2c_t *i2c, uint16_t i2cDeviceAddr, uint8_t *dataPtr, uint16_t dataLen, bool SendStop, EventGroupHandle_t event);
-i2c_err_t i2cAddQueueRead(i2c_t *i2c, uint16_t i2cDeviceAddr, uint8_t *dataPtr, uint16_t dataLen, bool SendStop, EventGroupHandle_t event);
-
-//stickbreaker debug support
-uint32_t i2cDebug(i2c_t *, uint32_t setBits, uint32_t resetBits);
-//  Debug actions have 3 currently defined locus 
-// 0xXX------ : at entry of ProcQueue 
-// 0x--XX---- : at exit of ProcQueue
-// 0x------XX : at entry of Flush
-// 
-// bit 0 causes DumpI2c to execute 
-// bit 1 causes DumpInts to execute
-// bit 2 causes DumpCmdqueue to execute
-// bit 3 causes DumpStatus to execute
-// bit 4 causes DumpFifo to execute
+esp_err_t i2cInit(uint8_t i2c_num, int8_t sda, int8_t scl, uint32_t clk_speed);
+esp_err_t i2cDeinit(uint8_t i2c_num);
+esp_err_t i2cSetClock(uint8_t i2c_num, uint32_t frequency);
+esp_err_t i2cGetClock(uint8_t i2c_num, uint32_t * frequency);
+esp_err_t i2cWrite(uint8_t i2c_num, uint16_t address, const uint8_t* buff, size_t size, uint32_t timeOutMillis);
+esp_err_t i2cRead(uint8_t i2c_num, uint16_t address, uint8_t* buff, size_t size, uint32_t timeOutMillis, size_t *readCount);
+esp_err_t i2cWriteReadNonStop(uint8_t i2c_num, uint16_t address, const uint8_t* wbuff, size_t wsize, uint8_t* rbuff, size_t rsize, uint32_t timeOutMillis, size_t *readCount);
+bool i2cIsInit(uint8_t i2c_num);

 #ifdef __cplusplus
 }
--- a/cores/esp32/esp32-hal-timer.c
+++ b/cores/esp32/esp32-hal-timer.c
@ -90,17 +90,10 @@ typedef void (*voidFuncPtr)(void);
 static voidFuncPtr __timerInterruptHandlers[4] = {0,0,0,0};

 void ARDUINO_ISR_ATTR __timerISR(void * arg){
-#if CONFIG_IDF_TARGET_ESP32
    uint32_t s0 = TIMERG0.int_st_timers.val;
    uint32_t s1 = TIMERG1.int_st_timers.val;
    TIMERG0.int_clr_timers.val = s0;
    TIMERG1.int_clr_timers.val = s1;
-#else
-    uint32_t s0 = TIMERG0.int_st.val;
-    uint32_t s1 = TIMERG1.int_st.val;
-    TIMERG0.int_clr.val = s0;
-    TIMERG1.int_clr.val = s1;
-#endif
    uint8_t status = (s1 & 3) << 2 | (s0 & 3);
    uint8_t i = 4;
    //restart the timers that should autoreload
@ -239,19 +232,19 @@ hw_timer_t * timerBegin(uint8_t num, uint16_t divider, bool countUp){
    }
    timer->dev->config.enable = 0;
    if(timer->group) {
+#if CONFIG_IDF_TARGET_ESP32
        TIMERG1.int_ena.val &= ~BIT(timer->timer);
-#if CONFIG_IDF_TARGET_ESP32
+#else
+        TIMERG1.int_ena_timers.val &= ~BIT(timer->timer);
+#endif
        TIMERG1.int_clr_timers.val |= BIT(timer->timer);
-#else
-            TIMERG1.int_clr.val = BIT(timer->timer);
-#endif
    } else {
-        TIMERG0.int_ena.val &= ~BIT(timer->timer);
 #if CONFIG_IDF_TARGET_ESP32
-            TIMERG0.int_clr_timers.val |= BIT(timer->timer);
+        TIMERG0.int_ena.val &= ~BIT(timer->timer);
 #else
-            TIMERG0.int_clr.val = BIT(timer->timer);
+        TIMERG0.int_ena_timers.val &= ~BIT(timer->timer);
 #endif
+        TIMERG0.int_clr_timers.val |= BIT(timer->timer);
    }
 #ifdef TIMER_GROUP_SUPPORTS_XTAL_CLOCK
    timer->dev->config.use_xtal = 0;
@ -289,19 +282,19 @@ void timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
        timer->dev->config.edge_int_en = 0;
        timer->dev->config.alarm_en = 0;
        if(timer->num & 2){
+#if CONFIG_IDF_TARGET_ESP32
            TIMERG1.int_ena.val &= ~BIT(timer->timer);
-#if CONFIG_IDF_TARGET_ESP32
+#else
+            TIMERG1.int_ena_timers.val &= ~BIT(timer->timer);
+#endif
            TIMERG1.int_clr_timers.val |= BIT(timer->timer);
-#else
-            TIMERG1.int_clr.val = BIT(timer->timer);
-#endif
        } else {
-            TIMERG0.int_ena.val &= ~BIT(timer->timer);
 #if CONFIG_IDF_TARGET_ESP32
-            TIMERG0.int_clr_timers.val |= BIT(timer->timer);
+            TIMERG0.int_ena.val &= ~BIT(timer->timer);
 #else
-            TIMERG0.int_clr.val = BIT(timer->timer);
+            TIMERG0.int_ena_timers.val &= ~BIT(timer->timer);
 #endif
+            TIMERG0.int_clr_timers.val |= BIT(timer->timer);
        }
        __timerInterruptHandlers[timer->num] = NULL;
    } else {
@ -333,9 +326,17 @@ void timerAttachInterrupt(hw_timer_t *timer, void (*fn)(void), bool edge){
            intr_matrix_set(esp_intr_get_cpu(intr_handle), intr_source, esp_intr_get_intno(intr_handle));
        }
        if(timer->group){
+#if CONFIG_IDF_TARGET_ESP32
            TIMERG1.int_ena.val |= BIT(timer->timer);
+#else
+            TIMERG1.int_ena_timers.val |= BIT(timer->timer);
+#endif
        } else {
+#if CONFIG_IDF_TARGET_ESP32
            TIMERG0.int_ena.val |= BIT(timer->timer);
+#else
+            TIMERG0.int_ena_timers.val |= BIT(timer->timer);
+#endif
        }
    }
    if(intr_handle){
--- a/cores/esp32/esp32-hal-uart.c
+++ b/cores/esp32/esp32-hal-uart.c
@ -269,7 +269,7 @@ void uartWrite(uart_t* uart, uint8_t c)

 void uartWriteBuf(uart_t* uart, const uint8_t * data, size_t len)
 {
-    if(uart == NULL) {
+    if(uart == NULL || data == NULL || !len) {
        return;
    }

@ -368,13 +368,9 @@ void uartSetDebug(uart_t* uart)
 {
    if(uart == NULL || uart->num >= SOC_UART_NUM) {
        s_uart_debug_nr = -1;
-        //ets_install_putc1(NULL);
-        //return;
-    } else
-    if(s_uart_debug_nr == uart->num) {
-        return;
-    } else
+    } else {
        s_uart_debug_nr = uart->num;
+    }
    uart_install_putc();
 }

--- a/cores/esp32/esp32-hal.h
+++ b/cores/esp32/esp32-hal.h
@ -31,6 +31,11 @@
 #include "sdkconfig.h"
 #include "esp_system.h"
 #include "esp_sleep.h"
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/queue.h"
+#include "freertos/semphr.h"
+#include "freertos/event_groups.h"

 #ifdef __cplusplus
 extern "C" {
--- a/cores/esp32/firmware_msc_fat.c
+++ b/cores/esp32/firmware_msc_fat.c
@ -39,7 +39,7 @@ static const char * FAT12_FILE_SYSTEM_TYPE = "FAT12";

 static uint16_t fat12_sectors_per_alloc_table(uint32_t sector_num){
  uint32_t required_bytes = (((sector_num * 3)+1)/2);
-  return (required_bytes / DISK_SECTOR_SIZE) + ((required_bytes & DISK_SECTOR_SIZE)?1:0);
+  return (required_bytes / DISK_SECTOR_SIZE) + ((required_bytes & (DISK_SECTOR_SIZE - 1))?1:0);
 }

 static uint8_t * fat12_add_table(uint8_t * dst, fat_boot_sector_t * boot){
@ -68,7 +68,7 @@ static const char * FAT16_FILE_SYSTEM_TYPE = "FAT16";

 static uint16_t fat16_sectors_per_alloc_table(uint32_t sector_num){
  uint32_t required_bytes = sector_num * 2;
-  return (required_bytes / DISK_SECTOR_SIZE) + ((required_bytes & DISK_SECTOR_SIZE)?1:0);
+  return (required_bytes / DISK_SECTOR_SIZE) + ((required_bytes & (DISK_SECTOR_SIZE - 1))?1:0);
 }

 static uint8_t * fat16_add_table(uint8_t * dst, fat_boot_sector_t * boot){
@ -129,7 +129,7 @@ fat_boot_sector_t * fat_add_boot_sector(uint8_t * dst, uint16_t sector_num, uint
  boot->num_heads = 1;
  boot->hidden_sectors_count = 0;
  boot->total_sectors_32 = 0;
-  boot->physical_drive_number = 0x00;
+  boot->physical_drive_number = 0x80;
  boot->reserved0 = 0x00;
  boot->extended_boot_signature = 0x29;
  boot->serial_number = serial_number;
--- a/cores/esp32/libb64/cdecode.c
+++ b/cores/esp32/libb64/cdecode.c
@ -12,7 +12,7 @@ static int base64_decode_value_signed(int8_t value_in){
  static const int8_t decoding[] = {62,-1,-1,-1,63,52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-2,-1,-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,-1,-1,-1,-1,-1,-1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51};
  static const int8_t decoding_size = sizeof(decoding);
  value_in -= 43;
-  if (value_in < 0 || value_in > decoding_size) return -1;
+  if (value_in < 0 || value_in >= decoding_size) return -1;
  return decoding[(int)value_in];
 }

--- a/docs/source/getting_started.rst
+++ b/docs/source/getting_started.rst
@ -35,8 +35,8 @@ Here are the ESP32 series supported by the Arduino-ESP32 project:
 SoC      Stable Development Datasheet
 ======== ====== =========== ===================================
 ESP32    Yes    Yes         `ESP32 Datasheet`_
-ESP32-S2 No     Yes         `ESP32-S2 Datasheet`_
-ESP32-C3 No     Yes         `ESP32-C3 Datasheet`_
+ESP32-S2 Yes    Yes         `ESP32-S2 Datasheet`_
+ESP32-C3 Yes    Yes         `ESP32-C3 Datasheet`_
 ESP32-S3 No     No          Not Available Yet
 ======== ====== =========== ===================================

--- a/docs/source/installing.rst
+++ b/docs/source/installing.rst
@ -166,9 +166,7 @@ Debian/Ubuntu
   mkdir -p ~/Arduino/hardware/espressif && \
   cd ~/Arduino/hardware/espressif && \
   git clone https://github.com/espressif/arduino-esp32.git esp32 && \
-   cd esp32 && \
-   git submodule update --init --recursive && \
-   cd tools && \
+   cd esp32/tools && \
   python3 get.py

 - Restart Arduino IDE.
@ -181,9 +179,7 @@ Debian/Ubuntu
   mkdir -p espressif && \
   cd espressif && \
   git clone https://github.com/espressif/arduino-esp32.git esp32 && \
-   cd esp32 && \
-   git submodule update --init --recursive && \
-   cd tools && \
+   cd esp32/tools && \
   python3 get.py

 Fedora
@ -203,9 +199,7 @@ Fedora
   mkdir -p ~/Arduino/hardware/espressif && \
   cd ~/Arduino/hardware/espressif && \
   git clone https://github.com/espressif/arduino-esp32.git esp32 && \
-   cd esp32 && \
-   git submodule update --init --recursive && \
-   cd tools && \
+   cd esp32/tools && \
   python get.py

 - Restart Arduino IDE.
@ -228,9 +222,7 @@ openSUSE
   mkdir -p ~/Arduino/hardware/espressif && \
   cd ~/Arduino/hardware/espressif && \
   git clone https://github.com/espressif/arduino-esp32.git esp32 && \
-   cd esp32 && \
-   git submodule update --init --recursive && \
-   cd tools && \
+   cd esp32/tools && \
   python get.py

 - Restart Arduino IDE.
@ -246,10 +238,8 @@ macOS

   mkdir -p ~/Documents/Arduino/hardware/espressif && \
   cd ~/Documents/Arduino/hardware/espressif && \
-   git clone https://github.com/espressif/arduino-esp32.git esp32 --depth 1 && \
-   cd esp32 && \
-   git submodule update --init --recursive --depth 1 && \
-   cd tools && \
+   git clone https://github.com/espressif/arduino-esp32.git esp32 && \
+   cd esp32/tools && \
   python get.py 

 Where ``~/Documents/Arduino`` represents your sketch book location as per "Arduino" > "Preferences" > "Sketchbook location" (in the IDE once started). Adjust the command above accordingly.
--- a/docs/source/troubleshooting.rst
+++ b/docs/source/troubleshooting.rst
@ -12,31 +12,57 @@ Here are some of the most common issues around the ESP32 development using Ardui
 Installing
 ----------

+Here are the common issues during the installation.
+
 Building
 --------

+Missing Python: "python": executable file not found in $PATH
+************************************************************
+
+You are trying to build your sketch using Ubuntu and this message appears:
+
+.. code-block:: bash
+
+    "exec: "python": executable file not found in $PATH
+    Error compiling for board ESP32 Dev Module"
+
+Solution
+^^^^^^^^
+
+To avoid this error, you can install the ``python-is-python3`` package to create the symbolic links.
+
+.. code-block:: bash
+    
+    sudo apt install python-is-python3
+
+If you are not using Ubuntu, you can check if you have the Python correctly installed or the presence of the symbolic links/environment variables.
+
 Flashing
 --------

 Why is my board not flashing/uploading when I try to upload my sketch?
 **********************************************************************

-If you are trying to upload a new sketch and your board isn't responding, there are some possible reasons.
 To be able to upload the sketch via serial interface, the ESP32 must be in the download mode. The download mode allows you to upload the sketch over the serial port and to get into it, you need to keep the **GPIO0** in LOW while a resetting (**EN** pin) cycle.
+If you are trying to upload a new sketch and your board is not responding, there are some possible reasons.

 Possible fatal error message from the Arduino IDE:

    *A fatal error occurred: Failed to connect to ESP32: Timed out waiting for packet header*

+Solution
+^^^^^^^^
+
 Here are some steps that you can try to:

 * Check your USB cable and try a new one.
 * Change the USB port.
 * Check your power supply.
-* In some instances, you must keep **GPIO0** LOW during the uploading process via serial interface.
-* Hold-down the **“BOOT”** button in your ESP32 board while uploading/flashing.
+* In some instances, you must keep **GPIO0** LOW during the uploading process via the serial interface.
+* Hold down the **“BOOT”** button in your ESP32 board while uploading/flashing.

-In some development boards, you can try adding the reset delay circuit, as decribed in the *Power-on Sequence* section on the `ESP32 Hardware Design Guidelines <https://www.espressif.com/sites/default/files/documentation/esp32_hardware_design_guidelines_en.pdf>`_ in order to get into the download mode automatically.
+In some development boards, you can try adding the reset delay circuit, as described in the *Power-on Sequence* section on the `ESP32 Hardware Design Guidelines <https://www.espressif.com/sites/default/files/documentation/esp32_hardware_design_guidelines_en.pdf>`_ in order to get into the download mode automatically.

 Hardware
 --------
@ -44,7 +70,10 @@ Hardware
 Why is my computer not detecting my board?
 **************************************************

-If your board is not detected after connecting into the USB, you can try to:
+If your board is not being detected after connecting to the USB, you can try to:
+
+Solution
+^^^^^^^^

 * Check if the USB driver is missing. - `USB Driver Download Link  <https://www.silabs.com/developers/usb-to-uart-bridge-vcp-drivers>`_
 * Check your USB cable and try a new one.
--- a/docs/source/tutorials/blink.rst
+++ b/docs/source/tutorials/blink.rst
@ -0,0 +1,113 @@
+##########################
+Blink Interactive Tutorial
+##########################
+
+Introduction
+------------
+
+This is the interactive blink tutorial using `Wokwi`_. For this tutorial, you don't need the ESP32 board or the Arduino toolchain.
+
+.. note:: If you don't want to use this tutorial with the simulation, you can copy and paste the :ref:`blink_example_code` from `Wokwi`_ editor and use it on the `Arduino IDE`_ or `PlatformIO`_.
+
+About this Tutorial
+-------------------
+
+This tutorial is the most basic for any get started. In this tutorial, we will show how to set a GPIO pin as an output to drive a LED to blink each 1 second.
+
+Step by step
+------------
+
+In order to make this simple blink tutorial, you'll need to do the following steps.
+
+1. **Define the GPIO for the LED.**
+
+.. code-block::
+
+    #define LED 2
+
+This ``#define LED 2`` will be used to set the GPIO2 as the ``LED`` output pin. 
+
+2. **Setup.**
+
+Inside the ``setup()`` function, we need to add all things we want to run once during the startup.
+Here we'll add the ``pinMode`` function to set the pin as output.
+
+.. code-block::
+
+    void setup() {
+        pinMode(LED, OUTPUT);
+    }
+
+The first argument is the GPIO number, already defined and the second is the mode, here defined as an output.
+
+3. **Main Loop.**
+
+After the ``setup``, the code runs the ``loop`` function infinitely. Here we will handle the GPIO in order to get the LED blinking.
+
+.. code-block::
+
+    void loop() {
+        digitalWrite(LED, HIGH);
+        delay(100);
+        digitalWrite(LED, LOW);
+        delay(100);
+    }
+
+The first function is the ``digitalWrite()`` with two arguments:
+
+* GPIO: Set the GPIO pin. Here defined by our ``LED`` connected to the GPIO2.
+* State: Set the GPIO state as HIGH (ON) or LOW (OFF).
+
+This first ``digitalWrite`` we will set the LED ON.
+
+After the ``digitalWrite``, we will set a ``delay`` function in order to wait for some time, defined in milliseconds.
+
+Now we can set the GPIO to ``LOW`` to turn the LED off and ``delay`` for more few milliseconds to get the LED blinking.
+
+4. **Run the code.**
+
+To run this code, you'll need a development board and the Arduino toolchain installed on your computer. If you don't have both, you can use the simulator to test and edit the code.
+
+Simulation
+----------
+
+This simulator is provided by `Wokwi`_ and you can test the blink code and play with some modifications to learn more about this example.
+
+.. raw:: html
+
+    <iframe src="https://wokwi.com/arduino/projects/305566932847821378?embed=1" width="100%" height="400" border="0"></iframe>
+
+Change the parameters, like the delay period, to test the code right on your browser. You can add more LEDs, change the GPIO, and more.
+
+.. _blink_example_code:
+
+Example Code
+------------
+
+Here is the full blink code.
+
+.. code-block::
+
+    #define LED 2
+
+    void setup() {
+        pinMode(LED, OUTPUT);
+    }
+
+    void loop() {
+        digitalWrite(LED, HIGH);
+        delay(100);
+        digitalWrite(LED, LOW);
+        delay(100);
+    }
+
+Resources
+---------
+
+* `ESP32 Datasheet`_ (Datasheet)
+* `Wokwi`_ (Wokwi Website)
+
+.. _ESP32 Datasheet: https://www.espressif.com/sites/default/files/documentation/esp32_datasheet_en.pdf
+.. _Wokwi: https://wokwi.com/
+.. _PlatformIO: https://docs.espressif.com/projects/arduino-esp32/en/latest/installing.html#platformio
+.. _Arduino IDE: https://docs.espressif.com/projects/arduino-esp32/en/latest/installing.html#installing-using-boards-manager
--- a/docs/source/tutorials/tutorials.rst
+++ b/docs/source/tutorials/tutorials.rst
@ -6,6 +6,7 @@ Tutorials
    :maxdepth: 2
    :caption: Tutorials:

+    Blink <blink>
    Basic <basic>
    DFU <dfu>
    GPIO Matrix and Pin Mux <io_mux>
--- a/libraries/BLE/src/BLECharacteristic.cpp
+++ b/libraries/BLE/src/BLECharacteristic.cpp
@ -191,7 +191,7 @@ uint8_t* BLECharacteristic::getData() {
 * @brief Retrieve the current length of the data of the characteristic.
 * @return Amount of databytes of the characteristic.
 */
-uint8_t BLECharacteristic::getLength() {
+size_t BLECharacteristic::getLength() {
 	return m_value.getLength();
 } // getLength

--- a/libraries/BLE/src/BLECharacteristic.h
+++ b/libraries/BLE/src/BLECharacteristic.h
@ -62,7 +62,7 @@ public:
 	BLEUUID        getUUID();
 	std::string    getValue();
 	uint8_t*       getData();
-	uint8_t        getLength();
+	size_t         getLength();

 	void indicate();
 	void notify(bool is_notification = true);
--- a/libraries/EEPROM/examples/eeprom_class/eeprom_class.ino
+++ b/libraries/EEPROM/examples/eeprom_class/eeprom_class.ino
@ -11,27 +11,27 @@
 #include "EEPROM.h"

 // Instantiate eeprom objects with parameter/argument names and sizes
-EEPROMClass  NAMES("eeprom0", 0x500);
-EEPROMClass  HEIGHT("eeprom1", 0x200);
-EEPROMClass  AGE("eeprom2", 0x100);
+EEPROMClass  NAMES("eeprom0");
+EEPROMClass  HEIGHT("eeprom1");
+EEPROMClass  AGE("eeprom2");

 void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("Testing EEPROMClass\n");
-  if (!NAMES.begin(NAMES.length())) {
+  if (!NAMES.begin(0x500)) {
    Serial.println("Failed to initialise NAMES");
    Serial.println("Restarting...");
    delay(1000);
    ESP.restart();
  }
-  if (!HEIGHT.begin(HEIGHT.length())) {
+  if (!HEIGHT.begin(0x200)) {
    Serial.println("Failed to initialise HEIGHT");
    Serial.println("Restarting...");
    delay(1000);
    ESP.restart();
  }
-  if (!AGE.begin(AGE.length())) {
+  if (!AGE.begin(0x100)) {
    Serial.println("Failed to initialise AGE");
    Serial.println("Restarting...");
    delay(1000);
--- a/libraries/EEPROM/src/EEPROM.cpp
+++ b/libraries/EEPROM/src/EEPROM.cpp
@ -34,7 +34,6 @@ EEPROMClass::EEPROMClass(void)
  , _size(0)
  , _dirty(false)
  , _name("eeprom")
-  , _user_defined_size(0)
 {
 }

@ -45,17 +44,15 @@ EEPROMClass::EEPROMClass(uint32_t sector)
  , _size(0)
  , _dirty(false)
  , _name("eeprom")
-  , _user_defined_size(0)
 {
 }

-EEPROMClass::EEPROMClass(const char* name, uint32_t user_defined_size)
+EEPROMClass::EEPROMClass(const char* name)
  : _handle(0)
  , _data(0)
  , _size(0)
  , _dirty(false)
  , _name(name)
-  , _user_defined_size(user_defined_size)
 {
 }

@ -133,7 +130,7 @@ bool EEPROMClass::begin(size_t size) {

  _data = (uint8_t*) malloc(size);
  if(!_data) {
-    log_e("Not enough memory for %d bytes in EEPROM");
+    log_e("Not enough memory for %d bytes in EEPROM", size);
    return false;
  }
  _size = size;
@ -215,7 +212,7 @@ uint8_t * EEPROMClass::getDataPtr() {
 */
 uint16_t EEPROMClass::length ()
 {
-  return _user_defined_size;
+  return _size;
 }

 /* 
--- a/libraries/EEPROM/src/EEPROM.h
+++ b/libraries/EEPROM/src/EEPROM.h
@ -35,7 +35,7 @@ typedef uint32_t nvs_handle;
 class EEPROMClass {
  public:
    EEPROMClass(uint32_t sector);
-    EEPROMClass(const char* name, uint32_t user_defined_size);
+    EEPROMClass(const char* name);
    EEPROMClass(void);
    ~EEPROMClass(void);

@ -112,7 +112,6 @@ class EEPROMClass {
    size_t _size;
    bool _dirty;
    const char* _name;
-    uint32_t _user_defined_size;
 };

 #if !defined(NO_GLOBAL_INSTANCES) && !defined(NO_GLOBAL_EEPROM)
--- a/libraries/ESP32/examples/Camera/CameraWebServer/CameraWebServer.ino
+++ b/libraries/ESP32/examples/Camera/CameraWebServer/CameraWebServer.ino
@ -14,6 +14,7 @@
 //#define CAMERA_MODEL_M5STACK_V2_PSRAM // M5Camera version B Has PSRAM
 //#define CAMERA_MODEL_M5STACK_WIDE // Has PSRAM
 //#define CAMERA_MODEL_M5STACK_ESP32CAM // No PSRAM
+//#define CAMERA_MODEL_M5STACK_UNITCAM // No PSRAM
 //#define CAMERA_MODEL_AI_THINKER // Has PSRAM
 //#define CAMERA_MODEL_TTGO_T_JOURNAL // No PSRAM

--- a/libraries/ESP32/examples/Camera/CameraWebServer/camera_pins.h
+++ b/libraries/ESP32/examples/Camera/CameraWebServer/camera_pins.h
@ -113,6 +113,25 @@
 #define HREF_GPIO_NUM     26
 #define PCLK_GPIO_NUM     21

+#elif defined(CAMERA_MODEL_M5STACK_UNITCAM)
+#define PWDN_GPIO_NUM     -1
+#define RESET_GPIO_NUM    15
+#define XCLK_GPIO_NUM     27
+#define SIOD_GPIO_NUM     25
+#define SIOC_GPIO_NUM     23
+
+#define Y9_GPIO_NUM       19
+#define Y8_GPIO_NUM       36
+#define Y7_GPIO_NUM       18
+#define Y6_GPIO_NUM       39
+#define Y5_GPIO_NUM        5
+#define Y4_GPIO_NUM       34
+#define Y3_GPIO_NUM       35
+#define Y2_GPIO_NUM       32
+#define VSYNC_GPIO_NUM    22
+#define HREF_GPIO_NUM     26
+#define PCLK_GPIO_NUM     21
+
 #elif defined(CAMERA_MODEL_AI_THINKER)
 #define PWDN_GPIO_NUM     32
 #define RESET_GPIO_NUM    -1
--- a/libraries/FFat/src/FFat.cpp
+++ b/libraries/FFat/src/FFat.cpp
@ -168,7 +168,7 @@ size_t F_Fat::freeBytes()

 bool F_Fat::exists(const char* path)
 {
-    File f = open(path, "r");
+    File f = open(path, "r",false);
    return (f == true) && !f.isDirectory();
 }

--- a/libraries/FS/src/FS.cpp
+++ b/libraries/FS/src/FS.cpp
@ -186,18 +186,18 @@ void File::rewindDirectory(void)
    _p->rewindDirectory();
 }

-File FS::open(const String& path, const char* mode)
+File FS::open(const String& path, const char* mode, const bool create)
 {
-    return open(path.c_str(), mode);
+    return open(path.c_str(), mode, create);
 }

-File FS::open(const char* path, const char* mode)
+File FS::open(const char* path, const char* mode, const bool create)
 {
    if (!_impl) {
        return File();
    }

-    return File(_impl->open(path, mode));
+    return File(_impl->open(path, mode, create));
 }

 bool FS::exists(const char* path)
--- a/libraries/FS/src/FS.h
+++ b/libraries/FS/src/FS.h
@ -89,8 +89,8 @@ class FS
 public:
    FS(FSImplPtr impl) : _impl(impl) { }

-    File open(const char* path, const char* mode = FILE_READ);
-    File open(const String& path, const char* mode = FILE_READ);
+    File open(const char* path, const char* mode = FILE_READ, const bool create = false);
+    File open(const String& path, const char* mode = FILE_READ, const bool create = false);

    bool exists(const char* path);
    bool exists(const String& path);
--- a/libraries/FS/src/FSImpl.h
+++ b/libraries/FS/src/FSImpl.h
@ -53,7 +53,7 @@ protected:
 public:
    FSImpl() : _mountpoint(NULL) { }
    virtual ~FSImpl() { }
-    virtual FileImplPtr open(const char* path, const char* mode) = 0;
+    virtual FileImplPtr open(const char* path, const char* mode, const bool create) = 0;
    virtual bool exists(const char* path) = 0;
    virtual bool rename(const char* pathFrom, const char* pathTo) = 0;
    virtual bool remove(const char* path) = 0;
--- a/libraries/FS/src/vfs_api.cpp
+++ b/libraries/FS/src/vfs_api.cpp
@ -16,7 +16,7 @@

 using namespace fs;

-FileImplPtr VFSImpl::open(const char* fpath, const char* mode)
+FileImplPtr VFSImpl::open(const char* fpath, const char* mode, const bool create)
 {
    if(!_mountpoint) {
        log_e("File system is not mounted");
@ -37,7 +37,7 @@ FileImplPtr VFSImpl::open(const char* fpath, const char* mode)
    sprintf(temp,"%s%s", _mountpoint, fpath);

    struct stat st;
-    //file lound
+    //file found
    if(!stat(temp, &st)) {
        free(temp);
        if (S_ISREG(st.st_mode) || S_ISDIR(st.st_mode)) {
@ -47,12 +47,6 @@ FileImplPtr VFSImpl::open(const char* fpath, const char* mode)
        return FileImplPtr();
    }

-    //file not found but mode permits creation
-    if(mode && mode[0] != 'r') {
-        free(temp);
-        return std::make_shared<VFSFileImpl>(this, fpath, mode);
-    }
-
    //try to open this as directory (might be mount point)
    DIR * d = opendir(temp);
    if(d) {
@ -61,7 +55,51 @@ FileImplPtr VFSImpl::open(const char* fpath, const char* mode)
        return std::make_shared<VFSFileImpl>(this, fpath, mode);
    }

-    log_e("%s does not exist", temp);
+    //file not found but mode permits file creation without folder creation
+    if((mode && mode[0] != 'r') && (!create)){
+        free(temp);
+        return std::make_shared<VFSFileImpl>(this, fpath, mode);
+    }
+
+    ////file not found but mode permits file creation and folder creation
+    if((mode && mode[0] != 'r') && create){
+
+        char *token;
+        char *folder = (char *)malloc(strlen(fpath));
+
+        int start_index = 0;
+        int end_index = 0;
+
+        token = strchr(fpath+1,'/');
+        end_index = (token-fpath);
+
+        while (token != NULL)
+        {
+            memcpy(folder,fpath + start_index, end_index-start_index);
+            folder[end_index-start_index] = '\0';
+            
+            if(!VFSImpl::mkdir(folder))
+            {
+                log_e("Creating folder: %s failed!",folder);
+                return FileImplPtr();
+            }
+
+            token=strchr(token+1,'/');
+            if(token != NULL)
+            {
+                end_index = (token-fpath);
+                memset(folder, 0, strlen(folder));
+            }
+            
+        }
+
+        free(folder);
+        free(temp);
+        return std::make_shared<VFSFileImpl>(this, fpath, mode);
+
+    }
+
+    log_e("%s does not exist, no permits for creation", temp);
    free(temp);
    return FileImplPtr();
 }
--- a/libraries/FS/src/vfs_api.h
+++ b/libraries/FS/src/vfs_api.h
@ -35,7 +35,7 @@ protected:
    friend class VFSFileImpl;

 public:
-    FileImplPtr open(const char* path, const char* mode) override;
+    FileImplPtr open(const char* path, const char* mode, const bool create) override;
    bool        exists(const char* path) override;
    bool        rename(const char* pathFrom, const char* pathTo) override;
    bool        remove(const char* path) override;
--- a/libraries/HTTPClient/src/HTTPClient.cpp
+++ b/libraries/HTTPClient/src/HTTPClient.cpp
@ -261,6 +261,10 @@ bool HTTPClient::beginInternal(String url, const char* expectedProtocol)
    url.remove(0, (index + 3)); // remove http:// or https://

    index = url.indexOf('/');
+    if (index == -1) {
+        index = url.length();
+        url += '/';
+    }
    String host = url.substring(0, index);
    url.remove(0, index); // remove host part

--- a/libraries/LittleFS/src/LittleFS.cpp
+++ b/libraries/LittleFS/src/LittleFS.cpp
@ -45,7 +45,7 @@ LittleFSImpl::LittleFSImpl()

 bool LittleFSImpl::exists(const char* path)
 {
-    File f = open(path, "r");
+    File f = open(path, "r",false);
    return (f == true);
 }

--- a/libraries/SD_MMC/src/SD_MMC.cpp
+++ b/libraries/SD_MMC/src/SD_MMC.cpp
@ -36,7 +36,7 @@ SDMMCFS::SDMMCFS(FSImplPtr impl)
    : FS(impl), _card(NULL)
 {}

-bool SDMMCFS::begin(const char * mountpoint, bool mode1bit, bool format_if_mount_failed)
+bool SDMMCFS::begin(const char * mountpoint, bool mode1bit, bool format_if_mount_failed, int sdmmc_frequency)
 {
    if(_card) {
        return true;
@ -46,7 +46,7 @@ bool SDMMCFS::begin(const char * mountpoint, bool mode1bit, bool format_if_mount
    sdmmc_host_t host;
    host.flags = SDMMC_HOST_FLAG_4BIT;
    host.slot = SDMMC_HOST_SLOT_1;
-    host.max_freq_khz = SDMMC_FREQ_DEFAULT;
+    host.max_freq_khz = sdmmc_frequency;
    host.io_voltage = 3.3f;
    host.init = &sdmmc_host_init;
    host.set_bus_width = &sdmmc_host_set_bus_width;
@ -54,11 +54,10 @@ bool SDMMCFS::begin(const char * mountpoint, bool mode1bit, bool format_if_mount
    host.set_bus_ddr_mode = &sdmmc_host_set_bus_ddr_mode;
    host.set_card_clk = &sdmmc_host_set_card_clk;
    host.do_transaction = &sdmmc_host_do_transaction;
-    host.deinit_p = &sdspi_host_remove_device;
+    host.deinit = &sdmmc_host_deinit;
    host.io_int_enable = &sdmmc_host_io_int_enable;
    host.io_int_wait = &sdmmc_host_io_int_wait;
    host.command_timeout_ms = 0;
-    host.max_freq_khz = SDMMC_FREQ_HIGHSPEED;
 #ifdef BOARD_HAS_1BIT_SDMMC
    mode1bit = true;
 #endif
--- a/libraries/SD_MMC/src/SD_MMC.h
+++ b/libraries/SD_MMC/src/SD_MMC.h
@ -21,6 +21,13 @@
 #include "driver/sdmmc_types.h"
 #include "sd_defines.h"

+// If reading/writing to the SD card is unstable, 
+// you can define BOARD_MAX_SDMMC_FREQ with lower value (Ex. SDMMC_FREQ_DEFAULT) 
+// in pins_arduino.h for your board variant.
+#ifndef BOARD_MAX_SDMMC_FREQ
+#define BOARD_MAX_SDMMC_FREQ SDMMC_FREQ_HIGHSPEED
+#endif
+
 namespace fs
 {

@ -31,7 +38,7 @@ protected:

 public:
    SDMMCFS(FSImplPtr impl);
-    bool begin(const char * mountpoint="/sdcard", bool mode1bit=false, bool format_if_mount_failed=false);
+    bool begin(const char * mountpoint="/sdcard", bool mode1bit=false, bool format_if_mount_failed=false, int sdmmc_frequency=BOARD_MAX_SDMMC_FREQ);
    void end();
    sdcard_type_t cardType();
    uint64_t cardSize();
--- a/libraries/SPI/examples/SPI_Multiple_Buses/SPI_Multiple_Buses.ino
+++ b/libraries/SPI/examples/SPI_Multiple_Buses/SPI_Multiple_Buses.ino
@ -76,36 +76,24 @@ void setup() {

  //set up slave select pins as outputs as the Arduino API
  //doesn't handle automatically pulling SS low
-  pinMode(VSPI_SS, OUTPUT); //VSPI SS
-  pinMode(HSPI_SS, OUTPUT); //HSPI SS
+  pinMode(vspi->pinSS(), OUTPUT); //VSPI SS
+  pinMode(hspi->pinSS(), OUTPUT); //HSPI SS

 }

 // the loop function runs over and over again until power down or reset
 void loop() {
  //use the SPI buses
-  vspiCommand();
-  hspiCommand();
+  spiCommand(vspi, 0b01010101); // junk data to illustrate usage
+  spiCommand(hspi, 0b11001100);
  delay(100);
 }

-void vspiCommand() {
-  byte data = 0b01010101; // junk data to illustrate usage
-
+void spiCommand(SPIClass *spi, byte data) {
  //use it as you would the regular arduino SPI API
-  vspi->beginTransaction(SPISettings(spiClk, MSBFIRST, SPI_MODE0));
-  digitalWrite(VSPI_SS, LOW); //pull SS slow to prep other end for transfer
-  vspi->transfer(data);  
-  digitalWrite(VSPI_SS, HIGH); //pull ss high to signify end of data transfer
-  vspi->endTransaction();
-}
-
-void hspiCommand() {
-  byte stuff = 0b11001100;
-  
-  hspi->beginTransaction(SPISettings(spiClk, MSBFIRST, SPI_MODE0));
-  digitalWrite(HSPI_SS, LOW);
-  hspi->transfer(stuff);
-  digitalWrite(HSPI_SS, HIGH);
-  hspi->endTransaction();
+  spi->beginTransaction(SPISettings(spiClk, MSBFIRST, SPI_MODE0));
+  digitalWrite(spi->pinSS(), LOW); //pull SS slow to prep other end for transfer
+  spi->transfer(data);
+  digitalWrite(spi->pinSS(), HIGH); //pull ss high to signify end of data transfer
+  spi->endTransaction();
 }
--- a/libraries/SPI/src/SPI.h
+++ b/libraries/SPI/src/SPI.h
@ -83,6 +83,7 @@ public:
    void writePattern(const uint8_t * data, uint8_t size, uint32_t repeat);

    spi_t * bus(){ return _spi; }
+    int8_t pinSS() { return _ss; }
 };

 extern SPIClass SPI;
--- a/libraries/SPIFFS/src/SPIFFS.cpp
+++ b/libraries/SPIFFS/src/SPIFFS.cpp
@ -39,7 +39,7 @@ SPIFFSImpl::SPIFFSImpl()

 bool SPIFFSImpl::exists(const char* path)
 {
-    File f = open(path, "r");
+    File f = open(path, "r",false);
    return (f == true) && !f.isDirectory();
 }

--- a/libraries/USB/src/USBHID.cpp
+++ b/libraries/USB/src/USBHID.cpp
@ -230,7 +230,7 @@ uint8_t const * tud_hid_descriptor_report_cb(uint8_t instance){
 // protocol is either HID_PROTOCOL_BOOT (0) or HID_PROTOCOL_REPORT (1)
 void tud_hid_set_protocol_cb(uint8_t instance, uint8_t protocol){
    log_v("instance: %u, protocol:%u", instance, protocol);
-    arduino_usb_hid_event_data_t p = {0};
+    arduino_usb_hid_event_data_t p;
    p.instance = instance;
    p.set_protocol.protocol = protocol;
    arduino_usb_event_post(ARDUINO_USB_HID_EVENTS, ARDUINO_USB_HID_SET_PROTOCOL_EVENT, &p, sizeof(arduino_usb_hid_event_data_t), portMAX_DELAY);
@ -241,7 +241,7 @@ void tud_hid_set_protocol_cb(uint8_t instance, uint8_t protocol){
 // - Idle Rate > 0 : skip duplication, but send at least 1 report every idle rate (in unit of 4 ms).
 bool tud_hid_set_idle_cb(uint8_t instance, uint8_t idle_rate){
    log_v("instance: %u, idle_rate:%u", instance, idle_rate);
-    arduino_usb_hid_event_data_t p = {0};
+    arduino_usb_hid_event_data_t p;
    p.instance = instance;
    p.set_idle.idle_rate = idle_rate;
    arduino_usb_event_post(ARDUINO_USB_HID_EVENTS, ARDUINO_USB_HID_SET_IDLE_EVENT, &p, sizeof(arduino_usb_hid_event_data_t), portMAX_DELAY);
--- a/libraries/USB/src/USBHIDKeyboard.cpp
+++ b/libraries/USB/src/USBHIDKeyboard.cpp
@ -61,7 +61,7 @@ void USBHIDKeyboard::onEvent(arduino_usb_hid_keyboard_event_t event, esp_event_h

 void USBHIDKeyboard::_onOutput(uint8_t report_id, const uint8_t* buffer, uint16_t len){
    if(report_id == HID_REPORT_ID_KEYBOARD){
-        arduino_usb_hid_keyboard_event_data_t p = {0};
+        arduino_usb_hid_keyboard_event_data_t p;
        p.leds = buffer[0];
        arduino_usb_event_post(ARDUINO_USB_HID_KEYBOARD_EVENTS, ARDUINO_USB_HID_KEYBOARD_LED_EVENT, &p, sizeof(arduino_usb_hid_keyboard_event_data_t), portMAX_DELAY);
    }
--- a/libraries/USB/src/USBHIDVendor.cpp
+++ b/libraries/USB/src/USBHIDVendor.cpp
@ -124,7 +124,7 @@ uint16_t USBHIDVendor::_onGetFeature(uint8_t report_id, uint8_t* buffer, uint16_
        return 0;
    }
    memcpy(buffer, feature, len);
-    arduino_usb_hid_vendor_event_data_t p = {0};
+    arduino_usb_hid_vendor_event_data_t p;
    p.buffer = feature;
    p.len = len;
    arduino_usb_event_post(ARDUINO_USB_HID_VENDOR_EVENTS, ARDUINO_USB_HID_VENDOR_GET_FEATURE_EVENT, &p, sizeof(arduino_usb_hid_vendor_event_data_t), portMAX_DELAY);
@ -136,7 +136,7 @@ void USBHIDVendor::_onSetFeature(uint8_t report_id, const uint8_t* buffer, uint1
        return;
    }
    memcpy(feature, buffer, len);
-    arduino_usb_hid_vendor_event_data_t p = {0};
+    arduino_usb_hid_vendor_event_data_t p;
    p.buffer = feature;
    p.len = len;
    arduino_usb_event_post(ARDUINO_USB_HID_VENDOR_EVENTS, ARDUINO_USB_HID_VENDOR_SET_FEATURE_EVENT, &p, sizeof(arduino_usb_hid_vendor_event_data_t), portMAX_DELAY);
@ -153,7 +153,7 @@ void USBHIDVendor::_onOutput(uint8_t report_id, const uint8_t* buffer, uint16_t
            break;
        }
    }
-    arduino_usb_hid_vendor_event_data_t p = {0};
+    arduino_usb_hid_vendor_event_data_t p;
    p.buffer = buffer;
    p.len = len;
    arduino_usb_event_post(ARDUINO_USB_HID_VENDOR_EVENTS, ARDUINO_USB_HID_VENDOR_OUTPUT_EVENT, &p, sizeof(arduino_usb_hid_vendor_event_data_t), portMAX_DELAY);
--- a/libraries/USB/src/USBVendor.cpp
+++ b/libraries/USB/src/USBVendor.cpp
@ -40,8 +40,8 @@ uint16_t tusb_vendor_load_descriptor(uint8_t * dst, uint8_t * itf)
 }

 void tud_vendor_rx_cb(uint8_t itf){
-    log_v("%u", len);
    size_t len = tud_vendor_n_available(itf);
+    log_v("%u", len);
    if(len){
        uint8_t buffer[len];
        len = tud_vendor_n_read(itf, buffer, len);
@ -146,7 +146,7 @@ void USBVendor::_onRX(const uint8_t* buffer, size_t len){
            break;
        }
    }
-    arduino_usb_vendor_event_data_t p = {0};
+    arduino_usb_vendor_event_data_t p;
    p.data.len = len;
    arduino_usb_event_post(ARDUINO_USB_VENDOR_EVENTS, ARDUINO_USB_VENDOR_DATA_EVENT, &p, sizeof(arduino_usb_vendor_event_data_t), portMAX_DELAY);
 }
--- a/libraries/WebServer/examples/SDWebServer/SDWebServer.ino
+++ b/libraries/WebServer/examples/SDWebServer/SDWebServer.ino
@ -25,6 +25,8 @@
  index.htm is the default index (works on subfolders as well)

  upload the contents of SdRoot to the root of the SDcard and access the editor by going to http://esp8266sd.local/edit
+  To retrieve the contents of SDcard, visit http://esp32sd.local/list?dir=/
+      dir is the argument that needs to be passed to the function PrintDirectory via HTTP Get request.

 */
 #include <WiFi.h>
--- a/libraries/WiFi/src/ETH.cpp
+++ b/libraries/WiFi/src/ETH.cpp
@ -237,12 +237,6 @@ bool ETHClass::begin(uint8_t phy_addr, int power, int mdc, int mdio, eth_phy_typ
    esp_netif_config_t cfg = ESP_NETIF_DEFAULT_ETH();
    esp_netif_t *eth_netif = esp_netif_new(&cfg);

-    if(esp_eth_set_default_handlers(eth_netif) != ESP_OK){
-        log_e("esp_eth_set_default_handlers failed");
-        return false;
-    }
-    
-    
    esp_eth_mac_t *eth_mac = NULL;
 #if CONFIG_ETH_SPI_ETHERNET_DM9051
    if(type == ETH_PHY_DM9051){
@ -288,7 +282,12 @@ bool ETHClass::begin(uint8_t phy_addr, int power, int mdc, int mdio, eth_phy_typ
            break;
 #endif
        case ETH_PHY_KSZ8081:
+#if ESP_IDF_VERSION > ESP_IDF_VERSION_VAL(4,3,0)
            eth_phy = esp_eth_phy_new_ksz8081(&phy_config);
+#else
+            log_e("unsupported ethernet type 'ETH_PHY_KSZ8081'");
+#endif
+            break;
        default:
            break;
    }
--- a/libraries/WiFi/src/WiFiGeneric.cpp
+++ b/libraries/WiFi/src/WiFiGeneric.cpp
@ -542,6 +542,20 @@ bool tcpipInit(){
 * */

 static bool lowLevelInitDone = false;
+bool WiFiGenericClass::_wifiUseStaticBuffers = false;
+
+bool WiFiGenericClass::useStaticBuffers(){
+    return _wifiUseStaticBuffers;
+}
+
+void WiFiGenericClass::useStaticBuffers(bool bufferMode){
+    if (lowLevelInitDone) {
+        log_w("WiFi already started. Call WiFi.mode(WIFI_MODE_NULL) before setting Static Buffer Mode.");
+    } 
+    _wifiUseStaticBuffers = bufferMode;
+}
+
+
 bool wifiLowLevelInit(bool persistent){
    if(!lowLevelInitDone){
        lowLevelInitDone = true;
@ -557,6 +571,16 @@ bool wifiLowLevelInit(bool persistent){
        }

        wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
+
+	if(!WiFiGenericClass::useStaticBuffers()) {
+	    cfg.static_tx_buf_num = 0;
+            cfg.dynamic_tx_buf_num = 32;
+	    cfg.tx_buf_type = 1;
+            cfg.cache_tx_buf_num = 1;  // can't be zero!
+	    cfg.static_rx_buf_num = 4;
+            cfg.dynamic_rx_buf_num = 32;
+        }
+
        esp_err_t err = esp_wifi_init(&cfg);
        if(err){
            log_e("esp_wifi_init %d", err);
@ -644,7 +668,6 @@ wifi_ps_type_t WiFiGenericClass::_sleepEnabled = WIFI_PS_MIN_MODEM;

 WiFiGenericClass::WiFiGenericClass() 
 {
-
 }

 const char * WiFiGenericClass::getHostname()
--- a/libraries/WiFi/src/WiFiGeneric.h
+++ b/libraries/WiFi/src/WiFiGeneric.h
@ -180,11 +180,15 @@ class WiFiGenericClass

    static esp_err_t _eventCallback(arduino_event_t *event);
    
+    static void useStaticBuffers(bool bufferMode);
+    static bool useStaticBuffers();
+
  protected:
    static bool _persistent;
    static bool _long_range;
    static wifi_mode_t _forceSleepLastMode;
    static wifi_ps_type_t _sleepEnabled;
+    static bool _wifiUseStaticBuffers;

    static int setStatusBits(int bits);
    static int clearStatusBits(int bits);
--- a/libraries/WiFiClientSecure/README.md
+++ b/libraries/WiFiClientSecure/README.md
@ -66,3 +66,18 @@ To use PSK:
  encryption for the connection

 Please see the WiFiClientPSK example.
+
+Specifying the ALPN Protocol
+----------------------------
+
+Application-Layer Protocol Negotiation (ALPN) is a Transport Layer Security (TLS) extension that allows 
+the application layer to negotiate which protocol should be performed over a secure connection in a manner 
+that avoids additional round trips and which is independent of the application-layer protocols.
+
+For example, this is used with AWS IoT Custom Authorizers where an MQTT client must set the ALPN protocol to ```mqtt```: 
+
+```
+const char *aws_protos[] = {"mqtt", NULL};
+...
+wiFiClient.setAlpnProtocols(aws_protos);
+```
--- a/libraries/WiFiClientSecure/examples/WiFiClientShowPeerCredentials/WiFiClientShowPeerCredentials.ino
+++ b/libraries/WiFiClientSecure/examples/WiFiClientShowPeerCredentials/WiFiClientShowPeerCredentials.ino
@ -0,0 +1,97 @@
+// WiFiClientShowPeerCredentials
+//
+// Example of a establishing a secure connection and then
+// showing the fingerprint of the certificate. This can
+// be useful in an IoT setting to know for sure that you
+// are connecting to the right server. Especally in 
+// situations where you cannot hardcode a trusted root
+// certificate for long periods of time (as they tend to
+// get replaced more often than the lifecycle of IoT
+// hardware).
+//
+
+#include <WiFi.h>
+#include <HTTPClient.h>
+#include <WiFiClientSecure.h>
+
+#ifndef WIFI_NETWORK
+#define WIFI_NETWORK "MyWifiNetwork"
+#endif
+
+#ifndef WIFI_PASSWD
+#define WIFI_PASSWD "MySecretWifiPassword"
+#endif
+
+#define URL "https://arduino.cc"
+
+void demo() {
+  WiFiClientSecure *client = new WiFiClientSecure;
+  client->setInsecure(); // 
+
+  HTTPClient https;
+  if (!https.begin(*client, URL )) {
+    Serial.println("HTTPS setup failed");
+    return;
+  };
+
+  https.setTimeout(5000);
+
+  int httpCode = https.GET();
+  if (httpCode != 200) {
+    Serial.print("Connect failed: ");
+    Serial.println(https.errorToString(httpCode));
+    return;
+  }
+
+  const mbedtls_x509_crt* peer = client->getPeerCertificate();
+
+  // Show general output / certificate information
+  //
+  char buf[1024];
+  int l = mbedtls_x509_crt_info (buf, sizeof(buf), "", peer);
+  if (l <= 0) {
+    Serial.println("Peer conversion to printable buffer failed");
+    return;
+  };
+  Serial.println();
+  Serial.println(buf);
+
+  uint8_t fingerprint_remote[32];
+  if (!client->getFingerprintSHA256(fingerprint_remote)) {
+    Serial.println("Failed to get the fingerprint");
+    return;
+  }
+  // Fingerprint late 2021
+  Serial.println("Expecting Fingerprint (SHA256): 70 CF A4 B7 5D 09 E9 2A 52 A8 B6 85 B5 0B D6 BE 83 47 83 5B 3A 4D 3C 3E 32 30 EC 1D 61 98 D7 0F");
+  Serial.print(  " Received Fingerprint (SHA256): ");
+
+  for (int i = 0; i < 32; i++) {
+    Serial.print(fingerprint_remote[i], HEX);
+    Serial.print(" ");
+  };
+  Serial.println("");
+};
+
+void setup() {
+  Serial.begin(115200);
+  Serial.println("Started " __FILE__ " build " __DATE__ " " __TIME__);
+
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(WIFI_NETWORK, WIFI_PASSWD);
+
+  while (WiFi.waitForConnectResult() != WL_CONNECTED) {
+    Serial.println("Wifi fail - rebooting");
+    delay(5000);
+    ESP.restart();
+  }
+}
+
+void loop() {
+  bool already_tried = false;
+  if ((millis() < 1000) || already_tried)
+    return;
+  already_tried = true;
+
+  // Run the test just once.
+  demo();
+}
--- a/libraries/WiFiClientSecure/keywords.txt
+++ b/libraries/WiFiClientSecure/keywords.txt
@ -29,6 +29,7 @@ connected	KEYWORD2
 setCACert	KEYWORD2
 setCertificate	KEYWORD2
 setPrivateKey	KEYWORD2
+setAlpnProtocols	KEYWORD2

 #######################################
 # Constants (LITERAL1)
--- a/libraries/WiFiClientSecure/src/WiFiClientSecure.cpp
+++ b/libraries/WiFiClientSecure/src/WiFiClientSecure.cpp
@ -43,6 +43,7 @@ WiFiClientSecure::WiFiClientSecure()
    _pskIdent = NULL;
    _psKey = NULL;
    next = NULL;
+    _alpn_protos = NULL;
 }


@ -66,6 +67,7 @@ WiFiClientSecure::WiFiClientSecure(int sock)
    _pskIdent = NULL;
    _psKey = NULL;
    next = NULL;
+    _alpn_protos = NULL;
 }

 WiFiClientSecure::~WiFiClientSecure()
@ -127,7 +129,7 @@ int WiFiClientSecure::connect(const char *host, uint16_t port, const char *CA_ce
    if(_timeout > 0){
        sslclient->handshake_timeout = _timeout;
    }
-    int ret = start_ssl_client(sslclient, host, port, _timeout, CA_cert, cert, private_key, NULL, NULL, _use_insecure);
+    int ret = start_ssl_client(sslclient, host, port, _timeout, CA_cert, cert, private_key, NULL, NULL, _use_insecure, _alpn_protos);
    _lastError = ret;
    if (ret < 0) {
        log_e("start_ssl_client: %d", ret);
@ -147,7 +149,7 @@ int WiFiClientSecure::connect(const char *host, uint16_t port, const char *pskId
    if(_timeout > 0){
        sslclient->handshake_timeout = _timeout;
    }
-    int ret = start_ssl_client(sslclient, host, port, _timeout, NULL, NULL, NULL, pskIdent, psKey, _use_insecure);
+    int ret = start_ssl_client(sslclient, host, port, _timeout, NULL, NULL, NULL, pskIdent, psKey, _use_insecure, _alpn_protos);
    _lastError = ret;
    if (ret < 0) {
        log_e("start_ssl_client: %d", ret);
@ -341,3 +343,8 @@ void WiFiClientSecure::setHandshakeTimeout(unsigned long handshake_timeout)
 {
    sslclient->handshake_timeout = handshake_timeout * 1000;
 }
+
+void WiFiClientSecure::setAlpnProtocols(const char **alpn_protos)
+{
+    _alpn_protos = alpn_protos;
+}
--- a/libraries/WiFiClientSecure/src/WiFiClientSecure.h
+++ b/libraries/WiFiClientSecure/src/WiFiClientSecure.h
@ -39,6 +39,7 @@ protected:
    const char *_private_key;
    const char *_pskIdent; // identity for PSK cipher suites
    const char *_psKey; // key in hex for PSK cipher suites
+    const char **_alpn_protos;

 public:
    WiFiClientSecure *next;
@ -73,7 +74,9 @@ public:
    bool loadPrivateKey(Stream& stream, size_t size);
    bool verify(const char* fingerprint, const char* domain_name);
    void setHandshakeTimeout(unsigned long handshake_timeout);
-
+    void setAlpnProtocols(const char **alpn_protos);
+    const mbedtls_x509_crt* getPeerCertificate() { return mbedtls_ssl_get_peer_cert(&sslclient->ssl_ctx); };
+    bool getFingerprintSHA256(uint8_t sha256_result[32]) { return get_peer_fingerprint(sslclient, sha256_result); };
    int setTimeout(uint32_t seconds){ return 0; }

    operator bool()
--- a/libraries/WiFiClientSecure/src/ssl_client.cpp
+++ b/libraries/WiFiClientSecure/src/ssl_client.cpp
@ -51,7 +51,7 @@ void ssl_init(sslclient_context *ssl_client)
 }


-int start_ssl_client(sslclient_context *ssl_client, const char *host, uint32_t port, int timeout, const char *rootCABuff, const char *cli_cert, const char *cli_key, const char *pskIdent, const char *psKey, bool insecure)
+int start_ssl_client(sslclient_context *ssl_client, const char *host, uint32_t port, int timeout, const char *rootCABuff, const char *cli_cert, const char *cli_key, const char *pskIdent, const char *psKey, bool insecure, const char **alpn_protos)
 {
    char buf[512];
    int ret, flags;
@ -156,6 +156,13 @@ int start_ssl_client(sslclient_context *ssl_client, const char *host, uint32_t p
        return handle_error(ret);
    }

+    if (alpn_protos != NULL) {
+        log_v("Setting ALPN protocols");
+        if ((ret = mbedtls_ssl_conf_alpn_protocols(&ssl_client->ssl_conf, alpn_protos) ) != 0) {
+            return handle_error(ret);
+        }
+    }
+
    // MBEDTLS_SSL_VERIFY_REQUIRED if a CA certificate is defined on Arduino IDE and
    // MBEDTLS_SSL_VERIFY_NONE if not.

@ -418,22 +425,10 @@ bool verify_ssl_fingerprint(sslclient_context *ssl_client, const char* fp, const
        fingerprint_local[i] = low | (high << 4);
    }

-    // Get certificate provided by the peer
-    const mbedtls_x509_crt* crt = mbedtls_ssl_get_peer_cert(&ssl_client->ssl_ctx);
-
-    if (!crt)
-    {
-        log_d("could not fetch peer certificate");
-        return false;
-    }
-
    // Calculate certificate's SHA256 fingerprint
    uint8_t fingerprint_remote[32];
-    mbedtls_sha256_context sha256_ctx;
-    mbedtls_sha256_init(&sha256_ctx);
-    mbedtls_sha256_starts(&sha256_ctx, false);
-    mbedtls_sha256_update(&sha256_ctx, crt->raw.p, crt->raw.len);
-    mbedtls_sha256_finish(&sha256_ctx, fingerprint_remote);
+    if(!get_peer_fingerprint(ssl_client, fingerprint_remote)) 
+        return false;

    // Check if fingerprints match
    if (memcmp(fingerprint_local, fingerprint_remote, 32))
@ -449,6 +444,28 @@ bool verify_ssl_fingerprint(sslclient_context *ssl_client, const char* fp, const
        return true;
 }

+bool get_peer_fingerprint(sslclient_context *ssl_client, uint8_t sha256[32]) 
+{
+    if (!ssl_client) {
+        log_d("Invalid ssl_client pointer");
+        return false;
+    };
+
+    const mbedtls_x509_crt* crt = mbedtls_ssl_get_peer_cert(&ssl_client->ssl_ctx);
+    if (!crt) {
+        log_d("Failed to get peer cert.");
+        return false;
+    };
+
+    mbedtls_sha256_context sha256_ctx;
+    mbedtls_sha256_init(&sha256_ctx);
+    mbedtls_sha256_starts(&sha256_ctx, false);
+    mbedtls_sha256_update(&sha256_ctx, crt->raw.p, crt->raw.len);
+    mbedtls_sha256_finish(&sha256_ctx, sha256);
+
+    return true;
+}
+
 // Checks if peer certificate has specified domain in CN or SANs
 bool verify_ssl_dn(sslclient_context *ssl_client, const char* domain_name)
 {
--- a/libraries/WiFiClientSecure/src/ssl_client.h
+++ b/libraries/WiFiClientSecure/src/ssl_client.h
@ -29,12 +29,12 @@ typedef struct sslclient_context {


 void ssl_init(sslclient_context *ssl_client);
-int start_ssl_client(sslclient_context *ssl_client, const char *host, uint32_t port, int timeout, const char *rootCABuff, const char *cli_cert, const char *cli_key, const char *pskIdent, const char *psKey, bool insecure);
+int start_ssl_client(sslclient_context *ssl_client, const char *host, uint32_t port, int timeout, const char *rootCABuff, const char *cli_cert, const char *cli_key, const char *pskIdent, const char *psKey, bool insecure, const char **alpn_protos);
 void stop_ssl_socket(sslclient_context *ssl_client, const char *rootCABuff, const char *cli_cert, const char *cli_key);
 int data_to_read(sslclient_context *ssl_client);
 int send_ssl_data(sslclient_context *ssl_client, const uint8_t *data, size_t len);
 int get_ssl_receive(sslclient_context *ssl_client, uint8_t *data, int length);
 bool verify_ssl_fingerprint(sslclient_context *ssl_client, const char* fp, const char* domain_name);
 bool verify_ssl_dn(sslclient_context *ssl_client, const char* domain_name);
-
+bool get_peer_fingerprint(sslclient_context *ssl_client, uint8_t sha256[32]);
 #endif
--- a/libraries/Wire/doc/i2c_debugging.md
+++ b/libraries/Wire/doc/i2c_debugging.md
@ -1,276 +0,0 @@
-# Debugging I2C
-
-With the release of Arduino-ESP32 V1.0.1 the I2C subsystem contains code to exhaustively report communication errors.  
-* Basic debugging can be enable by setting the *CORE DEBUG LEVEL* at or above *ERROR*. All errors will be directed the the *DEBUG OUTPUT* normally connected to `Serial()`.  
-* Enhanced debugging can be used to generate specified information at specific positions during the i2c communication sequence. Increase *CORE DEBUG LEVEL* to ***DEBUG***
-
-## Enable Debug Buffer
-The Enhanced debug features are enabled by uncommenting the `\\#define ENABLE_I2C_DEBUG_BUFFER` at line 45 of `esp32-hal-i2c.c`.  
-* When Arduino-Esp32 is installed in Windows with Arduino Boards Manager, `esp32-hal-i2c.c` can be found in:
-`C:\Users\{user}\AppData\Local\Arduino15\packages\esp32\hardware\esp32\1.0.1\cores\esp32\`
-* When Arduino-Esp32 Development version is installed from GitHub, `esp32-hal-i2c.c` can be found in:
-`{arduino Sketch}\hardware\espressif\esp32\cores\esp32\`
-
-
-```c++ 
-//#define ENABLE_I2C_DEBUG_BUFFER
-```
-Change it to:
-```c++ 
-#define ENABLE_I2C_DEBUG_BUFFER
-```
-and recompile/upload the resulting code to your ESP32.
-
-Enabling this `#define` will consume an additional 2570 bytes of RAM and include a commensurate amount of code FLASH. If you see the message `"Debug Buffer not Enabled"` in your console log I would suggest you un-comment the line and regenerate the error.  Additional information will be supplied on the log console.
-
-## Manually controlled Debugging
-Manual logging of the i2c control data buffers can be accomplished by using the debug control function of `Wire()`:
-```c++
-    uint32_t setDebugFlags( uint32_t setBits, uint32_t resetBits);
-```
-`setBits`, and `resetBits` manually cause output of the control structures to the log console.   They are bit fields that enable/disable the reporting of individual control structures during specific phases of the i2c communications sequence.  The 32bit values are divided into four 8bit fields.  Currently only five bits are defined. ***If an error is detected during normal operations, the relevant control structure will bit added to the log irrespective of the current debug flags.***
-
-* **bit 0** causes DumpI2c to execute 
-header information about current communications event,
-and the dataQueue elements showing the logical i2c transaction commands
-* **bit 1** causes DumpInts to execute
-Actual sequence of interrupts handled during last communications event, cleared on entry into `ProcQueue()`.
-* **bit 2** causes DumpCmdqueue to execute
-The last block of commands to the i2c peripheral.
-* **bit 3** causes DumpStatus to execute
-A descriptive display of the 32bit i2c peripheral status word.
-* **bit 4** causes DumpFifo to execute
-A buffer listing the sequence of data added to the txFifo of the i2c peripheral.
-
-Of the four division, only three are currently implemented:
-* 0xXX - - - - - - : at entry of ProcQueue (`bitFlags << 24`)
-* 0x - - XX - - - - : at exit of ProcQueue (`bitFlags << 16`)
-* 0x - - - - - - XX : at entry of Flush    (`bitFlags`)
- 
-For example, to display the sequence of Interrupts processed during the i2c communication transaction, **bit 1** would be set, and, since this information on Interrupt usage would only be valid after the communications have completed, the locus would be *at exit of ProcQueue*.  The following code would be necessary.
-### code
-```c++
-uint8_t flag = 1 << 1; // turn on bit 1
-uint32_t debugFlag = flag << 16; // correctly position the 8bits of flag as the second byte of setBits.
-Wire.setDebugFlags(debugFlag,0);// resetBits=0 says leave all current setBits as is.
-
-Wire.requestFrom(id,byteCount); // read byteCount bytes from slave at id 
-
-Wire.setDebugFlags(0,debugFlag); // don't add any new debug, remove debugFlag
-``` 
-### output of log console
-```
-[I][esp32-hal-i2c.c:437] i2cTriggerDumps(): after ProcQueue
-[I][esp32-hal-i2c.c:346] i2cDumpInts(): 0 row	count	INTR	TX	RX	Tick 
-[I][esp32-hal-i2c.c:350] i2cDumpInts(): [01]	0x0001	0x0002	0x0003	0x0000	0x005baac5
-[I][esp32-hal-i2c.c:350] i2cDumpInts(): [02]	0x0001	0x0200	0x0000	0x0000	0x005baac5
-[I][esp32-hal-i2c.c:350] i2cDumpInts(): [03]	0x0001	0x0080	0x0000	0x0008	0x005baac6
-```    
-# Debug Log example
-### Code
-To read eight bytes of data from a DS1307 RTCC
-```
-    uint32_t debugFlag = 0x001F0000;
-    uint8_t ID = 0x68;
-    uint8_t block=8;
-    
-    if(debugFlag >0){
-        Wire.setDebugFlags(debugFlag,0);
-    }
-
-    Wire.beginTransmission(ID);
-    Wire.write(lowByte(addr));
-    if((err=Wire.endTransmission(false))!=0)    {
-        Serial.printf(" EndTransmission=%d(%s)",Wire.lastError(),Wire.getErrorText(Wire.lastError()));
-
-        if(err!=2) {
-            Serial.printf(", resetting\n");
-            if( !Wire.begin()) Serial.printf(" Reset Failed\n");
-            if(debugFlag >0) Wire.setDebugFlags(0,debugFlag);
-            return;
-        } else {
-            Serial.printf(", No Device present, aborting\n");
-            currentCommand= NO_COMMAND;
-            return;
-        }
-    }
-    err = Wire.requestFrom(ID,block,true);
-    if(debugFlag >0){
-        Wire.setDebugFlags(0,debugFlag);
-    }
-```
-### output of log console
-```
-[I][esp32-hal-i2c.c:437] i2cTriggerDumps(): after ProcQueue
-[E][esp32-hal-i2c.c:318] i2cDumpI2c(): i2c=0x3ffbdc78
-[I][esp32-hal-i2c.c:319] i2cDumpI2c(): dev=0x60013000 date=0x16042000
-[I][esp32-hal-i2c.c:321] i2cDumpI2c(): lock=0x3ffb843c
-[I][esp32-hal-i2c.c:323] i2cDumpI2c(): num=0
-[I][esp32-hal-i2c.c:324] i2cDumpI2c(): mode=1
-[I][esp32-hal-i2c.c:325] i2cDumpI2c(): stage=3
-[I][esp32-hal-i2c.c:326] i2cDumpI2c(): error=1
-[I][esp32-hal-i2c.c:327] i2cDumpI2c(): event=0x3ffb85c4 bits=10
-[I][esp32-hal-i2c.c:328] i2cDumpI2c(): intr_handle=0x3ffb85f4
-[I][esp32-hal-i2c.c:329] i2cDumpI2c(): dq=0x3ffb858c
-[I][esp32-hal-i2c.c:330] i2cDumpI2c(): queueCount=2
-[I][esp32-hal-i2c.c:331] i2cDumpI2c(): queuePos=1
-[I][esp32-hal-i2c.c:332] i2cDumpI2c(): errorByteCnt=0
-[I][esp32-hal-i2c.c:333] i2cDumpI2c(): errorQueue=0
-[I][esp32-hal-i2c.c:334] i2cDumpI2c(): debugFlags=0x001F0000
-[I][esp32-hal-i2c.c:288] i2cDumpDqData(): [0] 7bit 68 W  buf@=0x3ffc04b2, len=1, pos=1, ctrl=11101
-[I][esp32-hal-i2c.c:306] i2cDumpDqData(): 0x0000: .                                00 
-[I][esp32-hal-i2c.c:288] i2cDumpDqData(): [1] 7bit 68 R STOP buf@=0x3ffc042c, len=8, pos=8, ctrl=11111
-[I][esp32-hal-i2c.c:306] i2cDumpDqData(): 0x0000: 5P......                         35 50 07 06 13 09 18 00 
-[I][esp32-hal-i2c.c:346] i2cDumpInts(): 0 row	count	INTR	TX	RX	Tick 
-[I][esp32-hal-i2c.c:350] i2cDumpInts(): [01]	0x0001	0x0002	0x0003	0x0000	0x000073d5
-[I][esp32-hal-i2c.c:350] i2cDumpInts(): [02]	0x0001	0x0200	0x0000	0x0000	0x000073d5
-[I][esp32-hal-i2c.c:350] i2cDumpInts(): [03]	0x0001	0x0080	0x0000	0x0008	0x000073d6
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [ 0]	Y	RSTART	val[0]	exp[0]	en[0]	bytes[0]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [ 1]	Y	WRITE	val[0]	exp[0]	en[1]	bytes[1]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [ 2]	Y	WRITE	val[0]	exp[0]	en[1]	bytes[1]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [ 3]	Y	RSTART	val[0]	exp[0]	en[0]	bytes[0]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [ 4]	Y	WRITE	val[0]	exp[0]	en[1]	bytes[1]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [ 5]	Y	READ	val[0]	exp[0]	en[0]	bytes[7]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [ 6]	Y	READ	val[1]	exp[0]	en[0]	bytes[1]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [ 7]	Y	STOP	val[0]	exp[0]	en[0]	bytes[0]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [ 8]	N	RSTART	val[0]	exp[0]	en[0]	bytes[0]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [ 9]	N	RSTART	val[0]	exp[0]	en[0]	bytes[0]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [10]	N	RSTART	val[0]	exp[0]	en[0]	bytes[0]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [11]	N	RSTART	val[0]	exp[0]	en[0]	bytes[0]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [12]	N	RSTART	val[0]	exp[0]	en[0]	bytes[0]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [13]	N	RSTART	val[0]	exp[0]	en[0]	bytes[0]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [14]	N	RSTART	val[0]	exp[0]	en[0]	bytes[0]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [15]	N	RSTART	val[0]	exp[0]	en[0]	bytes[0]
-[I][esp32-hal-i2c.c:385] i2cDumpStatus(): ack(0) sl_rw(0) to(0) arb(0) busy(0) sl(1) trans(0) rx(0) tx(0) sclMain(5) scl(6)
-[I][esp32-hal-i2c.c:424] i2cDumpFifo(): WRITE 0x68   0 
-[I][esp32-hal-i2c.c:424] i2cDumpFifo(): READ  0x68
-```
-## Explaination of log output
-### DumpI2c
-```
-[I][esp32-hal-i2c.c:437] i2cTriggerDumps(): after ProcQueue
-[E][esp32-hal-i2c.c:318] i2cDumpI2c(): i2c=0x3ffbdc78
-[I][esp32-hal-i2c.c:319] i2cDumpI2c(): dev=0x60013000 date=0x16042000
-[I][esp32-hal-i2c.c:321] i2cDumpI2c(): lock=0x3ffb843c
-[I][esp32-hal-i2c.c:323] i2cDumpI2c(): num=0
-[I][esp32-hal-i2c.c:324] i2cDumpI2c(): mode=1
-[I][esp32-hal-i2c.c:325] i2cDumpI2c(): stage=3
-[I][esp32-hal-i2c.c:326] i2cDumpI2c(): error=1
-[I][esp32-hal-i2c.c:327] i2cDumpI2c(): event=0x3ffb85c4 bits=10
-[I][esp32-hal-i2c.c:328] i2cDumpI2c(): intr_handle=0x3ffb85f4
-[I][esp32-hal-i2c.c:329] i2cDumpI2c(): dq=0x3ffb858c
-[I][esp32-hal-i2c.c:330] i2cDumpI2c(): queueCount=2
-[I][esp32-hal-i2c.c:331] i2cDumpI2c(): queuePos=1
-[I][esp32-hal-i2c.c:332] i2cDumpI2c(): errorByteCnt=0
-[I][esp32-hal-i2c.c:333] i2cDumpI2c(): errorQueue=0
-[I][esp32-hal-i2c.c:334] i2cDumpI2c(): debugFlags=0x001F0000
-```
-variable | description
---- | ----
-**i2c** | *memory address for control block*
-**dev** | *memory address for access to i2c peripheral registers*
-**date** | *revision date of peripheral silicon 2016, 42 week*
-**lock** | *hal lock handle*
-**num** | *0,1 which peripheral is being controlled*
-**mode** | *configuration of driver 0=none, 1=MASTER, 2=SLAVE, 3=MASTER and SLAVE*
-**stage** | *internal STATE of driver 0=not configured, 1=startup, 2=running, 3=done*
-**error** | *internal ERROR status 0=not configured, 1=ok, 2=error, 3=address NAK, 4=data NAK, 5=arbitration loss, 6=timeout*
-**event** | *handle for interprocess FreeRTOS eventSemaphore for communication between ISR and APP*
-**intr_handle** | *FreeRTOS handle for allocated interrupt*
-**dq** | *memory address for data queue control block*
-**queueCount** | *number of data operations in queue control block*
-**queuePos** | *last executed data block*
-**errorByteCnt** | *position in current data block when error occured -1=address byte*
-**errorQueue** | *queue that was executing when error occurred*
-**debugFlags** | *current specified error bits*
-
-### DQ data
-```
-[I][esp32-hal-i2c.c:288] i2cDumpDqData(): [0] 7bit 68 W  buf@=0x3ffc04b2, len=1, pos=1, ctrl=11101
-[I][esp32-hal-i2c.c:306] i2cDumpDqData(): 0x0000: .                                00 
-[I][esp32-hal-i2c.c:288] i2cDumpDqData(): [1] 7bit 68 R STOP buf@=0x3ffc042c, len=8, pos=8, ctrl=11111
-[I][esp32-hal-i2c.c:306] i2cDumpDqData(): 0x0000: 5P......                         35 50 07 06 13 09 18 00 
-```
-variable | description
--- | ---
-**[n]** | *index of data queue element*
-**i2c address** | *7bit= 7bit i2c slave address, 10bit= 10bit i2c slave address*
-**direction** | *W=Write, R=READ*
-**STOP** | *command issued a I2C STOP, else if blank, a RESTART was issued by next dq element.*
-**buf@** | *pointer to data buffer*
-**len** | *length of data buffer*
-**pos** | *last position used in buffer*
-**ctrl** | *bit field for data queue control, this bits describe if all necessary commands have been added to peripheral command buffer. in order(START,ADDRESS_Write,DATA,STOP,ADDRESS_value*
-**0xnnnn** | *data buffer content, displayable followed by HEX, 32 bytes on a line.*
- 
-### DumpInts
-```
-[I][esp32-hal-i2c.c:346] i2cDumpInts(): 0 row	count	INTR	TX	RX	Tick 
-[I][esp32-hal-i2c.c:350] i2cDumpInts(): [01]	0x0001	0x0002	0x0003	0x0000	0x000073d5
-[I][esp32-hal-i2c.c:350] i2cDumpInts(): [02]	0x0001	0x0200	0x0000	0x0000	0x000073d5
-[I][esp32-hal-i2c.c:350] i2cDumpInts(): [03]	0x0001	0x0080	0x0000	0x0008	0x000073d6
-```
-variable | description
---- | ----
-**row** | *array index*
-**count** | *number of consecutive, duplicate interrupts*
-**INTR** | *bit value of active interrupt (from ..\esp32\tools\sdk\include\soc\soc\i2c_struct.h)*
-**TX** | *number of bytes added to txFifo*
-**RX** | *number of bytes read from rxFifo*
-**Tick** | *current tick counter from xTaskGetTickCountFromISR()*
-
-### DumpCmdQueue
-```
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [ 0]	Y	RSTART	val[0]	exp[0]	en[0]	bytes[0]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [ 1]	Y	WRITE	val[0]	exp[0]	en[1]	bytes[1]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [ 2]	Y	WRITE	val[0]	exp[0]	en[1]	bytes[1]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [ 3]	Y	RSTART	val[0]	exp[0]	en[0]	bytes[0]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [ 4]	Y	WRITE	val[0]	exp[0]	en[1]	bytes[1]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [ 5]	Y	READ	val[0]	exp[0]	en[0]	bytes[7]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [ 6]	Y	READ	val[1]	exp[0]	en[0]	bytes[1]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [ 7]	Y	STOP	val[0]	exp[0]	en[0]	bytes[0]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [ 8]	N	RSTART	val[0]	exp[0]	en[0]	bytes[0]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [ 9]	N	RSTART	val[0]	exp[0]	en[0]	bytes[0]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [10]	N	RSTART	val[0]	exp[0]	en[0]	bytes[0]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [11]	N	RSTART	val[0]	exp[0]	en[0]	bytes[0]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [12]	N	RSTART	val[0]	exp[0]	en[0]	bytes[0]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [13]	N	RSTART	val[0]	exp[0]	en[0]	bytes[0]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [14]	N	RSTART	val[0]	exp[0]	en[0]	bytes[0]
-[E][esp32-hal-i2c.c:243] i2cDumpCmdQueue(): [15]	N	RSTART	val[0]	exp[0]	en[0]	bytes[0]
-```
-Column | description
---- | ----
-**command** | *RSTART= generate i2c START sequence, WRITE= output byte(s), READ= input byte(s), STOP= generate i2c STOP sequence, END= continuation flag for peripheral to pause execution waiting for a refilled command list*
-**val** | *value for ACK bit, 0 = LOW, 1= HIGH*
-**exp** | *test of ACK bit 0=no, 1=yes*
-**en** | *output of val, 0=no, 1=yes*
-**bytes** | *number of byte to send(WRITE) or receive(READ) 1..255*
- 
-### DumpStatus
-```
-[I][esp32-hal-i2c.c:385] i2cDumpStatus(): ack(0) sl_rw(0) to(0) arb(0) busy(0) sl(1) trans(0) rx(0) tx(0) sclMain(5) scl(6)
-```
-variable | description
---- | ----
-**ack** | *last value for ACK bit*
-**sl_rw** | *mode for SLAVE operation 0=write, 1=read*
-**to** | *timeout*
-**arb** | *arbitration loss*
-**busy** | *bus is inuse by other Master, or SLAVE is holding SCL,SDA*
-**sl** | *last address on bus was equal to slave_addr*
-**trans** | *a byte has moved though peripheral*
-**rx** | *count of bytes in rxFifo*
-**tx** | *count of bytes in txFifo*
-**sclMain** | *state machine for i2c module.  0: SCL_MAIN_IDLE,  1: SCL_ADDRESS_SHIFT, 2: SCL_ACK_ADDRESS, 3: SCL_RX_DATA, 4: SCL_TX_DATA, 5: SCL_SEND_ACK, 6 :SCL_WAIT_ACK*
-**scl** | *SCL clock state. 0: SCL_IDLE, 1: SCL_START, 2: SCL_LOW_EDGE, 3: SCL_LOW, 4: SCL_HIGH_EDGE, 5: SCL_HIGH, 6:SCL_STOP*
-
-### DumpFifo
-```
-[I][esp32-hal-i2c.c:424] i2cDumpFifo(): WRITE 0x68   0 
-[I][esp32-hal-i2c.c:424] i2cDumpFifo(): READ  0x68
-```
-Mode | datavalues
--- | ---
-**WRITE** | the following bytes added to the txFifo are in response to a WRITE command
-**READ** | the following bytes added to the txFifo are in response to a READ command
-
--- a/libraries/Wire/examples/WireMaster/WireMaster.ino
+++ b/libraries/Wire/examples/WireMaster/WireMaster.ino
@ -0,0 +1,30 @@
+#include "Wire.h"
+
+#define I2C_DEV_ADDR 0x55
+
+uint32_t i = 0;
+
+void setup() {
+  Serial.begin(115200);
+  Serial.setDebugOutput(true);
+  Wire.begin();
+}
+
+void loop() {
+  delay(5000);
+
+  //Write message to the slave
+  Wire.beginTransmission(I2C_DEV_ADDR);
+  Wire.printf("Hello World! %u", i++);
+  uint8_t error = Wire.endTransmission(true);
+  Serial.printf("endTransmission: %u\n", error);
+  
+  //Read 16 bytes from the slave
+  error = Wire.requestFrom(I2C_DEV_ADDR, 16);
+  Serial.printf("requestFrom: %u\n", error);
+  if(error){
+    uint8_t temp[error];
+    Wire.readBytes(temp, error);
+    log_print_buf(temp, error);
+  }
+}
--- a/libraries/Wire/examples/WireScan/WireScan.ino
+++ b/libraries/Wire/examples/WireScan/WireScan.ino
@ -0,0 +1,28 @@
+#include "Wire.h"
+
+void setup() {
+  Serial.begin(115200);
+  Wire.begin();
+}
+
+void loop() {
+  byte error, address;
+  int nDevices = 0;
+
+  delay(5000);
+
+  Serial.println("Scanning for I2C devices ...");
+  for(address = 0x01; address < 0x7f; address++){
+    Wire.beginTransmission(address);
+    error = Wire.endTransmission();
+    if (error == 0){
+      Serial.printf("I2C device found at address 0x%02X\n", address);
+      nDevices++;
+    } else if(error != 2){
+      Serial.printf("Error %d at address 0x%02X\n", error, address);
+    }
+  }
+  if (nDevices == 0){
+    Serial.println("No I2C devices found");
+  }
+}
--- a/libraries/Wire/examples/WireSlave/WireSlave.ino
+++ b/libraries/Wire/examples/WireSlave/WireSlave.ino
@ -0,0 +1,37 @@
+#include "Wire.h"
+
+#define I2C_DEV_ADDR 0x55
+
+uint32_t i = 0;
+
+void onRequest(){
+  Wire.print(i++);
+  Wire.print(" Packets.");
+  Serial.println("onRequest");
+}
+
+void onReceive(int len){
+  Serial.printf("onReceive[%d]: ", len);
+  while(Wire.available()){
+    Serial.write(Wire.read());
+  }
+  Serial.println();
+}
+
+void setup() {
+  Serial.begin(115200);
+  Serial.setDebugOutput(true);
+  Wire.onReceive(onReceive);
+  Wire.onRequest(onRequest);
+  Wire.begin((uint8_t)I2C_DEV_ADDR);
+
+#if CONFIG_IDF_TARGET_ESP32
+  char message[64];
+  snprintf(message, 64, "%u Packets.", i++);
+  Wire.slaveWrite((uint8_t *)message, strlen(message));
+#endif
+}
+
+void loop() {
+
+}
--- a/libraries/Wire/keywords.txt
+++ b/libraries/Wire/keywords.txt
@ -11,13 +11,14 @@
 #######################################

 begin	KEYWORD2
+end	KEYWORD2
 setClock	KEYWORD2
-setClockStretchLimit	KEYWORD2
+getClock	KEYWORD2
+setTimeOut	KEYWORD2
+getTimeOut	KEYWORD2
 beginTransmission	KEYWORD2
 endTransmission	KEYWORD2
 requestFrom	KEYWORD2
-send	KEYWORD2
-receive	KEYWORD2
 onReceive	KEYWORD2
 onRequest	KEYWORD2

@ -26,6 +27,7 @@ onRequest	KEYWORD2
 #######################################

 Wire	KEYWORD2
+TwoWire	KEYWORD2

 #######################################
 # Constants (LITERAL1)
--- a/libraries/Wire/src/Wire.cpp
+++ b/libraries/Wire/src/Wire.cpp
@ -20,6 +20,7 @@
  Modified December 2014 by Ivan Grokhotkov (ivan@esp8266.com) - esp8266 support
  Modified April 2015 by Hrsto Gochkov (ficeto@ficeto.com) - alternative esp8266 support
  Modified Nov 2017 by Chuck Todd (ctodd@cableone.net) - ESP32 ISR Support
+  Modified Nov 2021 by Hristo Gochkov <Me-No-Dev> to support ESP-IDF API
 */

 extern "C" {
@ -29,6 +30,7 @@ extern "C" {
 }

 #include "esp32-hal-i2c.h"
+#include "esp32-hal-i2c-slave.h"
 #include "Wire.h"
 #include "Arduino.h"

@ -36,40 +38,32 @@ TwoWire::TwoWire(uint8_t bus_num)
    :num(bus_num & 1)
    ,sda(-1)
    ,scl(-1)
-    ,i2c(NULL)
    ,rxIndex(0)
    ,rxLength(0)
-    ,rxQueued(0)
-    ,txIndex(0)
    ,txLength(0)
    ,txAddress(0)
-    ,txQueued(0)
-    ,transmitting(0)
-    ,last_error(I2C_ERROR_OK)
    ,_timeOutMillis(50)
+    ,nonStop(false)
+#if !CONFIG_DISABLE_HAL_LOCKS
+    ,nonStopTask(NULL)
+    ,lock(NULL)
+#endif
+    ,is_slave(false)
+    ,user_onRequest(NULL)
+    ,user_onReceive(NULL)
 {}

 TwoWire::~TwoWire()
 {
-    flush();
-    if(i2c) {
-        i2cRelease(i2c);
-        i2c=NULL;
+    end();
+#if !CONFIG_DISABLE_HAL_LOCKS
+    if(lock != NULL){
+        vSemaphoreDelete(lock);
    }
+#endif
 }

-bool TwoWire::setPins(int sdaPin, int sclPin)
-{
-    if(i2c) {
-        log_e("can not set pins if begin was already called");
-        return false;
-    }
-    sda = sdaPin;
-    scl = sclPin;
-    return true;
-}
-
-bool TwoWire::begin(int sdaPin, int sclPin, uint32_t frequency)
+bool TwoWire::initPins(int sdaPin, int sclPin)
 {
    if(sdaPin < 0) { // default param passed
        if(num == 0) {
@ -107,14 +101,195 @@ bool TwoWire::begin(int sdaPin, int sclPin, uint32_t frequency)

    sda = sdaPin;
    scl = sclPin;
-    i2c = i2cInit(num, sda, scl, frequency);
-    if(!i2c) {
-        return false;
+    return true;
 }

-    flush();
-    return true;
+bool TwoWire::setPins(int sdaPin, int sclPin)
+{
+#if !CONFIG_DISABLE_HAL_LOCKS
+    if(lock == NULL){
+        lock = xSemaphoreCreateMutex();
+        if(lock == NULL){
+            log_e("xSemaphoreCreateMutex failed");
+            return false;
+        }
+    }
+    //acquire lock
+    if(xSemaphoreTake(lock, portMAX_DELAY) != pdTRUE){
+        log_e("could not acquire lock");
+        return false;
+    }
+#endif
+    if(!i2cIsInit(num)){
+        initPins(sdaPin, sclPin);
+    } else {
+        log_e("bus already initialized. change pins only when not.");
+    }
+#if !CONFIG_DISABLE_HAL_LOCKS
+    //release lock
+    xSemaphoreGive(lock);
+#endif
+    return !i2cIsInit(num);
+}

+// Slave Begin
+bool TwoWire::begin(uint8_t addr, int sdaPin, int sclPin, uint32_t frequency)
+{
+    bool started = false;
+#if !CONFIG_DISABLE_HAL_LOCKS
+    if(lock == NULL){
+        lock = xSemaphoreCreateMutex();
+        if(lock == NULL){
+            log_e("xSemaphoreCreateMutex failed");
+            return false;
+        }
+    }
+    //acquire lock
+    if(xSemaphoreTake(lock, portMAX_DELAY) != pdTRUE){
+        log_e("could not acquire lock");
+        return false;
+    }
+#endif
+    if(is_slave){
+        log_w("Bus already started in Slave Mode.");
+        started = true;
+        goto end;
+    }
+    if(i2cIsInit(num)){
+        log_e("Bus already started in Master Mode.");
+        goto end;
+    }
+    if(!initPins(sdaPin, sclPin)){
+        goto end;
+    }
+    i2cSlaveAttachCallbacks(num, onRequestService, onReceiveService, this);
+    if(i2cSlaveInit(num, sda, scl, addr, frequency, I2C_BUFFER_LENGTH, I2C_BUFFER_LENGTH) != ESP_OK){
+        log_e("Slave Init ERROR");
+        goto end;
+    }
+    is_slave = true;
+    started = true;
+end:
+#if !CONFIG_DISABLE_HAL_LOCKS
+    //release lock
+    xSemaphoreGive(lock);
+#endif
+    return started;
+}
+
+// Master Begin
+bool TwoWire::begin(int sdaPin, int sclPin, uint32_t frequency)
+{
+    bool started = false;
+    esp_err_t err = ESP_OK;
+#if !CONFIG_DISABLE_HAL_LOCKS
+    if(lock == NULL){
+        lock = xSemaphoreCreateMutex();
+        if(lock == NULL){
+            log_e("xSemaphoreCreateMutex failed");
+            return false;
+        }
+    }
+    //acquire lock
+    if(xSemaphoreTake(lock, portMAX_DELAY) != pdTRUE){
+        log_e("could not acquire lock");
+        return false;
+    }
+#endif
+    if(is_slave){
+        log_e("Bus already started in Slave Mode.");
+        goto end;
+    }
+    if(i2cIsInit(num)){
+        log_w("Bus already started in Master Mode.");
+        started = true;
+        goto end;
+    }
+    if(!initPins(sdaPin, sclPin)){
+        goto end;
+    }
+    err = i2cInit(num, sda, scl, frequency);
+    started = (err == ESP_OK);
+
+end:
+#if !CONFIG_DISABLE_HAL_LOCKS
+    //release lock
+    xSemaphoreGive(lock);
+#endif
+    return started;
+
+}
+
+bool TwoWire::end()
+{
+    esp_err_t err = ESP_OK;
+#if !CONFIG_DISABLE_HAL_LOCKS
+    if(lock != NULL){
+        //acquire lock
+        if(xSemaphoreTake(lock, portMAX_DELAY) != pdTRUE){
+            log_e("could not acquire lock");
+            return false;
+        }
+#endif
+        if(is_slave){
+            err = i2cSlaveDeinit(num);
+            if(err == ESP_OK){
+                is_slave = false;
+            }
+        } else if(i2cIsInit(num)){
+            err = i2cDeinit(num);
+        }
+#if !CONFIG_DISABLE_HAL_LOCKS
+        //release lock
+        xSemaphoreGive(lock);
+    }
+#endif
+    return (err == ESP_OK);
+}
+
+uint32_t TwoWire::getClock()
+{
+    uint32_t frequency = 0;
+#if !CONFIG_DISABLE_HAL_LOCKS
+    //acquire lock
+    if(lock == NULL || xSemaphoreTake(lock, portMAX_DELAY) != pdTRUE){
+        log_e("could not acquire lock");
+    } else {
+#endif
+        if(is_slave){
+            log_e("Bus is in Slave Mode");
+        } else {
+            i2cGetClock(num, &frequency);
+        }
+#if !CONFIG_DISABLE_HAL_LOCKS
+        //release lock
+        xSemaphoreGive(lock);
+    }
+#endif
+    return frequency;
+}
+
+bool TwoWire::setClock(uint32_t frequency)
+{
+    esp_err_t err = ESP_OK;
+#if !CONFIG_DISABLE_HAL_LOCKS
+    //acquire lock
+    if(lock == NULL || xSemaphoreTake(lock, portMAX_DELAY) != pdTRUE){
+        log_e("could not acquire lock");
+        return false;
+    }
+#endif
+    if(is_slave){
+        log_e("Bus is in Slave Mode");
+        err = ESP_FAIL;
+    } else {
+        err = i2cSetClock(num, frequency);
+    }
+#if !CONFIG_DISABLE_HAL_LOCKS
+    //release lock
+    xSemaphoreGive(lock);
+#endif
+    return (err == ESP_OK);
 }

 void TwoWire::setTimeOut(uint16_t timeOutMillis)
@ -127,119 +302,105 @@ uint16_t TwoWire::getTimeOut()
    return _timeOutMillis;
 }

-void TwoWire::setClock(uint32_t frequency)
+void TwoWire::beginTransmission(uint16_t address)
 {
-#if CONFIG_IDF_TARGET_ESP32S2
-    i2c = i2cInit(num, sda, scl, frequency);
-    if(!i2c) {
+    if(is_slave){
+        log_e("Bus is in Slave Mode");
+        return;
+    }
+#if !CONFIG_DISABLE_HAL_LOCKS
+    if(nonStop && nonStopTask == xTaskGetCurrentTaskHandle()){
+        log_e("Unfinished Repeated Start transaction! Expected requestFrom, not beginTransmission! Clearing...");
+        //release lock
+        xSemaphoreGive(lock);
+    }
+    //acquire lock
+    if(lock == NULL || xSemaphoreTake(lock, portMAX_DELAY) != pdTRUE){
+        log_e("could not acquire lock");
        return;
    }
 #endif
-    i2cSetFrequency(i2c, frequency);
-}
-
-size_t TwoWire::getClock()
-{
-    return i2cGetFrequency(i2c);
-}
-
-/* stickBreaker Nov 2017 ISR, and bigblock 64k-1
- */
-i2c_err_t TwoWire::writeTransmission(uint16_t address, uint8_t *buff, uint16_t size, bool sendStop)
-{
-    last_error = i2cWrite(i2c, address, buff, size, sendStop, _timeOutMillis);
-    return last_error;
-}
-
-i2c_err_t TwoWire::readTransmission(uint16_t address, uint8_t *buff, uint16_t size, bool sendStop, uint32_t *readCount)
-{
-    last_error = i2cRead(i2c, address, buff, size, sendStop, _timeOutMillis, readCount);
-    return last_error;
-}
-
-void TwoWire::beginTransmission(uint16_t address)
-{
-    transmitting = 1;
+    nonStop = false;
    txAddress = address;
-    txIndex = txQueued; // allow multiple beginTransmission(),write(),endTransmission(false) until endTransmission(true)
-    txLength = txQueued;
-    last_error = I2C_ERROR_OK;
-}
-
-/*stickbreaker isr
- */
-uint8_t TwoWire::endTransmission(bool sendStop)  // Assumes Wire.beginTransaction(), Wire.write()
-{
-    if(transmitting == 1) {
-            // txlength is howmany bytes in txbuffer have been use
-        last_error = writeTransmission(txAddress, &txBuffer[txQueued], txLength - txQueued, sendStop);
-        if(last_error == I2C_ERROR_CONTINUE){
-            txQueued = txLength;
-        } else if( last_error == I2C_ERROR_OK){
-          rxIndex = 0;
-          rxLength = rxQueued;
-          rxQueued = 0;
-          txQueued = 0; // the SendStop=true will restart all Queueing
-        }
-    } else {
-        last_error = I2C_ERROR_NO_BEGIN;
-        flush();
-    }
-    txIndex = 0;
    txLength = 0;
-    transmitting = 0;
-    return (last_error == I2C_ERROR_CONTINUE)?I2C_ERROR_OK:last_error; // Don't return Continue for compatibility.
 }

-/* @stickBreaker 11/2017 fix for ReSTART timeout, ISR
- */
+uint8_t TwoWire::endTransmission(bool sendStop)
+{
+    if(is_slave){
+        log_e("Bus is in Slave Mode");
+        return 4;
+    }
+    esp_err_t err = ESP_OK;
+    if(sendStop){
+        err = i2cWrite(num, txAddress, txBuffer, txLength, _timeOutMillis);
+#if !CONFIG_DISABLE_HAL_LOCKS
+        //release lock
+        xSemaphoreGive(lock);
+#endif
+    } else {
+        //mark as non-stop
+        nonStop = true;
+#if !CONFIG_DISABLE_HAL_LOCKS
+        nonStopTask = xTaskGetCurrentTaskHandle();
+#endif
+    }
+    switch(err){
+        case ESP_OK: return 0;
+        case ESP_FAIL: return 2;
+        case ESP_ERR_TIMEOUT: return 5;
+        default: break;
+    }
+    return 4;
+}
+
 uint8_t TwoWire::requestFrom(uint16_t address, uint8_t size, bool sendStop)
 {
-    //use internal Wire rxBuffer, multiple requestFrom()'s may be pending, try to share rxBuffer
-    uint32_t cnt = rxQueued; // currently queued reads, next available position in rxBuffer
-    if(cnt < (I2C_BUFFER_LENGTH-1) && (size + cnt) <= I2C_BUFFER_LENGTH) { // any room left in rxBuffer
-        rxQueued += size;
-    } else { // no room to receive more!
-        log_e("rxBuff overflow %d", cnt + size);
-        cnt = 0;
-        last_error = I2C_ERROR_MEMORY;
-        flush();
-        return cnt;
+    if(is_slave){
+        log_e("Bus is in Slave Mode");
+        return 0;
    }
-
-    last_error = readTransmission(address, &rxBuffer[cnt], size, sendStop, &cnt);
+    esp_err_t err = ESP_OK;
+    if(nonStop
+#if !CONFIG_DISABLE_HAL_LOCKS
+    && nonStopTask == xTaskGetCurrentTaskHandle()
+#endif
+    ){
+        if(address != txAddress){
+            log_e("Unfinished Repeated Start transaction! Expected address do not match! %u != %u", address, txAddress);
+            return 0;
+        }
+        nonStop = false;
        rxIndex = 0;
-  
-    rxLength = cnt;
-  
-    if( last_error != I2C_ERROR_CONTINUE){ // not a  buffered ReSTART operation
-      // so this operation actually moved data, queuing is done.
-        rxQueued = 0;
-        txQueued = 0; // the SendStop=true will restart all Queueing or error condition
+        rxLength = 0;
+        err = i2cWriteReadNonStop(num, address, txBuffer, txLength, rxBuffer, size, _timeOutMillis, &rxLength);
+    } else {
+#if !CONFIG_DISABLE_HAL_LOCKS
+        //acquire lock
+        if(lock == NULL || xSemaphoreTake(lock, portMAX_DELAY) != pdTRUE){
+            log_e("could not acquire lock");
+            return 0;
        }
-  
-    if(last_error != I2C_ERROR_OK){ // ReSTART on read does not return any data
-        cnt = 0;
+#endif
+        rxIndex = 0;
+        rxLength = 0;
+        err = i2cRead(num, address, rxBuffer, size, _timeOutMillis, &rxLength);
    }
-  
-    return cnt;
+#if !CONFIG_DISABLE_HAL_LOCKS
+    //release lock
+    xSemaphoreGive(lock);
+#endif
+    return rxLength;
 }

 size_t TwoWire::write(uint8_t data)
 {
-    if(transmitting) {
    if(txLength >= I2C_BUFFER_LENGTH) {
-            last_error = I2C_ERROR_MEMORY;
        return 0;
    }
-        txBuffer[txIndex] = data;
-        ++txIndex;
-        txLength = txIndex;
+    txBuffer[txLength++] = data;
    return 1;
 }
-    last_error = I2C_ERROR_NO_BEGIN; // no begin, not transmitting
-    return 0;
-}

 size_t TwoWire::write(const uint8_t *data, size_t quantity)
 {
@ -262,8 +423,7 @@ int TwoWire::read(void)
 {
    int value = -1;
    if(rxIndex < rxLength) {
-        value = rxBuffer[rxIndex];
-        ++rxIndex;
+        value = rxBuffer[rxIndex++];
    }
    return value;
 }
@ -281,11 +441,8 @@ void TwoWire::flush(void)
 {
    rxIndex = 0;
    rxLength = 0;
-    txIndex = 0;
    txLength = 0;
-    rxQueued = 0;
-    txQueued = 0;
-    i2cFlush(i2c); // cleanup
+    //i2cFlush(num); // cleanup
 }

 uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity, uint8_t sendStop)
@ -333,56 +490,49 @@ uint8_t TwoWire::endTransmission(void)
    return endTransmission(true);
 }

-/* stickbreaker Nov2017 better error reporting
- */
-uint8_t TwoWire::lastError()
+size_t TwoWire::slaveWrite(const uint8_t * buffer, size_t len)
 {
-    return (uint8_t)last_error;
+    return i2cSlaveWrite(num, buffer, len, _timeOutMillis);
 }

-const char ERRORTEXT[] =
-    "OK\0"
-    "DEVICE\0"
-    "ACK\0"
-    "TIMEOUT\0"
-    "BUS\0"
-    "BUSY\0"
-    "MEMORY\0"
-    "CONTINUE\0"
-    "NO_BEGIN\0"
-    "\0";
-
-
-char * TwoWire::getErrorText(uint8_t err)
+void TwoWire::onReceiveService(uint8_t num, uint8_t* inBytes, size_t numBytes, bool stop, void * arg)
 {
-    uint8_t t = 0;
-    bool found = false;
-    char * message = (char*)&ERRORTEXT;
+    TwoWire * wire = (TwoWire*)arg;
+    if(!wire->user_onReceive){
+        return;
+    }
+    for(uint8_t i = 0; i < numBytes; ++i){
+        wire->rxBuffer[i] = inBytes[i];    
+    }
+    wire->rxIndex = 0;
+    wire->rxLength = numBytes;
+    wire->user_onReceive(numBytes);
+}

-    while(!found && message[0]) {
-        found = t == err;
-        if(!found) {
-            message = message + strlen(message) + 1;
-            t++;
+void TwoWire::onRequestService(uint8_t num, void * arg)
+{
+    TwoWire * wire = (TwoWire*)arg;
+    if(!wire->user_onRequest){
+        return;
    }
-    }
-    if(!found) {
-        return NULL;
-    } else {
-        return message;
+    wire->txLength = 0;
+    wire->user_onRequest();
+    if(wire->txLength){
+        wire->slaveWrite((uint8_t*)wire->txBuffer, wire->txLength);
    }
 }

-/*stickbreaker Dump i2c Interrupt buffer, i2c isr Debugging
- */
- 
-uint32_t TwoWire::setDebugFlags( uint32_t setBits, uint32_t resetBits){
-  return i2cDebug(i2c,setBits,resetBits);
+void TwoWire::onReceive( void (*function)(int) )
+{
+  user_onReceive = function;
 }

-bool TwoWire::busy(void){
-  return ((i2cGetStatus(i2c) & 16 )==16);
+// sets function called on slave read
+void TwoWire::onRequest( void (*function)(void) )
+{
+  user_onRequest = function;
 }

+
 TwoWire Wire = TwoWire(0);
 TwoWire Wire1 = TwoWire(1);
--- a/libraries/Wire/src/Wire.h
+++ b/libraries/Wire/src/Wire.h
@ -20,17 +20,20 @@
  Modified December 2014 by Ivan Grokhotkov (ivan@esp8266.com) - esp8266 support
  Modified April 2015 by Hrsto Gochkov (ficeto@ficeto.com) - alternative esp8266 support
  Modified November 2017 by Chuck Todd <stickbreaker on GitHub> to use ISR and increase stability.
+  Modified Nov 2021 by Hristo Gochkov <Me-No-Dev> to support ESP-IDF API
 */

 #ifndef TwoWire_h
 #define TwoWire_h

 #include <esp32-hal.h>
+#if !CONFIG_DISABLE_HAL_LOCKS
 #include "freertos/FreeRTOS.h"
-#include "freertos/queue.h"
+#include "freertos/task.h"
+#include "freertos/semphr.h"
+#endif
 #include "Stream.h"

-#define STICKBREAKER 'V1.1.0'
 #ifndef I2C_BUFFER_LENGTH
    #define I2C_BUFFER_LENGTH 128
 #endif
@ -43,28 +46,28 @@ protected:
    uint8_t num;
    int8_t sda;
    int8_t scl;
-    i2c_t * i2c;

    uint8_t rxBuffer[I2C_BUFFER_LENGTH];
-    uint16_t rxIndex;
-    uint16_t rxLength;
-    uint16_t rxQueued; //@stickBreaker
+    size_t rxIndex;
+    size_t rxLength;

    uint8_t txBuffer[I2C_BUFFER_LENGTH];
-    uint16_t txIndex;
-    uint16_t txLength;
+    size_t txLength;
    uint16_t txAddress;
-    uint16_t txQueued; //@stickbreaker

-    uint8_t transmitting;
-    /* slave Mode, not yet Stickbreaker
-            static user_onRequest uReq[2];
-            static user_onReceive uRcv[2];
-        void onRequestService(void);
-        void onReceiveService(uint8_t*, int);
-    */
-    i2c_err_t last_error; // @stickBreaker from esp32-hal-i2c.h
-    uint16_t _timeOutMillis;
+    uint32_t _timeOutMillis;
+    bool nonStop;
+#if !CONFIG_DISABLE_HAL_LOCKS
+    TaskHandle_t nonStopTask;
+    SemaphoreHandle_t lock;
+#endif
+private:
+    bool is_slave;
+    void (*user_onRequest)(void);
+    void (*user_onReceive)(int);
+    static void onRequestService(uint8_t, void *);
+    static void onReceiveService(uint8_t, uint8_t*, size_t, bool, void *);
+    bool initPins(int sdaPin, int sclPin);

 public:
    TwoWire(uint8_t bus_num);
@ -74,20 +77,14 @@ public:
    bool setPins(int sda, int scl);
    
    bool begin(int sda=-1, int scl=-1, uint32_t frequency=0); // returns true, if successful init of i2c bus
-      // calling will attemp to recover hung bus
-
-    void setClock(uint32_t frequency); // change bus clock without initing hardware
-    size_t getClock(); // current bus clock rate in hz
+    bool begin(uint8_t slaveAddr, int sda=-1, int scl=-1, uint32_t frequency=0);
+    bool end();

    void setTimeOut(uint16_t timeOutMillis); // default timeout of i2c transactions is 50ms
    uint16_t getTimeOut();

-    uint8_t lastError();
-    char * getErrorText(uint8_t err);
-
-    //@stickBreaker for big blocks and ISR model
-    i2c_err_t writeTransmission(uint16_t address, uint8_t* buff, uint16_t size, bool sendStop=true);
-    i2c_err_t readTransmission(uint16_t address, uint8_t* buff, uint16_t size, bool sendStop=true, uint32_t *readCount=NULL);
+    bool setClock(uint32_t);
+    uint32_t getClock();

    void beginTransmission(uint16_t address);
    void beginTransmission(uint8_t address);
@ -134,22 +131,10 @@ public:

    void onReceive( void (*)(int) );
    void onRequest( void (*)(void) );
-
-    uint32_t setDebugFlags( uint32_t setBits, uint32_t resetBits);
-    bool busy();
+    size_t slaveWrite(const uint8_t *, size_t);
 };

 extern TwoWire Wire;
 extern TwoWire Wire1;

-
-/*
-V1.1.0 08JAN2019 Support CPU Clock frequency changes
-V1.0.2 30NOV2018 stop returning I2C_ERROR_CONTINUE on ReSTART operations, regain compatibility with Arduino libs
-V1.0.1 02AUG2018 First Fix after release, Correct ReSTART handling, change Debug control, change begin()
-  to a function, this allow reporting if bus cannot be initialized, Wire.begin() can be used to recover
-  a hung bus busy condition.
-V0.2.2 13APR2018 preserve custom SCL,SDA,Frequency when no parameters passed to begin()
-V0.2.1 15MAR2018 Hardware reset, Glitch prevention, adding destructor for second i2c testing
-*/
 #endif
--- a/platform.txt
+++ b/platform.txt
--- a/tools/esptool.py
+++ b/tools/esptool.py
--- a/tools/gen_esp32part.py
+++ b/tools/gen_esp32part.py
@ -73,6 +73,7 @@ SUBTYPES = {
        'coredump': 0x03,
        'nvs_keys': 0x04,
        'efuse': 0x05,
+        'undefined': 0x06,
        'esphttpd': 0x80,
        'fat': 0x81,
        'spiffs': 0x82,
@ -91,6 +92,19 @@ def get_subtype_as_int(ptype, subtype):
            return subtype


+ALIGNMENT = {
+    APP_TYPE: 0x10000,
+    DATA_TYPE: 0x4,
+}
+
+
+STRICT_DATA_ALIGNMENT = 0x1000
+
+
+def get_alignment_for_type(ptype):
+    return ALIGNMENT.get(ptype, ALIGNMENT[DATA_TYPE])
+
+
 quiet = False
 md5sum = True
 secure = False
@ -143,8 +157,8 @@ class PartitionTable(list):
                continue
            try:
                res.append(PartitionDefinition.from_csv(line, line_no + 1))
-            except InputError as e:
-                raise InputError('Error at line %d: %s' % (line_no + 1, e))
+            except InputError as err:
+                raise InputError('Error at line %d: %s' % (line_no + 1, err))
            except Exception:
                critical('Unexpected error parsing CSV line %d: %s' % (line_no + 1, line))
                raise
@ -160,7 +174,7 @@ class PartitionTable(list):
                    raise InputError('CSV Error: Partitions overlap. Partition at line %d sets offset 0x%x. Previous partition ends 0x%x'
                                     % (e.line_no, e.offset, last_end))
            if e.offset is None:
-                pad_to = 0x10000 if e.type == APP_TYPE else 4
+                pad_to = get_alignment_for_type(e.type)
                if last_end % pad_to != 0:
                    last_end += pad_to - (last_end % pad_to)
                e.offset = last_end
@ -210,10 +224,10 @@ class PartitionTable(list):

        # print sorted duplicate partitions by name
        if len(duplicates) != 0:
-            print('A list of partitions that have the same name:')
+            critical('A list of partitions that have the same name:')
            for p in sorted(self, key=lambda x:x.name):
                if len(duplicates.intersection([p.name])) != 0:
-                    print('%s' % (p.to_csv()))
+                    critical('%s' % (p.to_csv()))
            raise InputError('Partition names must be unique')

        # check for overlaps
@ -225,6 +239,18 @@ class PartitionTable(list):
                raise InputError('Partition at 0x%x overlaps 0x%x-0x%x' % (p.offset, last.offset, last.offset + last.size - 1))
            last = p

+        # check that otadata should be unique
+        otadata_duplicates = [p for p in self if p.type == TYPES['data'] and p.subtype == SUBTYPES[DATA_TYPE]['ota']]
+        if len(otadata_duplicates) > 1:
+            for p in otadata_duplicates:
+                critical('%s' % (p.to_csv()))
+            raise InputError('Found multiple otadata partitions. Only one partition can be defined with type="data"(1) and subtype="ota"(0).')
+
+        if len(otadata_duplicates) == 1 and otadata_duplicates[0].size != 0x2000:
+            p = otadata_duplicates[0]
+            critical('%s' % (p.to_csv()))
+            raise InputError('otadata partition must have size = 0x2000')
+
    def flash_size(self):
        """ Return the size that partitions will occupy in flash
            (ie the offset the last partition ends at)
@ -274,11 +300,6 @@ class PartitionTable(list):
 class PartitionDefinition(object):
    MAGIC_BYTES = b'\xAA\x50'

-    ALIGNMENT = {
-        APP_TYPE: 0x10000,
-        DATA_TYPE: 0x04,
-    }
-
    # dictionary maps flag name (as used in CSV flags list, property name)
    # to bit set in flags words in binary format
    FLAGS = {
@ -358,7 +379,9 @@ class PartitionDefinition(object):

    def parse_subtype(self, strval):
        if strval == '':
-            return 0  # default
+            if self.type == TYPES['app']:
+                raise InputError('App partition cannot have an empty subtype')
+            return SUBTYPES[DATA_TYPE]['undefined']
        return parse_int(strval, SUBTYPES.get(self.type, {}))

    def parse_address(self, strval):
@ -373,10 +396,15 @@ class PartitionDefinition(object):
            raise ValidationError(self, 'Subtype field is not set')
        if self.offset is None:
            raise ValidationError(self, 'Offset field is not set')
-        align = self.ALIGNMENT.get(self.type, 4)
+        align = get_alignment_for_type(self.type)
        if self.offset % align:
            raise ValidationError(self, 'Offset 0x%x is not aligned to 0x%x' % (self.offset, align))
-        if self.size % align and secure:
+        # The alignment requirement for non-app partition is 4 bytes, but it should be 4 kB.
+        # Print a warning for now, make it an error in IDF 5.0 (IDF-3742).
+        if self.type != APP_TYPE and self.offset % STRICT_DATA_ALIGNMENT:
+            critical('WARNING: Partition %s not aligned to 0x%x.'
+                     'This is deprecated and will be considered an error in the future release.' % (self.name, STRICT_DATA_ALIGNMENT))
+        if self.size % align and secure and self.type == APP_TYPE:
            raise ValidationError(self, 'Size 0x%x is not aligned to 0x%x' % (self.size, align))
        if self.size is None:
            raise ValidationError(self, 'Size field is not set')
--- a/tools/platformio-build-esp32.py
+++ b/tools/platformio-build-esp32.py
--- a/tools/platformio-build-esp32c3.py
+++ b/tools/platformio-build-esp32c3.py
--- a/tools/platformio-build-esp32s2.py
+++ b/tools/platformio-build-esp32s2.py
--- a/tools/sdk/esp32/bin/bootloader_dio_40m.bin
+++ b/tools/sdk/esp32/bin/bootloader_dio_40m.bin
--- a/tools/sdk/esp32/bin/bootloader_dio_80m.bin
+++ b/tools/sdk/esp32/bin/bootloader_dio_80m.bin
--- a/tools/sdk/esp32/bin/bootloader_dout_40m.bin
+++ b/tools/sdk/esp32/bin/bootloader_dout_40m.bin
--- a/tools/sdk/esp32/bin/bootloader_dout_80m.bin
+++ b/tools/sdk/esp32/bin/bootloader_dout_80m.bin
--- a/tools/sdk/esp32/bin/bootloader_qio_40m.bin
+++ b/tools/sdk/esp32/bin/bootloader_qio_40m.bin
--- a/tools/sdk/esp32/bin/bootloader_qio_80m.bin
+++ b/tools/sdk/esp32/bin/bootloader_qio_80m.bin
--- a/tools/sdk/esp32/bin/bootloader_qout_40m.bin
+++ b/tools/sdk/esp32/bin/bootloader_qout_40m.bin
--- a/tools/sdk/esp32/bin/bootloader_qout_80m.bin
+++ b/tools/sdk/esp32/bin/bootloader_qout_80m.bin
--- a/tools/sdk/esp32/include/app_update/include/esp_ota_ops.h
+++ b/tools/sdk/esp32/include/app_update/include/esp_ota_ops.h
@ -244,6 +244,14 @@ const esp_partition_t* esp_ota_get_next_update_partition(const esp_partition_t *
 */
 esp_err_t esp_ota_get_partition_description(const esp_partition_t *partition, esp_app_desc_t *app_desc);

+/**
+ * @brief Returns number of ota partitions provided in partition table.
+ *
+ * @return
+ *  - Number of OTA partitions
+ */
+uint8_t esp_ota_get_app_partition_count(void);
+
 /**
 * @brief This function is called to indicate that the running app is working well.
 *
--- a/tools/sdk/esp32/include/asio/port/include/esp_asio_config.h
+++ b/tools/sdk/esp32/include/asio/port/include/esp_asio_config.h
@ -18,6 +18,11 @@
 #  define ASIO_NO_TYPEID
 # endif   // CONFIG_COMPILER_RTTI

+//
+// Supress OpenSSL deprecation warning, when building ASIO
+//
+#define ESP_OPENSSL_SUPPRESS_LEGACY_WARNING
+
 //
 // LWIP compatibility inet and address macros/functions
 //
--- a/tools/sdk/esp32/include/bootloader_support/include/bootloader_common.h
+++ b/tools/sdk/esp32/include/bootloader_support/include/bootloader_common.h
@ -119,6 +119,15 @@ bool bootloader_common_label_search(const char *list, char *label);
 */
 void bootloader_configure_spi_pins(int drv);

+/**
+ * @brief Get flash CS IO
+ *
+ * Can be determined by eFuse values, or the default value
+ *
+ * @return Flash CS IO
+ */
+uint8_t bootloader_flash_get_cs_io(void);
+
 /**
 * @brief Calculates a sha-256 for a given partition or returns a appended digest.
 *
--- a/tools/sdk/esp32/include/bootloader_support/include/bootloader_flash.h
+++ b/tools/sdk/esp32/include/bootloader_support/include/bootloader_flash.h
@ -10,6 +10,18 @@
 #include "sdkconfig.h"
 #include "soc/soc_caps.h"

+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Read flash ID by sending RDID command (0x9F)
+ * @return flash raw ID
+ *     mfg_id = (ID >> 16) & 0xFF;
+       flash_id = ID & 0xffff;
+ */
+uint32_t bootloader_read_flash_id(void);
+
 #if SOC_CACHE_SUPPORT_WRAP
 /**
 * @brief Set the burst mode setting command for specified wrap mode.
@ -19,3 +31,22 @@
 */
 esp_err_t bootloader_flash_wrap_set(spi_flash_wrap_mode_t mode);
 #endif
+
+/**
+  * @brief Unlock Flash write protect.
+  *        Please do not call this function in SDK.
+  *
+  * @note This can be overridden because it's attribute weak.
+  */
+esp_err_t bootloader_flash_unlock(void);
+
+/**
+ * @brief Startup flow recommended by XMC. Call at startup before any erase/write operation.
+ *
+ * @return ESP_OK When startup successfully, otherwise ESP_FAIL (indiciating you should reboot before erase/write).
+ */
+esp_err_t bootloader_flash_xmc_startup(void);
+
+#ifdef __cplusplus
+}
+#endif
--- a/tools/sdk/esp32/include/bt/common/osi/include/osi/alarm.h
+++ b/tools/sdk/esp32/include/bt/common/osi/include/osi/alarm.h
@ -77,4 +77,8 @@ period_ms_t osi_alarm_get_remaining_ms(const osi_alarm_t *alarm);

 uint32_t osi_time_get_os_boottime_ms(void);

+// This function returns whether the given |alarm| is active or not.
+// Return true if active, false otherwise.
+bool osi_alarm_is_active(osi_alarm_t *alarm);
+
 #endif /*_ALARM_H_*/
--- a/tools/sdk/esp32/include/bt/host/bluedroid/api/include/api/esp_gattc_api.h
+++ b/tools/sdk/esp32/include/bt/host/bluedroid/api/include/api/esp_gattc_api.h
@ -380,7 +380,7 @@ esp_err_t esp_ble_gattc_search_service(esp_gatt_if_t gattc_if, uint16_t conn_id,
 /**
 * @brief           Find all the service with the given service uuid in the gattc cache, if the svc_uuid is NULL, find all the service.
 *                  Note: It just get service from local cache, won't get from remote devices. If want to get it from remote device, need
- *                  to used the esp_ble_gattc_search_service.
+ *                  to used the esp_ble_gattc_cache_refresh, then call esp_ble_gattc_get_service again.
 *
 * @param[in]       gattc_if: Gatt client access interface.
 * @param[in]       conn_id: connection ID which identify the server.
--- a/tools/sdk/esp32/include/bt/host/bluedroid/api/include/api/esp_hidd_api.h
+++ b/tools/sdk/esp32/include/bt/host/bluedroid/api/include/api/esp_hidd_api.h
@ -0,0 +1,379 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+// Copyright 2019      Blake Felt
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef __ESP_HIDD_API_H__
+#define __ESP_HIDD_API_H__
+
+#include "esp_bt_defs.h"
+#include "esp_err.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* sub_class of hid device */
+#define ESP_HID_CLASS_UNKNOWN      (0x00<<2)
+#define ESP_HID_CLASS_JOS          (0x01<<2)           /* joy stick */
+#define ESP_HID_CLASS_GPD          (0x02<<2)           /* game pad */
+#define ESP_HID_CLASS_RMC          (0x03<<2)           /* remote control */
+#define ESP_HID_CLASS_SED          (0x04<<2)           /* sensing device */
+#define ESP_HID_CLASS_DGT          (0x05<<2)           /* Digitizer tablet */
+#define ESP_HID_CLASS_CDR          (0x06<<2)           /* card reader */
+#define ESP_HID_CLASS_KBD          (0x10<<2)           /* keyboard */
+#define ESP_HID_CLASS_MIC          (0x20<<2)           /* pointing device */
+#define ESP_HID_CLASS_COM          (0x30<<2)           /* Combo keyboard/pointing */
+
+/**
+ * @brief HIDD handshake error
+ */
+typedef enum {
+    ESP_HID_PAR_HANDSHAKE_RSP_SUCCESS = 0,
+    ESP_HID_PAR_HANDSHAKE_RSP_NOT_READY = 1,
+    ESP_HID_PAR_HANDSHAKE_RSP_ERR_INVALID_REP_ID = 2,
+    ESP_HID_PAR_HANDSHAKE_RSP_ERR_UNSUPPORTED_REQ = 3,
+    ESP_HID_PAR_HANDSHAKE_RSP_ERR_INVALID_PARAM = 4,
+    ESP_HID_PAR_HANDSHAKE_RSP_ERR_UNKNOWN = 14,
+    ESP_HID_PAR_HANDSHAKE_RSP_ERR_FATAL = 15
+} esp_hidd_handshake_error_t;
+
+/**
+ * @brief HIDD report types
+ */
+typedef enum {
+    ESP_HIDD_REPORT_TYPE_OTHER = 0,
+    ESP_HIDD_REPORT_TYPE_INPUT,
+    ESP_HIDD_REPORT_TYPE_OUTPUT,
+    ESP_HIDD_REPORT_TYPE_FEATURE,
+    // special value for reports to be sent on INTR(INPUT is assumed)
+    ESP_HIDD_REPORT_TYPE_INTRDATA
+} esp_hidd_report_type_t;
+
+/**
+ * @brief HIDD connection state
+ */
+typedef enum {
+    ESP_HIDD_CONN_STATE_CONNECTED,
+    ESP_HIDD_CONN_STATE_CONNECTING,
+    ESP_HIDD_CONN_STATE_DISCONNECTED,
+    ESP_HIDD_CONN_STATE_DISCONNECTING,
+    ESP_HIDD_CONN_STATE_UNKNOWN
+} esp_hidd_connection_state_t;
+
+/**
+ * @brief HID device protocol modes
+ */
+typedef enum {
+    ESP_HIDD_REPORT_MODE = 0x00,
+    ESP_HIDD_BOOT_MODE = 0x01,
+    ESP_HIDD_UNSUPPORTED_MODE = 0xff
+} esp_hidd_protocol_mode_t;
+
+
+/**
+ * @brief HIDD characteristics for SDP report
+ */
+typedef struct {
+    const char *name;
+    const char *description;
+    const char *provider;
+    uint8_t subclass;
+    uint8_t *desc_list;
+    int desc_list_len;
+} esp_hidd_app_param_t;
+
+/**
+ * @brief HIDD Quality of Service parameters
+ */
+typedef struct {
+    uint8_t service_type;
+    uint32_t token_rate;
+    uint32_t token_bucket_size;
+    uint32_t peak_bandwidth;
+    uint32_t access_latency;
+    uint32_t delay_variation;
+} esp_hidd_qos_param_t;
+
+/**
+ * @brief HID device callback function events
+ */
+typedef enum {
+    ESP_HIDD_INIT_EVT = 0,       /*!< When HID device is inited, the event comes */
+    ESP_HIDD_DEINIT_EVT,         /*!< When HID device is deinited, the event comes */
+    ESP_HIDD_REGISTER_APP_EVT,   /*!< When HID device application registered, the event comes */
+    ESP_HIDD_UNREGISTER_APP_EVT, /*!< When HID device application unregistered, the event comes */
+    ESP_HIDD_OPEN_EVT,           /*!< When HID device connection to host opened, the event comes */
+    ESP_HIDD_CLOSE_EVT,          /*!< When HID device connection to host closed, the event comes */
+    ESP_HIDD_SEND_REPORT_EVT,    /*!< When HID device send report to lower layer, the event comes */
+    ESP_HIDD_REPORT_ERR_EVT,     /*!< When HID device report handshanke error to lower layer, the event comes */
+    ESP_HIDD_GET_REPORT_EVT,     /*!< When HID device receives GET_REPORT request from host, the event comes */
+    ESP_HIDD_SET_REPORT_EVT,     /*!< When HID device receives SET_REPORT request from host, the event comes */
+    ESP_HIDD_SET_PROTOCOL_EVT,   /*!< When HID device receives SET_PROTOCOL request from host, the event comes */
+    ESP_HIDD_INTR_DATA_EVT,      /*!< When HID device receives DATA from host on intr, the event comes */
+    ESP_HIDD_VC_UNPLUG_EVT,      /*!< When HID device initiates Virtual Cable Unplug, the event comes */
+    ESP_HIDD_API_ERR_EVT         /*!< When HID device has API error, the event comes */
+} esp_hidd_cb_event_t;
+
+typedef enum {
+    ESP_HIDD_SUCCESS,
+    ESP_HIDD_ERROR,         /*!< general ESP HD error */
+    ESP_HIDD_NO_RES,        /*!< out of system resources */
+    ESP_HIDD_BUSY,          /*!< Temporarily can not handle this request. */
+    ESP_HIDD_NO_DATA,       /*!< No data. */
+    ESP_HIDD_NEED_INIT,     /*!< HIDD module shall init first */
+    ESP_HIDD_NEED_DEINIT,   /*!< HIDD module shall deinit first */
+    ESP_HIDD_NEED_REG,      /*!< HIDD module shall register first */
+    ESP_HIDD_NEED_DEREG,    /*!< HIDD module shall deregister first */
+    ESP_HIDD_NO_CONNECTION, /*!< connection may have been closed */
+} esp_hidd_status_t;
+
+/**
+ * @brief HID device callback parameters union
+ */
+typedef union {
+    /**
+     * @brief ESP_HIDD_INIT_EVT
+     */
+    struct hidd_init_evt_param {
+        esp_hidd_status_t status; /*!< operation status */
+    } init;                       /*!< HIDD callback param of ESP_HIDD_INIT_EVT */
+
+    /**
+     * @brief ESP_HIDD_DEINIT_EVT
+     */
+    struct hidd_deinit_evt_param {
+        esp_hidd_status_t status; /*!< operation status */
+    } deinit;                     /*!< HIDD callback param of ESP_HIDD_DEINIT_EVT */
+
+    /**
+     * @brief ESP_HIDD_REGISTER_APP_EVT
+     */
+    struct hidd_register_app_evt_param {
+        esp_hidd_status_t status; /*!< operation status */
+        bool in_use;              /*!< indicate whether use virtual cable plug host address */
+        esp_bd_addr_t bd_addr;    /*!< host address */
+    } register_app;               /*!< HIDD callback param of ESP_HIDD_REGISTER_APP_EVT */
+
+    /**
+     * @brief ESP_HIDD_UNREGISTER_APP_EVT
+     */
+    struct hidd_unregister_app_evt_param {
+        esp_hidd_status_t status; /*!< operation status         */
+    } unregister_app;             /*!< HIDD callback param of ESP_HIDD_UNREGISTER_APP_EVT */
+
+    /**
+     * @brief ESP_HIDD_OPEN_EVT
+     */
+    struct hidd_open_evt_param {
+        esp_hidd_status_t status;                /*!< operation status         */
+        esp_hidd_connection_state_t conn_status; /*!< connection status */
+        esp_bd_addr_t bd_addr;                   /*!< host address */
+    } open;                                      /*!< HIDD callback param of ESP_HIDD_OPEN_EVT */
+
+    /**
+     * @brief ESP_HIDD_CLOSE_EVT
+     */
+    struct hidd_close_evt_param {
+        esp_hidd_status_t status;                /*!< operation status         */
+        esp_hidd_connection_state_t conn_status; /*!< connection status        */
+    } close;                                     /*!< HIDD callback param of ESP_HIDD_CLOSE_EVT */
+
+    /**
+     * @brief ESP_HIDD_SEND_REPORT_EVT
+     */
+    struct hidd_send_report_evt_param {
+        esp_hidd_status_t status;           /*!< operation status         */
+        uint8_t reason;                     /*!< lower layer failed reason(ref hiddefs.h)       */
+        esp_hidd_report_type_t report_type; /*!< report type        */
+        uint8_t report_id;                  /*!< report id         */
+    } send_report;                          /*!< HIDD callback param of ESP_HIDD_SEND_REPORT_EVT */
+
+    /**
+     * @brief ESP_HIDD_REPORT_ERR_EVT
+     */
+    struct hidd_report_err_evt_param {
+        esp_hidd_status_t status; /*!< operation status         */
+        uint8_t reason;           /*!< lower layer failed reason(ref hiddefs.h)           */
+    } report_err;                 /*!< HIDD callback param of ESP_HIDD_REPORT_ERR_EVT */
+
+    /**
+     * @brief ESP_HIDD_GET_REPORT_EVT
+     */
+    struct hidd_get_report_evt_param {
+        esp_hidd_report_type_t report_type; /*!< report type        */
+        uint8_t report_id;                  /*!< report id         */
+        uint16_t buffer_size;               /*!< buffer size         */
+    } get_report;                           /*!< HIDD callback param of ESP_HIDD_GET_REPORT_EVT */
+
+    /**
+     * @brief ESP_HIDD_SET_REPORT_EVT
+     */
+    struct hidd_set_report_evt_param {
+        esp_hidd_report_type_t report_type; /*!< report type        */
+        uint8_t report_id;                  /*!< report id         */
+        uint16_t len;                       /*!< set_report data length         */
+        uint8_t *data;                      /*!< set_report data pointer         */
+    } set_report;                           /*!< HIDD callback param of ESP_HIDD_SET_REPORT_EVT */
+
+    /**
+     * @brief ESP_HIDD_SET_PROTOCOL_EVT
+     */
+    struct hidd_set_protocol_evt_param {
+        esp_hidd_protocol_mode_t protocol_mode; /*!< protocol mode        */
+    } set_protocol;                             /*!< HIDD callback param of ESP_HIDD_SET_PROTOCOL_EVT */
+
+    /**
+     * @brief ESP_HIDD_INTR_DATA_EVT
+     */
+    struct hidd_intr_data_evt_param {
+        uint8_t report_id; /*!< interrupt channel report id         */
+        uint16_t len;      /*!< interrupt channel report data length         */
+        uint8_t *data;     /*!< interrupt channel report data pointer         */
+    } intr_data;           /*!< HIDD callback param of ESP_HIDD_INTR_DATA_EVT */
+
+    /**
+     * @brief ESP_HIDD_VC_UNPLUG_EVT
+     */
+    struct hidd_vc_unplug_param {
+        esp_hidd_status_t status;                /*!< operation status         */
+        esp_hidd_connection_state_t conn_status; /*!< connection status        */
+    } vc_unplug;                                 /*!< HIDD callback param of ESP_HIDD_VC_UNPLUG_EVT */
+} esp_hidd_cb_param_t;
+
+/**
+ * @brief       HID device callback function type.
+ * @param       event:      Event type
+ * @param       param:      Point to callback parameter, currently is union type
+ */
+typedef void (esp_hd_cb_t)(esp_hidd_cb_event_t event, esp_hidd_cb_param_t *param);
+
+/**
+ * @brief       This function is called to init callbacks with HID device module.
+ *
+ * @param[in]   callback:   pointer to the init callback function.
+ *
+ * @return
+ *              - ESP_OK: success
+ *              - other: failed
+ */
+esp_err_t esp_bt_hid_device_register_callback(esp_hd_cb_t callback);
+
+/**
+ * @brief       This function initializes HIDD. This function should be called after esp_bluedroid_enable and
+ *              esp_blueroid_init success, and should be called after esp_bt_hid_device_register_callback.
+ *              When the operation is complete the callback function will be called with ESP_HIDD_INIT_EVT.
+ *
+ * @return
+ *              - ESP_OK: success
+ *              - other: failed
+ */
+esp_err_t esp_bt_hid_device_init(void);
+
+/**
+ * @brief       This function de-initializes HIDD interface. This function should be called after esp_bluedroid_enable() and
+ *              esp_blueroid_init() success, and should be called after esp_bt_hid_device_init(). When the operation is complete the callback
+ *              function will be called with ESP_HIDD_DEINIT_EVT.
+ *
+ * @return    - ESP_OK: success
+ *            - other: failed
+ */
+esp_err_t esp_bt_hid_device_deinit(void);
+
+/**
+ * @brief     Registers HIDD parameters with SDP and sets l2cap Quality of Service. This function should be called after
+ *            esp_bluedroid_enable and esp_blueroid_init success, and must be done after esp_bt_hid_device_init. When the operation is complete the callback
+ *            function will be called with ESP_HIDD_REGISTER_APP_EVT.
+ *
+ * @param[in] app_param:  HIDD parameters
+ * @param[in] in_qos:     incoming QoS parameters
+ * @param[in] out_qos:    outgoing QoS parameters
+ *
+ * @return    - ESP_OK: success
+ *            - other: failed
+ */
+esp_err_t esp_bt_hid_device_register_app(esp_hidd_app_param_t *app_param, esp_hidd_qos_param_t *in_qos,
+                                         esp_hidd_qos_param_t *out_qos);
+
+/**
+ * @brief   Removes HIDD parameters from SDP and resets l2cap Quality of Service. This function should be called after esp_bluedroid_enable and
+ *          esp_blueroid_init success, and should be called after esp_bt_hid_device_init. When the operation is complete the callback
+ *          function will be called with ESP_HIDD_UNREGISTER_APP_EVT.
+ *
+ * @return  - ESP_OK: success
+ *          - other: failed
+ */
+esp_err_t esp_bt_hid_device_unregister_app(void);
+
+/**
+ * @brief     This function connects HIDD interface to connected bluetooth device, if not done already. When the operation is complete the callback
+ *            function will be called with ESP_HIDD_OPEN_EVT.
+ *
+ * @param[in] bd_addr:      Remote host bluetooth device address.
+ *
+ * @return
+ *            - ESP_OK: success
+ *            - other: failed
+ */
+esp_err_t esp_bt_hid_device_connect(esp_bd_addr_t bd_addr);
+
+/**
+ * @brief     This function disconnects HIDD interface. When the operation is complete the callback
+ *            function will be called with ESP_HIDD_CLOSE_EVT.
+ *
+ * @return
+ *            - ESP_OK: success
+ *            - other: failed
+ */
+esp_err_t esp_bt_hid_device_disconnect(void);
+
+/**
+ * @brief     Send HIDD report. When the operation is complete the callback
+ *            function will be called with ESP_HIDD_SEND_REPORT_EVT.
+ *
+ * @param[in] type:   type of report
+ * @param[in] id:     report id as defined by descriptor
+ * @param[in] len:    length of report
+ * @param[in] data:   report data
+ *
+ * @return
+ *            - ESP_OK: success
+ *            - other: failed
+ */
+esp_err_t esp_bt_hid_device_send_report(esp_hidd_report_type_t type, uint8_t id, uint16_t len, uint8_t *data);
+
+/**
+ * @brief     Sends HIDD handshake with error info for invalid set_report. When the operation is complete the callback
+ *            function will be called with ESP_HIDD_REPORT_ERR_EVT.
+ *
+ * @param[in] error: type of error
+ *
+ * @return    - ESP_OK: success
+ *            - other: failed
+ */
+esp_err_t esp_bt_hid_device_report_error(esp_hidd_handshake_error_t error);
+
+/**
+ * @brief     Unplug virtual cable of HIDD. When the operation is complete the callback
+ *            function will be called with ESP_HIDD_VC_UNPLUG_EVT.
+ *
+ * @return    - ESP_OK: success
+ *            - other: failed
+ */
+esp_err_t esp_bt_hid_device_virtual_cable_unplug(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/tools/sdk/esp32/include/bt/host/bluedroid/api/include/api/esp_hidh_api.h
+++ b/tools/sdk/esp32/include/bt/host/bluedroid/api/include/api/esp_hidh_api.h
@ -0,0 +1,465 @@
+// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
+// Copyright 2019      Blake Felt
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef __ESP_HIDH_API_H__
+#define __ESP_HIDH_API_H__
+
+#include "esp_bt_defs.h"
+#include "esp_err.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define BTHH_MAX_DSC_LEN 884
+
+/**
+ * @brief HID host connection state
+ */
+typedef enum {
+    ESP_HIDH_CONN_STATE_CONNECTED = 0,           /*!< connected state */
+    ESP_HIDH_CONN_STATE_CONNECTING,              /*!< connecting state */
+    ESP_HIDH_CONN_STATE_DISCONNECTED,            /*!< disconnected state */
+    ESP_HIDH_CONN_STATE_DISCONNECTING,           /*!< disconnecting state */
+    ESP_HIDH_CONN_STATE_UNKNOWN                  /*!< unknown state(initial state) */
+} esp_hidh_connection_state_t;
+
+typedef enum {
+    ESP_HIDH_OK,
+    ESP_HIDH_HS_HID_NOT_READY,  /*!< handshake error : device not ready */
+    ESP_HIDH_HS_INVALID_RPT_ID, /*!< handshake error : invalid report ID */
+    ESP_HIDH_HS_TRANS_NOT_SPT,  /*!< handshake error : transaction not spt */
+    ESP_HIDH_HS_INVALID_PARAM,  /*!< handshake error : invalid paremter */
+    ESP_HIDH_HS_ERROR,          /*!< handshake error : unspecified HS error */
+    ESP_HIDH_ERR,               /*!< general ESP HH error */
+    ESP_HIDH_ERR_SDP,           /*!< SDP error */
+    ESP_HIDH_ERR_PROTO,         /*!< SET_Protocol error,
+                                  only used in ESP_HIDH_OPEN_EVT callback */
+
+    ESP_HIDH_ERR_DB_FULL,       /*!< device database full error, used in
+                                     ESP_HIDH_OPEN_EVT/ESP_HIDH_ADD_DEV_EVT */
+    ESP_HIDH_ERR_TOD_UNSPT,     /*!< type of device not supported */
+    ESP_HIDH_ERR_NO_RES,        /*!< out of system resources */
+    ESP_HIDH_ERR_AUTH_FAILED,   /*!< authentication fail */
+    ESP_HIDH_ERR_HDL,           /*!< connection handle error */
+    ESP_HIDH_ERR_SEC,           /*!< encryption error */
+    // self_defined
+    ESP_HIDH_BUSY,              /*!< Temporarily can not handle this request. */
+    ESP_HIDH_NO_DATA,           /*!< No data. */
+    ESP_HIDH_NEED_INIT,         /*!< HIDH module shall init first */
+    ESP_HIDH_NEED_DEINIT,       /*!< HIDH module shall deinit first */
+    ESP_HIDH_NO_CONNECTION,     /*!< connection may have been closed */
+} esp_hidh_status_t;
+
+/**
+ * @brief HID host protocol modes
+ */
+typedef enum {
+    ESP_HIDH_BOOT_MODE = 0x00,       /*!< boot protocol mode */
+    ESP_HIDH_REPORT_MODE = 0x01,     /*!< report protocol mode */
+    ESP_HIDH_UNSUPPORTED_MODE = 0xff /*!< unsupported protocol mode */
+} esp_hidh_protocol_mode_t;
+
+/**
+ * @brief HID host report types
+ */
+typedef enum {
+    ESP_HIDH_REPORT_TYPE_OTHER = 0, /*!< unsupported report type */
+    ESP_HIDH_REPORT_TYPE_INPUT,     /*!< input report type */
+    ESP_HIDH_REPORT_TYPE_OUTPUT,    /*!< output report type */
+    ESP_HIDH_REPORT_TYPE_FEATURE,   /*!< feature report type */
+} esp_hidh_report_type_t;
+
+/**
+ * @brief HID host callback function events
+ */
+typedef enum {
+    ESP_HIDH_INIT_EVT = 0,  /*!< When HID host is inited, the event comes */
+    ESP_HIDH_DEINIT_EVT,    /*!< When HID host is deinited, the event comes */
+    ESP_HIDH_OPEN_EVT,      /*!< When HID host connection opened, the event comes */
+    ESP_HIDH_CLOSE_EVT,     /*!< When HID host connection closed, the event comes */
+    ESP_HIDH_GET_RPT_EVT,   /*!< When Get_Report command is called, the event comes */
+    ESP_HIDH_SET_RPT_EVT,   /*!< When Set_Report command is called, the event comes */
+    ESP_HIDH_GET_PROTO_EVT, /*!< When Get_Protocol command is called, the event comes */
+    ESP_HIDH_SET_PROTO_EVT, /*!< When Set_Protocol command is called, the event comes */
+    ESP_HIDH_GET_IDLE_EVT,  /*!< When Get_Idle command is called, the event comes */
+    ESP_HIDH_SET_IDLE_EVT,  /*!< When Set_Idle command is called, the event comes */
+    ESP_HIDH_GET_DSCP_EVT,  /*!< When HIDH is inited, the event comes */
+    ESP_HIDH_ADD_DEV_EVT,   /*!< When a device is added, the event comes */
+    ESP_HIDH_RMV_DEV_EVT,   /*!< When a device is removed, the event comes */
+    ESP_HIDH_VC_UNPLUG_EVT, /*!< When virtually unplugged, the event comes */
+    ESP_HIDH_DATA_EVT,      /*!< When send data on interrupt channel, the event comes */
+    ESP_HIDH_DATA_IND_EVT,  /*!< When receive data on interrupt channel, the event comes */
+    ESP_HIDH_SET_INFO_EVT   /*!< When set the HID device descriptor, the event comes */
+} esp_hidh_cb_event_t;
+
+typedef struct {
+    int attr_mask;
+    uint8_t sub_class;
+    uint8_t app_id;
+    int vendor_id;
+    int product_id;
+    int version;
+    uint8_t ctry_code;
+    int dl_len;
+    uint8_t dsc_list[BTHH_MAX_DSC_LEN];
+} esp_hidh_hid_info_t;
+
+/**
+ * @brief HID host callback parameters union
+ */
+typedef union {
+    /**
+     * @brief ESP_HIDH_INIT_EVT
+     */
+    struct hidh_init_evt_param {
+        esp_hidh_status_t status; /*!< status */
+    } init;                       /*!< HIDH callback param of ESP_HIDH_INIT_EVT */
+
+    /**
+     * @brief ESP_HIDH_DEINIT_EVT
+     */
+    struct hidh_uninit_evt_param {
+        esp_hidh_status_t status; /*!< status */
+    } deinit;                     /*!< HIDH callback param of ESP_HIDH_DEINIT_EVT */
+
+    /**
+     * @brief ESP_HIDH_OPEN_EVT
+     */
+    struct hidh_open_evt_param {
+        esp_hidh_status_t status;                /*!< operation status         */
+        esp_hidh_connection_state_t conn_status; /*!< connection status        */
+        bool is_orig;                            /*!< indicate if host intiate the connection        */
+        uint8_t handle;                          /*!< device handle            */
+        esp_bd_addr_t bd_addr;                   /*!< device address           */
+    } open;                                      /*!< HIDH callback param of ESP_HIDH_OPEN_EVT */
+
+    /**
+     * @brief ESP_HIDH_CLOSE_EVT
+     */
+    struct hidh_close_evt_param {
+        esp_hidh_status_t status;                /*!< operation status         */
+        uint8_t reason;                          /*!< lower layer failed reason(ref hiddefs.h)       */
+        esp_hidh_connection_state_t conn_status; /*!< connection status        */
+        uint8_t handle;                          /*!< device handle            */
+    } close;                                     /*!< HIDH callback param of ESP_HIDH_CLOSE_EVT */
+
+    /**
+     * @brief ESP_HIDH_VC_UNPLUG_EVT
+     */
+    struct hidh_unplug_evt_param {
+        esp_hidh_status_t status;                /*!< operation status         */
+        esp_hidh_connection_state_t conn_status; /*!< connection status        */
+        uint8_t handle;                          /*!< device handle            */
+    } unplug;                                    /*!< HIDH callback param of ESP_HIDH_VC_UNPLUG_EVT */
+
+    /**
+     * @brief ESP_HIDH_GET_PROTO_EVT
+     */
+    struct hidh_get_proto_evt_param {
+        esp_hidh_status_t status;            /*!< operation status         */
+        uint8_t handle;                      /*!< device handle            */
+        esp_hidh_protocol_mode_t proto_mode; /*!< protocol mode            */
+    } get_proto;                             /*!< HIDH callback param of ESP_HIDH_GET_PROTO_EVT */
+
+    /**
+     * @brief ESP_HIDH_SET_PROTO_EVT
+     */
+    struct hidh_set_proto_evt_param {
+        esp_hidh_status_t status; /*!< operation status         */
+        uint8_t handle;           /*!< device handle            */
+    } set_proto;                  /*!< HIDH callback param of ESP_HIDH_SET_PROTO_EVT */
+
+    /**
+     * @brief ESP_HIDH_GET_RPT_EVT
+     */
+    struct hidh_get_rpt_evt_param {
+        esp_hidh_status_t status; /*!< operation status         */
+        uint8_t handle;           /*!< device handle            */
+        uint16_t len;             /*!< data length              */
+        uint8_t *data;            /*!< data pointer             */
+    } get_rpt;                    /*!< HIDH callback param of ESP_HIDH_GET_RPT_EVT */
+
+    /**
+     * @brief ESP_HIDH_SET_RPT_EVT
+     */
+    struct hidh_set_rpt_evt_param {
+        esp_hidh_status_t status; /*!< operation status         */
+        uint8_t handle;           /*!< device handle            */
+    } set_rpt;                    /*!< HIDH callback param of ESP_HIDH_SET_RPT_EVT */
+
+    /**
+     * @brief ESP_HIDH_DATA_EVT
+     */
+    struct hidh_send_data_evt_param {
+        esp_hidh_status_t status; /*!< operation status         */
+        uint8_t handle;           /*!< device handle            */
+        uint8_t reason;           /*!< lower layer failed reason(ref hiddefs.h)       */
+    } send_data;                  /*!< HIDH callback param of ESP_HIDH_DATA_EVT */
+
+    /**
+     * @brief ESP_HIDH_GET_IDLE_EVT
+     */
+    struct hidh_get_idle_evt_param {
+        esp_hidh_status_t status; /*!< operation status         */
+        uint8_t handle;           /*!< device handle            */
+        uint8_t idle_rate;        /*!< idle rate                */
+    } get_idle;                   /*!< HIDH callback param of ESP_HIDH_GET_IDLE_EVT */
+
+    /**
+     * @brief ESP_HIDH_SET_IDLE_EVT
+     */
+    struct hidh_set_idle_evt_param {
+        esp_hidh_status_t status; /*!< operation status         */
+        uint8_t handle;           /*!< device handle            */
+    } set_idle;                   /*!< HIDH callback param of ESP_HIDH_SET_IDLE_EVT */
+
+    /**
+     * @brief ESP_HIDH_DATA_IND_EVT
+     */
+    struct hidh_data_ind_evt_param {
+        esp_hidh_status_t status;            /*!< operation status         */
+        uint8_t handle;                      /*!< device handle            */
+        esp_hidh_protocol_mode_t proto_mode; /*!< protocol mode            */
+        uint16_t len;                        /*!< data length              */
+        uint8_t *data;                       /*!< data pointer             */
+    } data_ind;                              /*!< HIDH callback param of ESP_HIDH_DATA_IND_EVT */
+
+    /**
+     * @brief ESP_HIDH_ADD_DEV_EVT
+     */
+    struct hidh_add_dev_evt_param {
+        esp_hidh_status_t status; /*!< operation status         */
+        uint8_t handle;           /*!< device handle            */
+        esp_bd_addr_t bd_addr;    /*!< device address           */
+    } add_dev;                    /*!< HIDH callback param of ESP_HIDH_ADD_DEV_EVT */
+
+    /**
+     * @brief ESP_HIDH_RMV_DEV_EVT
+     */
+    struct hidh_rmv_dev_evt_param {
+        esp_hidh_status_t status; /*!< operation status         */
+        uint8_t handle;           /*!< device handle            */
+        esp_bd_addr_t bd_addr;    /*!< device address           */
+    } rmv_dev;                    /*!< HIDH callback param of ESP_HIDH_RMV_DEV_EVT */
+
+    /**
+     * @brief ESP_HIDH_GET_DSCP_EVT
+     */
+    struct hidh_get_dscp_evt_param {
+        esp_hidh_status_t status; /*!< operation status         */
+        uint8_t handle;           /*!< device handle            */
+        bool added;               /*!< Indicate if added        */
+        uint16_t vendor_id;       /*!< Vendor ID */
+        uint16_t product_id;      /*!< Product ID */
+        uint16_t version;         /*!< Version */
+        uint16_t ssr_max_latency; /*!< SSR max latency */
+        uint16_t ssr_min_tout;    /*!< SSR min timeout */
+        uint8_t ctry_code;        /*!< Country Code */
+        uint16_t dl_len;          /*!< Device descriptor length */
+        uint8_t *dsc_list;        /*!< Device descriptor pointer */
+    } dscp;                       /*!< HIDH callback param of ESP_HIDH_GET_DSCP_EVT */
+
+    /**
+     * @brief ESP_HIDH_SET_INFO_EVT
+     */
+    struct hidh_set_info_evt_param {
+        esp_hidh_status_t status; /*!< operation status         */
+        uint8_t handle;           /*!< device handle            */
+        esp_bd_addr_t bd_addr;    /*!< device address           */
+    } set_info;                   /*!< HIDH callback param of ESP_HIDH_SET_INFO_EVT */
+} esp_hidh_cb_param_t;
+
+/**
+ * @brief       HID host callback function type
+ * @param       event:      Event type
+ * @param       param:      Point to callback parameter, currently is union type
+ */
+typedef void (esp_hh_cb_t)(esp_hidh_cb_event_t event, esp_hidh_cb_param_t *param);
+
+/**
+ * @brief       This function is called to init callbacks with HID host module.
+ *
+ * @param[in]   callback:   pointer to the init callback function.
+ *
+ * @return
+ *              - ESP_OK: success
+ *              - other: failed
+ */
+esp_err_t esp_bt_hid_host_register_callback(esp_hh_cb_t callback);
+
+/**
+ * @brief       This function initializes HID host. This function should be called after esp_bluedroid_enable() and
+ *              esp_blueroid_init() success, and should be called after esp_bt_hid_host_register_callback().
+ *              When the operation is complete the callback function will be called with ESP_HIDH_INIT_EVT.
+ *
+ * @return
+ *              - ESP_OK: success
+ *              - other: failed
+ */
+esp_err_t esp_bt_hid_host_init(void);
+
+/**
+ * @brief       Closes the interface. This function should be called after esp_bluedroid_enable() and
+ *              esp_blueroid_init() success, and should be called after esp_bt_hid_host_init().
+ *              When the operation is complete the callback function will be called with ESP_HIDH_DEINIT_EVT.
+ *
+ * @return      - ESP_OK: success
+ *              - other: failed
+ */
+esp_err_t esp_bt_hid_host_deinit(void);
+
+/**
+ * @brief       Connect to hid device. When the operation is complete the callback
+ *              function will be called with ESP_HIDH_OPEN_EVT.
+ *
+ * @param[in]   bd_addr:  Remote device bluetooth device address.
+ *
+ * @return      - ESP_OK: success
+ *              - other: failed
+ */
+esp_err_t esp_bt_hid_host_connect(esp_bd_addr_t bd_addr);
+
+/**
+ * @brief       Disconnect from hid device. When the operation is complete the callback
+ *              function will be called with ESP_HIDH_CLOSE_EVT.
+ *
+ * @param[in]   bd_addr:  Remote device bluetooth device address.
+ *
+ * @return      - ESP_OK: success
+ *              - other: failed
+ */
+esp_err_t esp_bt_hid_host_disconnect(esp_bd_addr_t bd_addr);
+
+/**
+ * @brief       Virtual UnPlug (VUP) the specified HID device. When the operation is complete the callback
+ *              function will be called with ESP_HIDH_VC_UNPLUG_EVT.
+ *
+ * @param[in]   bd_addr:  Remote device bluetooth device address.
+ *
+ * @return      - ESP_OK: success
+ *              - other: failed
+ */
+esp_err_t esp_bt_hid_host_virtual_cable_unplug(esp_bd_addr_t bd_addr);
+
+/**
+ * @brief       Set the HID device descriptor for the specified HID device. When the operation is complete the callback
+ *              function will be called with ESP_HIDH_SET_INFO_EVT.
+ *
+ * @param[in]   bd_addr:  Remote device bluetooth device address.
+ * @param[in]   hid_info:  HID device descriptor structure.
+ *
+ * @return      - ESP_OK: success
+ *              - other: failed
+ */
+esp_err_t esp_bt_hid_host_set_info(esp_bd_addr_t bd_addr, esp_hidh_hid_info_t *hid_info);
+
+/**
+ * @brief       Get the HID proto mode. When the operation is complete the callback
+ *              function will be called with ESP_HIDH_GET_PROTO_EVT.
+ *
+ * @param[in]   bd_addr:  Remote device bluetooth device address.
+ *
+ * @return
+ *              - ESP_OK: success
+ *              - other: failed
+ */
+esp_err_t esp_bt_hid_host_get_protocol(esp_bd_addr_t bd_addr);
+
+/**
+ * @brief       Set the HID proto mode. When the operation is complete the callback
+ *              function will be called with ESP_HIDH_SET_PROTO_EVT.
+ *
+ * @param[in]   bd_addr:  Remote device bluetooth device address.
+ * @param[in]   protocol_mode:  Protocol mode type.
+ *
+ * @return
+ *              - ESP_OK: success
+ *              - other: failed
+ */
+esp_err_t esp_bt_hid_host_set_protocol(esp_bd_addr_t bd_addr, esp_hidh_protocol_mode_t protocol_mode);
+
+/**
+ * @brief       Get the HID Idle Time. When the operation is complete the callback
+ *              function will be called with ESP_HIDH_GET_IDLE_EVT.
+ *
+ * @param[in]   bd_addr:  Remote device bluetooth device address.
+ *
+ * @return
+ *              - ESP_OK: success
+ *              - other: failed
+ */
+esp_err_t esp_bt_hid_host_get_idle(esp_bd_addr_t bd_addr);
+
+/**
+ * @brief       Set the HID Idle Time. When the operation is complete the callback
+ *              function will be called with ESP_HIDH_SET_IDLE_EVT.
+ *
+ * @param[in]   bd_addr:  Remote device bluetooth device address.
+ * @param[in]   idle_time:  Idle time rate
+ *
+ * @return    - ESP_OK: success
+ *            - other: failed
+ */
+esp_err_t esp_bt_hid_host_set_idle(esp_bd_addr_t bd_addr, uint16_t idle_time);
+
+/**
+ * @brief       Send a GET_REPORT to HID device. When the operation is complete the callback
+ *              function will be called with ESP_HIDH_GET_RPT_EVT.
+ *
+ * @param[in]   bd_addr:  Remote device bluetooth device address.
+ * @param[in]   report_type:  Report type
+ * @param[in]   report_id:  Report id
+ * @param[in]   buffer_size:  Buffer size
+ *
+ * @return      - ESP_OK: success
+ *              - other: failed
+ */
+esp_err_t esp_bt_hid_host_get_report(esp_bd_addr_t bd_addr, esp_hidh_report_type_t report_type, uint8_t report_id,
+                                     int buffer_size);
+
+/**
+ * @brief       Send a SET_REPORT to HID device. When the operation is complete the callback
+ *              function will be called with ESP_HIDH_SET_RPT_EVT.
+ *
+ * @param[in]   bd_addr:  Remote device bluetooth device address.
+ * @param[in]   report_type:  Report type
+ * @param[in]   report:  Report data pointer
+ * @param[in]   len:  Report data length
+ *
+ * @return      - ESP_OK: success
+ *              - other: failed
+ */
+esp_err_t esp_bt_hid_host_set_report(esp_bd_addr_t bd_addr, esp_hidh_report_type_t report_type, uint8_t *report,
+                                     size_t len);
+
+/**
+ * @brief       Send data to HID device. When the operation is complete the callback
+ *              function will be called with ESP_HIDH_DATA_EVT.
+ *
+ * @param[in]   bd_addr:  Remote device bluetooth device address.
+ * @param[in]   data:  Data pointer
+ * @param[in]   len:  Data length
+ *
+ * @return      - ESP_OK: success
+ *              - other: failed
+ */
+esp_err_t esp_bt_hid_host_send_data(esp_bd_addr_t bd_addr, uint8_t *data, size_t len);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
--- a/tools/sdk/esp32/include/bt/include/esp32/include/esp_bt.h
+++ b/tools/sdk/esp32/include/bt/include/esp32/include/esp_bt.h
@ -1,16 +1,8 @@
-// Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-
-//     http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
+/*
+ * SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */

 #ifndef __ESP_BT_H__
 #define __ESP_BT_H__
@ -149,6 +141,12 @@ the adv packet will be discarded until the memory is restored. */
 #define BTDM_CTRL_AUTO_LATENCY_EFF false
 #endif

+#ifdef CONFIG_BTDM_CTRL_HLI
+#define BTDM_CTRL_HLI CONFIG_BTDM_CTRL_HLI
+#else
+#define BTDM_CTRL_HLI false
+#endif
+
 #ifdef CONFIG_BTDM_CTRL_LEGACY_AUTH_VENDOR_EVT_EFF
 #define BTDM_CTRL_LEGACY_AUTH_VENDOR_EVT_EFF CONFIG_BTDM_CTRL_LEGACY_AUTH_VENDOR_EVT_EFF
 #else
@ -183,6 +181,7 @@ the adv packet will be discarded until the memory is restored. */
    .ble_sca = CONFIG_BTDM_BLE_SLEEP_CLOCK_ACCURACY_INDEX_EFF,             \
    .pcm_role = CONFIG_BTDM_CTRL_PCM_ROLE_EFF,                             \
    .pcm_polar = CONFIG_BTDM_CTRL_PCM_POLAR_EFF,                           \
+    .hli = BTDM_CTRL_HLI,                                                  \
    .magic = ESP_BT_CONTROLLER_CONFIG_MAGIC_VAL,                           \
 };

@ -224,6 +223,7 @@ typedef struct {
    uint8_t ble_sca;                        /*!< BLE low power crystal accuracy index */
    uint8_t pcm_role;                       /*!< PCM role (master & slave)*/
    uint8_t pcm_polar;                      /*!< PCM polar trig (falling clk edge & rising clk edge) */
+    bool hli;                               /*!< Using high level interrupt or not */
    uint32_t magic;                         /*!< Magic number */
 } esp_bt_controller_config_t;

@ -383,12 +383,6 @@ esp_err_t esp_bt_controller_disable(void);
 */
 esp_bt_controller_status_t esp_bt_controller_get_status(void);

-/**
- * @brief  Get BT MAC address.
- * @return Array pointer of length 6 storing MAC address value.
- */
-uint8_t* esp_bt_get_mac(void);
-
 /** @brief esp_vhci_host_callback
 *  used for vhci call host function to notify what host need to do
 */
@ -528,6 +522,16 @@ esp_err_t esp_bt_sleep_disable(void);
 */
 esp_err_t esp_ble_scan_dupilcate_list_flush(void);

+/**
+ * @brief bt Wi-Fi power domain power on
+ */
+void esp_wifi_bt_power_domain_on(void);
+
+/**
+ * @brief bt Wi-Fi power domain power off
+ */
+void esp_wifi_bt_power_domain_off(void);
+
 #ifdef __cplusplus
 }
 #endif
--- a/tools/sdk/esp32/include/coap/libcoap/include/coap2/async.h
+++ b/tools/sdk/esp32/include/coap/libcoap/include/coap2/async.h
@ -1,148 +0,0 @@
-/*
- * async.h -- state management for asynchronous messages
- *
- * Copyright (C) 2010-2011 Olaf Bergmann <bergmann@tzi.org>
- *
- * This file is part of the CoAP library libcoap. Please see README for terms
- * of use.
- */
-
-/**
- * @file async.h
- * @brief State management for asynchronous messages
- */
-
-#ifndef COAP_ASYNC_H_
-#define COAP_ASYNC_H_
-
-#include "net.h"
-
-#ifndef WITHOUT_ASYNC
-
-/**
- * @defgroup coap_async Asynchronous Messaging
- * @{
- * Structure for managing asynchronous state of CoAP resources. A
- * coap_resource_t object holds a list of coap_async_state_t objects that can be
- * used to generate a separate response in case a result of an operation cannot
- * be delivered in time, or the resource has been explicitly subscribed to with
- * the option @c observe.
- */
-typedef struct coap_async_state_t {
-  unsigned char flags;  /**< holds the flags to control behaviour */
-
-  /**
-   * Holds the internal time when the object was registered with a
-   * resource. This field will be updated whenever
-   * coap_register_async() is called for a specific resource.
-   */
-  coap_tick_t created;
-
-  /**
-   * This field can be used to register opaque application data with the
-   * asynchronous state object.
-   */
-  void *appdata;
-  coap_session_t *session;         /**< transaction session */
-  coap_tid_t id;                   /**< transaction id */
-  struct coap_async_state_t *next; /**< internally used for linking */
-  size_t tokenlen;                 /**< length of the token */
-  uint8_t token[8];                /**< the token to use in a response */
-} coap_async_state_t;
-
-/* Definitions for Async Status Flags These flags can be used to control the
- * behaviour of asynchronous response generation.
- */
-#define COAP_ASYNC_CONFIRM   0x01  /**< send confirmable response */
-#define COAP_ASYNC_SEPARATE  0x02  /**< send separate response */
-#define COAP_ASYNC_OBSERVED  0x04  /**< the resource is being observed */
-
-/** release application data on destruction */
-#define COAP_ASYNC_RELEASE_DATA  0x08
-
-/**
- * Allocates a new coap_async_state_t object and fills its fields according to
- * the given @p request. The @p flags are used to control generation of empty
- * ACK responses to stop retransmissions and to release registered @p data when
- * the resource is deleted by coap_free_async(). This function returns a pointer
- * to the registered coap_async_t object or @c NULL on error. Note that this
- * function will return @c NULL in case that an object with the same identifier
- * is already registered.
- *
- * @param context  The context to use.
- * @param session  The session that is used for asynchronous transmissions.
- * @param request  The request that is handled asynchronously.
- * @param flags    Flags to control state management.
- * @param data     Opaque application data to register. Note that the
- *                 storage occupied by @p data is released on destruction
- *                 only if flag COAP_ASYNC_RELEASE_DATA is set.
- *
- * @return         A pointer to the registered coap_async_state_t object or @c
- *                 NULL in case of an error.
- */
-coap_async_state_t *
-coap_register_async(coap_context_t *context,
-                    coap_session_t *session,
-                    coap_pdu_t *request,
-                    unsigned char flags,
-                    void *data);
-
-/**
- * Removes the state object identified by @p id from @p context. The removed
- * object is returned in @p s, if found. Otherwise, @p s is undefined. This
- * function returns @c 1 if the object was removed, @c 0 otherwise. Note that
- * the storage allocated for the stored object is not released by this
- * functions. You will have to call coap_free_async() to do so.
- *
- * @param context The context where the async object is registered.
- * @param session  The session that is used for asynchronous transmissions.
- * @param id      The identifier of the asynchronous transaction.
- * @param s       Will be set to the object identified by @p id after removal.
- *
- * @return        @c 1 if object was removed and @p s updated, or @c 0 if no
- *                object was found with the given id. @p s is valid only if the
- *                return value is @c 1.
- */
-int coap_remove_async(coap_context_t *context,
-                      coap_session_t *session,
-                      coap_tid_t id,
-                      coap_async_state_t **s);
-
-/**
- * Releases the memory that was allocated by coap_async_state_init() for the
- * object @p s. The registered application data will be released automatically
- * if COAP_ASYNC_RELEASE_DATA is set.
- *
- * @param state The object to delete.
- */
-void
-coap_free_async(coap_async_state_t *state);
-
-/**
- * Retrieves the object identified by @p id from the list of asynchronous
- * transactions that are registered with @p context. This function returns a
- * pointer to that object or @c NULL if not found.
- *
- * @param context The context where the asynchronous objects are registered
- *                with.
- * @param session  The session that is used for asynchronous transmissions.
- * @param id      The id of the object to retrieve.
- *
- * @return        A pointer to the object identified by @p id or @c NULL if
- *                not found.
- */
-coap_async_state_t *coap_find_async(coap_context_t *context, coap_session_t *session, coap_tid_t id);
-
-/**
- * Updates the time stamp of @p s.
- *
- * @param s The state object to update.
- */
-COAP_STATIC_INLINE void
-coap_touch_async(coap_async_state_t *s) { coap_ticks(&s->created); }
-
-/** @} */
-
-#endif /*  WITHOUT_ASYNC */
-
-#endif /* COAP_ASYNC_H_ */
--- a/tools/sdk/esp32/include/coap/libcoap/include/coap2/bits.h
+++ b/tools/sdk/esp32/include/coap/libcoap/include/coap2/bits.h
@ -1,78 +0,0 @@
-/*
- * bits.h -- bit vector manipulation
- *
- * Copyright (C) 2010-2011 Olaf Bergmann <bergmann@tzi.org>
- *
- * This file is part of the CoAP library libcoap. Please see README for terms
- * of use.
- */
-
-/**
- * @file bits.h
- * @brief Bit vector manipulation
- */
-
-#ifndef COAP_BITS_H_
-#define COAP_BITS_H_
-
-#include <stdint.h>
-
-/**
- * Sets the bit @p bit in bit-vector @p vec. This function returns @c 1 if bit
- * was set or @c -1 on error (i.e. when the given bit does not fit in the
- * vector).
- *
- * @param vec  The bit-vector to change.
- * @param size The size of @p vec in bytes.
- * @param bit  The bit to set in @p vec.
- *
- * @return     @c -1 if @p bit does not fit into @p vec, @c 1 otherwise.
- */
-COAP_STATIC_INLINE int
-bits_setb(uint8_t *vec, size_t size, uint8_t bit) {
-  if (size <= ((size_t)bit >> 3))
-    return -1;
-
-  *(vec + (bit >> 3)) |= (uint8_t)(1 << (bit & 0x07));
-  return 1;
-}
-
-/**
- * Clears the bit @p bit from bit-vector @p vec. This function returns @c 1 if
- * bit was cleared or @c -1 on error (i.e. when the given bit does not fit in
- * the vector).
- *
- * @param vec  The bit-vector to change.
- * @param size The size of @p vec in bytes.
- * @param bit  The bit to clear from @p vec.
- *
- * @return     @c -1 if @p bit does not fit into @p vec, @c 1 otherwise.
- */
-COAP_STATIC_INLINE int
-bits_clrb(uint8_t *vec, size_t size, uint8_t bit) {
-  if (size <= ((size_t)bit >> 3))
-    return -1;
-
-  *(vec + (bit >> 3)) &= (uint8_t)(~(1 << (bit & 0x07)));
-  return 1;
-}
-
-/**
- * Gets the status of bit @p bit from bit-vector @p vec. This function returns
- * @c 1 if the bit is set, @c 0 otherwise (even in case of an error).
- *
- * @param vec  The bit-vector to read from.
- * @param size The size of @p vec in bytes.
- * @param bit  The bit to get from @p vec.
- *
- * @return     @c 1 if the bit is set, @c 0 otherwise.
- */
-COAP_STATIC_INLINE int
-bits_getb(const uint8_t *vec, size_t size, uint8_t bit) {
-  if (size <= ((size_t)bit >> 3))
-    return -1;
-
-  return (*(vec + (bit >> 3)) & (1 << (bit & 0x07))) != 0;
-}
-
-#endif /* COAP_BITS_H_ */
--- a/tools/sdk/esp32/include/coap/libcoap/include/coap2/block.h
+++ b/tools/sdk/esp32/include/coap/libcoap/include/coap2/block.h
@ -1,173 +0,0 @@
-/*
- * block.h -- block transfer
- *
- * Copyright (C) 2010-2012,2014-2015 Olaf Bergmann <bergmann@tzi.org>
- *
- * This file is part of the CoAP library libcoap. Please see README for terms
- * of use.
- */
-
-#ifndef COAP_BLOCK_H_
-#define COAP_BLOCK_H_
-
-#include "encode.h"
-#include "option.h"
-#include "pdu.h"
-
-struct coap_resource_t;
-struct coap_session_t;
-
-/**
- * @defgroup block Block Transfer
- * API functions for handling PDUs using CoAP BLOCK options
- * @{
- */
-
-#ifndef COAP_MAX_BLOCK_SZX
-/**
- * The largest value for the SZX component in a Block option.
- */
-#define COAP_MAX_BLOCK_SZX      6
-#endif /* COAP_MAX_BLOCK_SZX */
-
-/**
- * Structure of Block options.
- */
-typedef struct {
-  unsigned int num;       /**< block number */
-  unsigned int m:1;       /**< 1 if more blocks follow, 0 otherwise */
-  unsigned int szx:3;     /**< block size */
-} coap_block_t;
-
-/**
- * Returns the value of the least significant byte of a Block option @p opt.
- * For zero-length options (i.e. num == m == szx == 0), COAP_OPT_BLOCK_LAST
- * returns @c NULL.
- */
-#define COAP_OPT_BLOCK_LAST(opt) \
-  (coap_opt_length(opt) ? (coap_opt_value(opt) + (coap_opt_length(opt)-1)) : 0)
-
-/** Returns the value of the More-bit of a Block option @p opt. */
-#define COAP_OPT_BLOCK_MORE(opt) \
-  (coap_opt_length(opt) ? (*COAP_OPT_BLOCK_LAST(opt) & 0x08) : 0)
-
-/** Returns the value of the SZX-field of a Block option @p opt. */
-#define COAP_OPT_BLOCK_SZX(opt)  \
-  (coap_opt_length(opt) ? (*COAP_OPT_BLOCK_LAST(opt) & 0x07) : 0)
-
-/**
- * Returns the value of field @c num in the given block option @p block_opt.
- */
-unsigned int coap_opt_block_num(const coap_opt_t *block_opt);
-
-/**
- * Checks if more than @p num blocks are required to deliver @p data_len
- * bytes of data for a block size of 1 << (@p szx + 4).
- */
-COAP_STATIC_INLINE int
-coap_more_blocks(size_t data_len, unsigned int num, uint16_t szx) {
-  return ((num+1) << (szx + 4)) < data_len;
-}
-
-#if 0
-/** Sets the More-bit in @p block_opt */
-COAP_STATIC_INLINE void
-coap_opt_block_set_m(coap_opt_t *block_opt, int m) {
-  if (m)
-    *(coap_opt_value(block_opt) + (coap_opt_length(block_opt) - 1)) |= 0x08;
-  else
-    *(coap_opt_value(block_opt) + (coap_opt_length(block_opt) - 1)) &= ~0x08;
-}
-#endif
-
-/**
- * Initializes @p block from @p pdu. @p type must be either COAP_OPTION_BLOCK1
- * or COAP_OPTION_BLOCK2. When option @p type was found in @p pdu, @p block is
- * initialized with values from this option and the function returns the value
- * @c 1. Otherwise, @c 0 is returned.
- *
- * @param pdu   The pdu to search for option @p type.
- * @param type  The option to search for (must be COAP_OPTION_BLOCK1 or
- *              COAP_OPTION_BLOCK2).
- * @param block The block structure to initilize.
- *
- * @return      @c 1 on success, @c 0 otherwise.
- */
-int coap_get_block(coap_pdu_t *pdu, uint16_t type, coap_block_t *block);
-
-/**
- * Writes a block option of type @p type to message @p pdu. If the requested
- * block size is too large to fit in @p pdu, it is reduced accordingly. An
- * exception is made for the final block when less space is required. The actual
- * length of the resource is specified in @p data_length.
- *
- * This function may change *block to reflect the values written to @p pdu. As
- * the function takes into consideration the remaining space @p pdu, no more
- * options should be added after coap_write_block_opt() has returned.
- *
- * @param block       The block structure to use. On return, this object is
- *                    updated according to the values that have been written to
- *                    @p pdu.
- * @param type        COAP_OPTION_BLOCK1 or COAP_OPTION_BLOCK2.
- * @param pdu         The message where the block option should be written.
- * @param data_length The length of the actual data that will be added the @p
- *                    pdu by calling coap_add_block().
- *
- * @return            @c 1 on success, or a negative value on error.
- */
-int coap_write_block_opt(coap_block_t *block,
-                         uint16_t type,
-                         coap_pdu_t *pdu,
-                         size_t data_length);
-
-/**
- * Adds the @p block_num block of size 1 << (@p block_szx + 4) from source @p
- * data to @p pdu.
- *
- * @param pdu       The message to add the block.
- * @param len       The length of @p data.
- * @param data      The source data to fill the block with.
- * @param block_num The actual block number.
- * @param block_szx Encoded size of block @p block_number.
- *
- * @return          @c 1 on success, @c 0 otherwise.
- */
-int coap_add_block(coap_pdu_t *pdu,
-                   unsigned int len,
-                   const uint8_t *data,
-                   unsigned int block_num,
-                   unsigned char block_szx);
-
-/**
- * Adds the appropriate part of @p data to the @p response pdu.  If blocks are
- * required, then the appropriate block will be added to the PDU and sent.
- * Adds a ETAG option that is the hash of the entire data if the data is to be
- * split into blocks
- * Used by a GET request handler.
- *
- * @param resource   The resource the data is associated with.
- * @param session    The coap session.
- * @param request    The requesting pdu.
- * @param response   The response pdu.
- * @param token      The token taken from the (original) requesting pdu.
- * @param media_type The format of the data.
- * @param maxage     The maxmimum life of the data. If @c -1, then there
- *                   is no maxage.
- * @param length     The total length of the data.
- * @param data       The entire data block to transmit.
- *
- */
-void
-coap_add_data_blocked_response(struct coap_resource_t *resource,
-                               struct coap_session_t *session,
-                               coap_pdu_t *request,
-                               coap_pdu_t *response,
-                               const coap_binary_t *token,
-                               uint16_t media_type,
-                               int maxage,
-                               size_t length,
-                               const uint8_t* data);
-
-/**@}*/
-
-#endif /* COAP_BLOCK_H_ */
--- a/tools/sdk/esp32/include/coap/libcoap/include/coap2/coap_dtls.h
+++ b/tools/sdk/esp32/include/coap/libcoap/include/coap2/coap_dtls.h
@ -1,611 +0,0 @@
-/*
- * coap_dtls.h -- (Datagram) Transport Layer Support for libcoap
- *
- * Copyright (C) 2016 Olaf Bergmann <bergmann@tzi.org>
- * Copyright (C) 2017 Jean-Claude Michelou <jcm@spinetix.com>
- *
- * This file is part of the CoAP library libcoap. Please see README for terms
- * of use.
- */
-
-#ifndef COAP_DTLS_H_
-#define COAP_DTLS_H_
-
-#include "coap_time.h"
-
-struct coap_context_t;
-struct coap_session_t;
-struct coap_dtls_pki_t;
-
-/**
- * @defgroup dtls DTLS Support
- * API functions for interfacing with DTLS libraries.
- * @{
- */
-
-/**
- * Check whether DTLS is available.
- *
- * @return @c 1 if support for DTLS is enabled, or @c 0 otherwise.
- */
-int coap_dtls_is_supported(void);
-
-/**
- * Check whether TLS is available.
- *
- * @return @c 1 if support for TLS is enabled, or @c 0 otherwise.
- */
-int coap_tls_is_supported(void);
-
-#define COAP_TLS_LIBRARY_NOTLS 0 /**< No DTLS library */
-#define COAP_TLS_LIBRARY_TINYDTLS 1 /**< Using TinyDTLS library */
-#define COAP_TLS_LIBRARY_OPENSSL 2 /**< Using OpenSSL library */
-#define COAP_TLS_LIBRARY_GNUTLS 3 /**< Using GnuTLS library */
-
-/**
- * The structure used for returning the underlying (D)TLS library
- * information.
- */
-typedef struct coap_tls_version_t {
-  uint64_t version; /**< (D)TLS runtime Library Version */
-  int type; /**< Library type. One of COAP_TLS_LIBRARY_* */
-  uint64_t built_version; /**< (D)TLS Built against Library Version */
-} coap_tls_version_t;
-
-/**
- * Determine the type and version of the underlying (D)TLS library.
- *
- * @return The version and type of library libcoap was compiled against.
- */
-coap_tls_version_t *coap_get_tls_library_version(void);
-
-/**
- * Additional Security setup handler that can be set up by
- * coap_context_set_pki().
- * Invoked when libcoap has done the validation checks at the TLS level,
- * but the application needs to do some additional checks/changes/updates.
- *
- * @param tls_session The security session definition - e.g. SSL * for OpenSSL.
- *                    NULL if server call-back.
- *                    This will be dependent on the underlying TLS library -
- *                    see coap_get_tls_library_version()
- * @param setup_data A structure containing setup data originally passed into
- *                   coap_context_set_pki() or coap_new_client_session_pki().
- *
- * @return @c 1 if successful, else @c 0.
- */
-typedef int (*coap_dtls_security_setup_t)(void* tls_session,
-                                        struct coap_dtls_pki_t *setup_data);
-
-/**
- * CN Validation call-back that can be set up by coap_context_set_pki().
- * Invoked when libcoap has done the validation checks at the TLS level,
- * but the application needs to check that the CN is allowed.
- * CN is the SubjectAltName in the cert, if not present, then the leftmost
- * Common Name (CN) component of the subject name.
- *
- * @param cn  The determined CN from the certificate
- * @param asn1_public_cert  The ASN.1 DER encoded X.509 certificate
- * @param asn1_length  The ASN.1 length
- * @param coap_session  The CoAP session associated with the certificate update
- * @param depth  Depth in cert chain.  If 0, then client cert, else a CA
- * @param validated  TLS layer can find no issues if 1
- * @param arg  The same as was passed into coap_context_set_pki()
- *             in setup_data->cn_call_back_arg
- *
- * @return @c 1 if accepted, else @c 0 if to be rejected.
- */
-typedef int (*coap_dtls_cn_callback_t)(const char *cn,
-             const uint8_t *asn1_public_cert,
-             size_t asn1_length,
-             struct coap_session_t *coap_session,
-             unsigned depth,
-             int validated,
-             void *arg);
-
-/**
- * The enum used for determining the provided PKI ASN.1 (DER) Private Key
- * formats.
- */
-typedef enum coap_asn1_privatekey_type_t {
-  COAP_ASN1_PKEY_NONE,     /**< NONE */
-  COAP_ASN1_PKEY_RSA,      /**< RSA type */
-  COAP_ASN1_PKEY_RSA2,     /**< RSA2 type */
-  COAP_ASN1_PKEY_DSA,      /**< DSA type */
-  COAP_ASN1_PKEY_DSA1,     /**< DSA1 type */
-  COAP_ASN1_PKEY_DSA2,     /**< DSA2 type */
-  COAP_ASN1_PKEY_DSA3,     /**< DSA3 type */
-  COAP_ASN1_PKEY_DSA4,     /**< DSA4 type */
-  COAP_ASN1_PKEY_DH,       /**< DH type */
-  COAP_ASN1_PKEY_DHX,      /**< DHX type */
-  COAP_ASN1_PKEY_EC,       /**< EC type */
-  COAP_ASN1_PKEY_HMAC,     /**< HMAC type */
-  COAP_ASN1_PKEY_CMAC,     /**< CMAC type */
-  COAP_ASN1_PKEY_TLS1_PRF, /**< TLS1_PRF type */
-  COAP_ASN1_PKEY_HKDF      /**< HKDF type */
-} coap_asn1_privatekey_type_t;
-
-/**
- * The enum used for determining the PKI key formats.
- */
-typedef enum coap_pki_key_t {
-  COAP_PKI_KEY_PEM = 0,   /**< The PKI key type is PEM */
-  COAP_PKI_KEY_ASN1,      /**< The PKI key type is ASN.1 (DER) */
-} coap_pki_key_t;
-
-/**
- * The structure that holds the PKI PEM definitions.
- */
-typedef struct coap_pki_key_pem_t {
-  const char *ca_file;       /**< File location of Common CA in PEM format */
-  const char *public_cert;   /**< File location of Public Cert in PEM format */
-  const char *private_key;   /**< File location of Private Key in PEM format */
-} coap_pki_key_pem_t;
-
-/**
- * The structure that holds the PKI ASN.1 (DER) definitions.
- */
-typedef struct coap_pki_key_asn1_t {
-  const uint8_t *ca_cert;     /**< ASN1 (DER) Common CA Cert */
-  const uint8_t *public_cert; /**< ASN1 (DER) Public Cert */
-  const uint8_t *private_key; /**< ASN1 (DER) Private Key */
-  size_t ca_cert_len;         /**< ASN1 CA Cert length */
-  size_t public_cert_len;     /**< ASN1 Public Cert length */
-  size_t private_key_len;     /**< ASN1 Private Key length */
-  coap_asn1_privatekey_type_t private_key_type; /**< Private Key Type */
-} coap_pki_key_asn1_t;
-
-/**
- * The structure that holds the PKI key information.
- */
-typedef struct coap_dtls_key_t {
-  coap_pki_key_t key_type;          /**< key format type */
-  union {
-    coap_pki_key_pem_t pem;         /**< for PEM keys */
-    coap_pki_key_asn1_t asn1;       /**< for ASN.1 (DER) keys */
-  } key;
-} coap_dtls_key_t;
-
-/**
- * Server Name Indication (SNI) Validation call-back that can be set up by
- * coap_context_set_pki().
- * Invoked if the SNI is not previously seen and prior to sending a certificate
- * set back to the client so that the appropriate certificate set can be used
- * based on the requesting SNI.
- *
- * @param sni  The requested SNI
- * @param arg  The same as was passed into coap_context_set_pki()
- *             in setup_data->sni_call_back_arg
- *
- * @return New set of certificates to use, or @c NULL if SNI is to be rejected.
- */
-typedef coap_dtls_key_t *(*coap_dtls_sni_callback_t)(const char *sni,
-             void* arg);
-
-
-#define COAP_DTLS_PKI_SETUP_VERSION 1 /**< Latest PKI setup version */
-
-/**
- * The structure used for defining the PKI setup data to be used.
- */
-typedef struct coap_dtls_pki_t {
-  uint8_t version; /** Set to 1 to support this version of the struct */
-
-  /* Options to enable different TLS functionality in libcoap */
-  uint8_t verify_peer_cert;        /**< 1 if peer cert is to be verified */
-  uint8_t require_peer_cert;       /**< 1 if peer cert is required */
-  uint8_t allow_self_signed;       /**< 1 if self signed certs are allowed */
-  uint8_t allow_expired_certs;     /**< 1 if expired certs are allowed */
-  uint8_t cert_chain_validation;   /**< 1 if to check cert_chain_verify_depth */
-  uint8_t cert_chain_verify_depth; /**< recommended depth is 3 */
-  uint8_t check_cert_revocation;   /**< 1 if revocation checks wanted */
-  uint8_t allow_no_crl;            /**< 1 ignore if CRL not there */
-  uint8_t allow_expired_crl;       /**< 1 if expired crl is allowed */
-  uint8_t reserved[6];             /**< Reserved - must be set to 0 for
-                                        future compatibility */
-                                   /* Size of 6 chosen to align to next
-                                    * parameter, so if newly defined option
-                                    * it can use one of the reserverd slot so
-                                    * no need to change
-                                    * COAP_DTLS_PKI_SETUP_VERSION and just
-                                    * decrement the reserved[] count.
-                                    */
-
-  /** CN check call-back function.
-   * If not NULL, is called when the TLS connection has passed the configured
-   * TLS options above for the application to verify if the CN is valid.
-   */
-  coap_dtls_cn_callback_t validate_cn_call_back;
-  void *cn_call_back_arg;  /**< Passed in to the CN call-back function */
-
-  /** SNI check call-back function.
-   * If not @p NULL, called if the SNI is not previously seen and prior to
-   * sending a certificate set back to the client so that the appropriate
-   * certificate set can be used based on the requesting SNI.
-   */
-  coap_dtls_sni_callback_t validate_sni_call_back;
-  void *sni_call_back_arg;  /**< Passed in to the sni call-back function */
-
-  /** Additional Security call-back handler that is invoked when libcoap has
-   * done the standerd, defined validation checks at the TLS level,
-   * If not @p NULL, called from within the TLS Client Hello connection
-   * setup.
-   */
-  coap_dtls_security_setup_t additional_tls_setup_call_back;
-
-  char* client_sni;    /**<  If not NULL, SNI to use in client TLS setup.
-                             Owned by the client app and must remain valid
-                             during the call to coap_new_client_session_pki() */
-
-  coap_dtls_key_t pki_key;  /**< PKI key definition */
-} coap_dtls_pki_t;
-
-/** @} */
-
-/**
- * @defgroup dtls_internal DTLS Support (Internal)
- * Internal API functions for interfacing with DTLS libraries.
- * @{
- */
-
-/**
- * Creates a new DTLS context for the given @p coap_context. This function
- * returns a pointer to a new DTLS context object or @c NULL on error.
- *
- * Internal function.
- *
- * @param coap_context The CoAP context where the DTLS object shall be used.
- *
- * @return A DTLS context object or @c NULL on error.
- */
-void *
-coap_dtls_new_context(struct coap_context_t *coap_context);
-
-typedef enum coap_dtls_role_t {
-  COAP_DTLS_ROLE_CLIENT, /**< Internal function invoked for client */
-  COAP_DTLS_ROLE_SERVER  /**< Internal function invoked for server */
-} coap_dtls_role_t;
-
-/**
- * Set the DTLS context's default PSK information.
- * This does the PSK specifics following coap_dtls_new_context().
- * If @p COAP_DTLS_ROLE_SERVER, then identity hint will also get set.
- * If @p COAP_DTLS_ROLE_SERVER, then the information will get put into the
- * TLS library's context (from which sessions are derived).
- * If @p COAP_DTLS_ROLE_CLIENT, then the information will get put into the
- * TLS library's session.
- *
- * Internal function.
- *
- * @param coap_context The CoAP context.
- * @param identity_hint The default PSK server identity hint sent to a client.
- *                      Required parameter.  If @p NULL, will be set to "".
- *                      Empty string is a valid hint.
- *                      This parameter is ignored if COAP_DTLS_ROLE_CLIENT
- * @param role  One of @p COAP_DTLS_ROLE_CLIENT or @p COAP_DTLS_ROLE_SERVER
- *
- * @return @c 1 if successful, else @c 0.
- */
-
-int
-coap_dtls_context_set_psk(struct coap_context_t *coap_context,
-                          const char *identity_hint,
-                          coap_dtls_role_t role);
-
-/**
- * Set the DTLS context's default server PKI information.
- * This does the PKI specifics following coap_dtls_new_context().
- * If @p COAP_DTLS_ROLE_SERVER, then the information will get put into the
- * TLS library's context (from which sessions are derived).
- * If @p COAP_DTLS_ROLE_CLIENT, then the information will get put into the
- * TLS library's session.
- *
- * Internal function.
- *
- * @param coap_context The CoAP context.
- * @param setup_data     Setup information defining how PKI is to be setup.
- *                       Required parameter.  If @p NULL, PKI will not be
- *                       set up.
- * @param role  One of @p COAP_DTLS_ROLE_CLIENT or @p COAP_DTLS_ROLE_SERVER
- *
- * @return @c 1 if successful, else @c 0.
- */
-
-int
-coap_dtls_context_set_pki(struct coap_context_t *coap_context,
-                          coap_dtls_pki_t *setup_data,
-                          coap_dtls_role_t role);
-
-/**
- * Set the dtls context's default Root CA information for a client or server.
- *
- * Internal function.
- *
- * @param coap_context   The current coap_context_t object.
- * @param ca_file        If not @p NULL, is the full path name of a PEM encoded
- *                       file containing all the Root CAs to be used.
- * @param ca_dir         If not @p NULL, points to a directory containing PEM
- *                       encoded files containing all the Root CAs to be used.
- *
- * @return @c 1 if successful, else @c 0.
- */
-
-int
-coap_dtls_context_set_pki_root_cas(struct coap_context_t *coap_context,
-                                   const char *ca_file,
-                                   const char *ca_dir);
-
-/**
- * Check whether one of the coap_dtls_context_set_{psk|pki}() functions have
- * been called.
- *
- * Internal function.
- *
- * @param coap_context The current coap_context_t object.
- *
- * @return @c 1 if coap_dtls_context_set_{psk|pki}() called, else @c 0.
- */
-
-int coap_dtls_context_check_keys_enabled(struct coap_context_t *coap_context);
-
-/**
- * Releases the storage allocated for @p dtls_context.
- *
- * Internal function.
- *
- * @param dtls_context The DTLS context as returned by coap_dtls_new_context().
- */
-void coap_dtls_free_context(void *dtls_context);
-
-/**
- * Create a new client-side session. This should send a HELLO to the server.
- *
- * Internal function.
- *
- * @param coap_session   The CoAP session.
- *
- * @return Opaque handle to underlying TLS library object containing security
- *         parameters for the session.
-*/
-void *coap_dtls_new_client_session(struct coap_session_t *coap_session);
-
-/**
- * Create a new DTLS server-side session.
- * Called after coap_dtls_hello() has returned @c 1, signalling that a validated
- * HELLO was received from a client.
- * This should send a HELLO to the server.
- *
- * Internal function.
- *
- * @param coap_session   The CoAP session.
- *
- * @return Opaque handle to underlying TLS library object containing security
- *         parameters for the DTLS session.
- */
-void *coap_dtls_new_server_session(struct coap_session_t *coap_session);
-
-/**
- * Terminates the DTLS session (may send an ALERT if necessary) then frees the
- * underlying TLS library object containing security parameters for the session.
- *
- * Internal function.
- *
- * @param coap_session   The CoAP session.
- */
-void coap_dtls_free_session(struct coap_session_t *coap_session);
-
-/**
- * Notify of a change in the CoAP session's MTU, for example after
- * a PMTU update.
- *
- * Internal function.
- *
- * @param coap_session   The CoAP session.
- */
-void coap_dtls_session_update_mtu(struct coap_session_t *coap_session);
-
-/**
- * Send data to a DTLS peer.
- *
- * Internal function.
- *
- * @param coap_session The CoAP session.
- * @param data      pointer to data.
- * @param data_len  Number of bytes to send.
- *
- * @return @c 0 if this would be blocking, @c -1 if there is an error or the
- *         number of cleartext bytes sent.
- */
-int coap_dtls_send(struct coap_session_t *coap_session,
-                   const uint8_t *data,
-                   size_t data_len);
-
-/**
- * Check if timeout is handled per CoAP session or per CoAP context.
- *
- * Internal function.
- *
- * @return @c 1 of timeout and retransmit is per context, @c 0 if it is
- *         per session.
- */
-int coap_dtls_is_context_timeout(void);
-
-/**
- * Do all pending retransmits and get next timeout
- *
- * Internal function.
- *
- * @param dtls_context The DTLS context.
- *
- * @return @c 0 if no event is pending or date of the next retransmit.
- */
-coap_tick_t coap_dtls_get_context_timeout(void *dtls_context);
-
-/**
- * Get next timeout for this session.
- *
- * Internal function.
- *
- * @param coap_session The CoAP session.
- * @param now The current time in ticks.
- *
- * @return @c 0 If no event is pending or ticks time of the next retransmit.
- */
-coap_tick_t coap_dtls_get_timeout(struct coap_session_t *coap_session,
-                                  coap_tick_t now);
-
-/**
- * Handle a DTLS timeout expiration.
- *
- * Internal function.
- *
- * @param coap_session The CoAP session.
- */
-void coap_dtls_handle_timeout(struct coap_session_t *coap_session);
-
-/**
- * Handling incoming data from a DTLS peer.
- *
- * Internal function.
- *
- * @param coap_session The CoAP session.
- * @param data      Encrypted datagram.
- * @param data_len  Encrypted datagram size.
- *
- * @return Result of coap_handle_dgram on the decrypted CoAP PDU
- *         or @c -1 for error.
- */
-int coap_dtls_receive(struct coap_session_t *coap_session,
-                      const uint8_t *data,
-                      size_t data_len);
-
-/**
- * Handling client HELLO messages from a new candiate peer.
- * Note that session->tls is empty.
- *
- * Internal function.
- *
- * @param coap_session The CoAP session.
- * @param data      Encrypted datagram.
- * @param data_len  Encrypted datagram size.
- *
- * @return @c 0 if a cookie verification message has been sent, @c 1 if the
- *        HELLO contains a valid cookie and a server session should be created,
- *        @c -1 if the message is invalid.
- */
-int coap_dtls_hello(struct coap_session_t *coap_session,
-                    const uint8_t *data,
-                    size_t data_len);
-
-/**
- * Get DTLS overhead over cleartext PDUs.
- *
- * Internal function.
- *
- * @param coap_session The CoAP session.
- *
- * @return Maximum number of bytes added by DTLS layer.
- */
-unsigned int coap_dtls_get_overhead(struct coap_session_t *coap_session);
-
-/**
- * Create a new TLS client-side session.
- *
- * Internal function.
- *
- * @param coap_session The CoAP session.
- * @param connected Updated with whether the connection is connected yet or not.
- *                  @c 0 is not connected, @c 1 is connected.
- *
- * @return Opaque handle to underlying TLS library object containing security
- *         parameters for the session.
-*/
-void *coap_tls_new_client_session(struct coap_session_t *coap_session, int *connected);
-
-/**
- * Create a TLS new server-side session.
- *
- * Internal function.
- *
- * @param coap_session The CoAP session.
- * @param connected Updated with whether the connection is connected yet or not.
- *                  @c 0 is not connected, @c 1 is connected.
- *
- * @return Opaque handle to underlying TLS library object containing security
- *         parameters for the session.
- */
-void *coap_tls_new_server_session(struct coap_session_t *coap_session, int *connected);
-
-/**
- * Terminates the TLS session (may send an ALERT if necessary) then frees the
- * underlying TLS library object containing security parameters for the session.
- *
- * Internal function.
- *
- * @param coap_session The CoAP session.
- */
-void coap_tls_free_session( struct coap_session_t *coap_session );
-
-/**
- * Send data to a TLS peer, with implicit flush.
- *
- * Internal function.
- *
- * @param coap_session The CoAP session.
- * @param data      Pointer to data.
- * @param data_len  Number of bytes to send.
- *
- * @return          @c 0 if this should be retried, @c -1 if there is an error
- *                  or the number of cleartext bytes sent.
- */
-ssize_t coap_tls_write(struct coap_session_t *coap_session,
-                       const uint8_t *data,
-                       size_t data_len
-                       );
-
-/**
- * Read some data from a TLS peer.
- *
- * Internal function.
- *
- * @param coap_session The CoAP session.
- * @param data      Pointer to data.
- * @param data_len  Maximum number of bytes to read.
- *
- * @return          @c 0 if this should be retried, @c -1 if there is an error
- *                  or the number of cleartext bytes read.
- */
-ssize_t coap_tls_read(struct coap_session_t *coap_session,
-                      uint8_t *data,
-                      size_t data_len
-                      );
-
-/**
- * Initialize the underlying (D)TLS Library layer.
- *
- * Internal function.
- *
- */
-void coap_dtls_startup(void);
-
-/** @} */
-
-/**
- * @ingroup logging
- * Sets the (D)TLS logging level to the specified @p level.
- * Note: coap_log_level() will influence output if at a specified level.
- *
- * @param level The logging level to use - LOG_*
- */
-void coap_dtls_set_log_level(int level);
-
-/**
- * @ingroup logging
- * Get the current (D)TLS logging.
- *
- * @return The current log level (one of LOG_*).
- */
-int coap_dtls_get_log_level(void);
-
-
-#endif /* COAP_DTLS_H */
--- a/tools/sdk/esp32/include/coap/libcoap/include/coap2/coap_session.h
+++ b/tools/sdk/esp32/include/coap/libcoap/include/coap2/coap_session.h
@ -1,492 +0,0 @@
-/* coap_session.h -- Session management for libcoap
-*
-* Copyright (C) 2017 Jean-Claue Michelou <jcm@spinetix.com>
-*
-* This file is part of the CoAP library libcoap. Please see
-* README for terms of use.
-*/
-
-#ifndef COAP_SESSION_H_
-#define COAP_SESSION_H_
-
-
-#include "coap_io.h"
-#include "coap_time.h"
-#include "pdu.h"
-
-struct coap_endpoint_t;
-struct coap_context_t;
-struct coap_queue_t;
-
-/**
-* Abstraction of a fixed point number that can be used where necessary instead
-* of a float.  1,000 fractional bits equals one integer
-*/
-typedef struct coap_fixed_point_t {
-  uint16_t integer_part;    /**< Integer part of fixed point variable */
-  uint16_t fractional_part; /**< Fractional part of fixed point variable
-                                1/1000 (3 points) precision */
-} coap_fixed_point_t;
-
-#define COAP_DEFAULT_SESSION_TIMEOUT 300
-#define COAP_PARTIAL_SESSION_TIMEOUT_TICKS (30 * COAP_TICKS_PER_SECOND)
-#define COAP_DEFAULT_MAX_HANDSHAKE_SESSIONS 100
-
-#define COAP_PROTO_NOT_RELIABLE(p) ((p)==COAP_PROTO_UDP || (p)==COAP_PROTO_DTLS)
-#define COAP_PROTO_RELIABLE(p) ((p)==COAP_PROTO_TCP || (p)==COAP_PROTO_TLS)
-
-typedef uint8_t coap_session_type_t;
-/**
- * coap_session_type_t values
- */
-#define COAP_SESSION_TYPE_CLIENT 1  /**< client-side */
-#define COAP_SESSION_TYPE_SERVER 2  /**< server-side */
-#define COAP_SESSION_TYPE_HELLO  3  /**< server-side ephemeral session for responding to a client hello */
-
-typedef uint8_t coap_session_state_t;
-/**
- * coap_session_state_t values
- */
-#define COAP_SESSION_STATE_NONE                0
-#define COAP_SESSION_STATE_CONNECTING        1
-#define COAP_SESSION_STATE_HANDSHAKE        2
-#define COAP_SESSION_STATE_CSM                3
-#define COAP_SESSION_STATE_ESTABLISHED        4
-
-typedef struct coap_session_t {
-  struct coap_session_t *next;
-  coap_proto_t proto;               /**< protocol used */
-  coap_session_type_t type;         /**< client or server side socket */
-  coap_session_state_t state;       /**< current state of relationaship with peer */
-  unsigned ref;                     /**< reference count from queues */
-  unsigned tls_overhead;            /**< overhead of TLS layer */
-  unsigned mtu;                     /**< path or CSM mtu */
-  coap_address_t local_if;          /**< optional local interface address */
-  coap_address_t remote_addr;       /**< remote address and port */
-  coap_address_t local_addr;        /**< local address and port */
-  int ifindex;                      /**< interface index */
-  coap_socket_t sock;               /**< socket object for the session, if any */
-  struct coap_endpoint_t *endpoint; /**< session's endpoint */
-  struct coap_context_t *context;   /**< session's context */
-  void *tls;                        /**< security parameters */
-  uint16_t tx_mid;                  /**< the last message id that was used in this session */
-  uint8_t con_active;               /**< Active CON request sent */
-  struct coap_queue_t *delayqueue;  /**< list of delayed messages waiting to be sent */
-  size_t partial_write;             /**< if > 0 indicates number of bytes already written from the pdu at the head of sendqueue */
-  uint8_t read_header[8];           /**< storage space for header of incoming message header */
-  size_t partial_read;              /**< if > 0 indicates number of bytes already read for an incoming message */
-  coap_pdu_t *partial_pdu;          /**< incomplete incoming pdu */
-  coap_tick_t last_rx_tx;
-  coap_tick_t last_tx_rst;
-  coap_tick_t last_ping;
-  coap_tick_t last_pong;
-  coap_tick_t csm_tx;
-  uint8_t *psk_identity;
-  size_t psk_identity_len;
-  uint8_t *psk_key;
-  size_t psk_key_len;
-  void *app;                        /**< application-specific data */
-  unsigned int max_retransmit;      /**< maximum re-transmit count (default 4) */
-  coap_fixed_point_t ack_timeout;   /**< timeout waiting for ack (default 2 secs) */
-  coap_fixed_point_t ack_random_factor; /**< ack random factor backoff (default 1.5) */
-  unsigned int dtls_timeout_count;      /**< dtls setup retry counter */
-  int dtls_event;                       /**< Tracking any (D)TLS events on this sesison */
-} coap_session_t;
-
-/**
-* Increment reference counter on a session.
-*
-* @param session The CoAP session.
-* @return same as session
-*/
-coap_session_t *coap_session_reference(coap_session_t *session);
-
-/**
-* Decrement reference counter on a session.
-* Note that the session may be deleted as a result and should not be used
-* after this call.
-*
-* @param session The CoAP session.
-*/
-void coap_session_release(coap_session_t *session);
-
-/**
-* Stores @p data with the given session. This function overwrites any value
-* that has previously been stored with @p session.
-*/
-void coap_session_set_app_data(coap_session_t *session, void *data);
-
-/**
-* Returns any application-specific data that has been stored with @p
-* session using the function coap_session_set_app_data(). This function will
-* return @c NULL if no data has been stored.
-*/
-void *coap_session_get_app_data(const coap_session_t *session);
-
-/**
-* Notify session that it has failed.
-*
-* @param session The CoAP session.
-* @param reason The reason why the session was disconnected.
-*/
-void coap_session_disconnected(coap_session_t *session, coap_nack_reason_t reason);
-
-/**
-* Notify session transport has just connected and CSM exchange can now start.
-*
-* @param session The CoAP session.
-*/
-void coap_session_send_csm(coap_session_t *session);
-
-/**
-* Notify session that it has just connected or reconnected.
-*
-* @param session The CoAP session.
-*/
-void coap_session_connected(coap_session_t *session);
-
-/**
-* Set the session MTU. This is the maximum message size that can be sent,
-* excluding IP and UDP overhead.
-*
-* @param session The CoAP session.
-* @param mtu maximum message size
-*/
-void coap_session_set_mtu(coap_session_t *session, unsigned mtu);
-
-/**
- * Get maximum acceptable PDU size
- *
- * @param session The CoAP session.
- * @return maximum PDU size, not including header (but including token).
- */
-size_t coap_session_max_pdu_size(const coap_session_t *session);
-
-/**
-* Creates a new client session to the designated server.
-* @param ctx The CoAP context.
-* @param local_if Address of local interface. It is recommended to use NULL to let the operating system choose a suitable local interface. If an address is specified, the port number should be zero, which means that a free port is automatically selected.
-* @param server The server's address. If the port number is zero, the default port for the protocol will be used.
-* @param proto Protocol.
-*
-* @return A new CoAP session or NULL if failed. Call coap_session_release to free.
-*/
-coap_session_t *coap_new_client_session(
-  struct coap_context_t *ctx,
-  const coap_address_t *local_if,
-  const coap_address_t *server,
-  coap_proto_t proto
-);
-
-/**
-* Creates a new client session to the designated server with PSK credentials
-* @param ctx The CoAP context.
-* @param local_if Address of local interface. It is recommended to use NULL to let the operating system choose a suitable local interface. If an address is specified, the port number should be zero, which means that a free port is automatically selected.
-* @param server The server's address. If the port number is zero, the default port for the protocol will be used.
-* @param proto Protocol.
-* @param identity PSK client identity
-* @param key PSK shared key
-* @param key_len PSK shared key length
-*
-* @return A new CoAP session or NULL if failed. Call coap_session_release to free.
-*/
-coap_session_t *coap_new_client_session_psk(
-  struct coap_context_t *ctx,
-  const coap_address_t *local_if,
-  const coap_address_t *server,
-  coap_proto_t proto,
-  const char *identity,
-  const uint8_t *key,
-  unsigned key_len
-);
-
-struct coap_dtls_pki_t;
-
-/**
-* Creates a new client session to the designated server with PKI credentials
-* @param ctx The CoAP context.
-* @param local_if Address of local interface. It is recommended to use NULL to
-*                 let the operating system choose a suitable local interface.
-*                 If an address is specified, the port number should be zero,
-*                 which means that a free port is automatically selected.
-* @param server The server's address. If the port number is zero, the default
-*               port for the protocol will be used.
-* @param proto CoAP Protocol.
-* @param setup_data PKI parameters.
-*
-* @return A new CoAP session or NULL if failed. Call coap_session_release()
-*         to free.
-*/
-coap_session_t *coap_new_client_session_pki(
-  struct coap_context_t *ctx,
-  const coap_address_t *local_if,
-  const coap_address_t *server,
-  coap_proto_t proto,
-  struct coap_dtls_pki_t *setup_data
-);
-
-/**
-* Creates a new server session for the specified endpoint.
-* @param ctx The CoAP context.
-* @param ep An endpoint where an incoming connection request is pending.
-*
-* @return A new CoAP session or NULL if failed. Call coap_session_release to free.
-*/
-coap_session_t *coap_new_server_session(
-  struct coap_context_t *ctx,
-  struct coap_endpoint_t *ep
-);
-
-/**
-* Function interface for datagram data transmission. This function returns
-* the number of bytes that have been transmitted, or a value less than zero
-* on error.
-*
-* @param session          Session to send data on.
-* @param data             The data to send.
-* @param datalen          The actual length of @p data.
-*
-* @return                 The number of bytes written on success, or a value
-*                         less than zero on error.
-*/
-ssize_t coap_session_send(coap_session_t *session,
-  const uint8_t *data, size_t datalen);
-
-/**
-* Function interface for stream data transmission. This function returns
-* the number of bytes that have been transmitted, or a value less than zero
-* on error. The number of bytes written may be less than datalen because of
-* congestion control.
-*
-* @param session          Session to send data on.
-* @param data             The data to send.
-* @param datalen          The actual length of @p data.
-*
-* @return                 The number of bytes written on success, or a value
-*                         less than zero on error.
-*/
-ssize_t coap_session_write(coap_session_t *session,
-  const uint8_t *data, size_t datalen);
-
-/**
-* Send a pdu according to the session's protocol. This function returns
-* the number of bytes that have been transmitted, or a value less than zero
-* on error.
-*
-* @param session          Session to send pdu on.
-* @param pdu              The pdu to send.
-*
-* @return                 The number of bytes written on success, or a value
-*                         less than zero on error.
-*/
-ssize_t coap_session_send_pdu(coap_session_t *session, coap_pdu_t *pdu);
-
-
-/**
- * @ingroup logging
- * Get session description.
- *
- * @param session  The CoAP session.
- * @return description string.
- */
-const char *coap_session_str(const coap_session_t *session);
-
-ssize_t
-coap_session_delay_pdu(coap_session_t *session, coap_pdu_t *pdu,
-                       struct coap_queue_t *node);
-/**
-* Abstraction of virtual endpoint that can be attached to coap_context_t. The
-* tuple (handle, addr) must uniquely identify this endpoint.
-*/
-typedef struct coap_endpoint_t {
-  struct coap_endpoint_t *next;
-  struct coap_context_t *context; /**< endpoint's context */
-  coap_proto_t proto;             /**< protocol used on this interface */
-  uint16_t default_mtu;           /**< default mtu for this interface */
-  coap_socket_t sock;             /**< socket object for the interface, if any */
-  coap_address_t bind_addr;       /**< local interface address */
-  coap_session_t *sessions;       /**< list of active sessions */
-} coap_endpoint_t;
-
-/**
-* Create a new endpoint for communicating with peers.
-*
-* @param context        The coap context that will own the new endpoint
-* @param listen_addr    Address the endpoint will listen for incoming requests on or originate outgoing requests from. Use NULL to specify that no incoming request will be accepted and use a random endpoint.
-* @param proto          Protocol used on this endpoint
-*/
-
-coap_endpoint_t *coap_new_endpoint(struct coap_context_t *context, const coap_address_t *listen_addr, coap_proto_t proto);
-
-/**
-* Set the endpoint's default MTU. This is the maximum message size that can be
-* sent, excluding IP and UDP overhead.
-*
-* @param endpoint The CoAP endpoint.
-* @param mtu maximum message size
-*/
-void coap_endpoint_set_default_mtu(coap_endpoint_t *endpoint, unsigned mtu);
-
-void coap_free_endpoint(coap_endpoint_t *ep);
-
-
-/**
- * @ingroup logging
-* Get endpoint description.
-*
-* @param endpoint  The CoAP endpoint.
-* @return description string.
-*/
-const char *coap_endpoint_str(const coap_endpoint_t *endpoint);
-
-/**
-* Lookup the server session for the packet received on an endpoint, or create
-* a new one.
-*
-* @param endpoint Active endpoint the packet was received on.
-* @param packet Received packet.
-* @param now The current time in ticks.
-* @return The CoAP session or @c NULL if error.
-*/
-coap_session_t *coap_endpoint_get_session(coap_endpoint_t *endpoint,
-  const struct coap_packet_t *packet, coap_tick_t now);
-
-/**
- * Create a new DTLS session for the @p session.
- * Note: the @p session is released if no DTLS server session can be created.
- *
- * @ingroup dtls_internal
- *
- * @param session   Session to add DTLS session to
- * @param now       The current time in ticks.
- *
- * @return CoAP session or @c NULL if error.
- */
-coap_session_t *coap_session_new_dtls_session(coap_session_t *session,
-  coap_tick_t now);
-
-coap_session_t *coap_session_get_by_peer(struct coap_context_t *ctx,
-  const struct coap_address_t *remote_addr, int ifindex);
-
-void coap_session_free(coap_session_t *session);
-void coap_session_mfree(coap_session_t *session);
-
- /**
-  * @defgroup cc Rate Control
-  * The transmission parameters for CoAP rate control ("Congestion
-  * Control" in stream-oriented protocols) are defined in
-  * https://tools.ietf.org/html/rfc7252#section-4.8
-  * @{
-  */
-
-  /**
-   * Number of seconds when to expect an ACK or a response to an
-   * outstanding CON message.
-   * RFC 7252, Section 4.8 Default value of ACK_TIMEOUT is 2
-   */
-#define COAP_DEFAULT_ACK_TIMEOUT ((coap_fixed_point_t){2,0})
-
-   /**
-    * A factor that is used to randomize the wait time before a message
-    * is retransmitted to prevent synchronization effects.
-    * RFC 7252, Section 4.8 Default value of ACK_RANDOM_FACTOR is 1.5
-    */
-#define COAP_DEFAULT_ACK_RANDOM_FACTOR ((coap_fixed_point_t){1,500})
-
-    /**
-     * Number of message retransmissions before message sending is stopped
-     * RFC 7252, Section 4.8 Default value of MAX_RETRANSMIT is 4
-     */
-#define COAP_DEFAULT_MAX_RETRANSMIT  4
-
-     /**
-      * The number of simultaneous outstanding interactions that a client
-      * maintains to a given server.
-      * RFC 7252, Section 4.8 Default value of NSTART is 1
-      */
-#define COAP_DEFAULT_NSTART 1
-
-      /** @} */
-
-/**
-* Set the CoAP maximum retransmit count before failure
-*
-* Number of message retransmissions before message sending is stopped
-*
-* @param session The CoAP session.
-* @param value The value to set to. The default is 4 and should not normally
-*              get changed.
-*/
-void coap_session_set_max_retransmit(coap_session_t *session,
-                                     unsigned int value);
-
-/**
-* Set the CoAP initial ack response timeout before the next re-transmit
-*
-* Number of seconds when to expect an ACK or a response to an
-* outstanding CON message.
-*
-* @param session The CoAP session.
-* @param value The value to set to. The default is 2 and should not normally
-*              get changed.
-*/
-void coap_session_set_ack_timeout(coap_session_t *session,
-                                  coap_fixed_point_t value);
-
-/**
-* Set the CoAP ack randomize factor
-*
-* A factor that is used to randomize the wait time before a message
-* is retransmitted to prevent synchronization effects.
-*
-* @param session The CoAP session.
-* @param value The value to set to. The default is 1.5 and should not normally
-*              get changed.
-*/
-void coap_session_set_ack_random_factor(coap_session_t *session,
-                                        coap_fixed_point_t value);
-
-/**
-* Get the CoAP maximum retransmit before failure
-*
-* Number of message retransmissions before message sending is stopped
-*
-* @param session The CoAP session.
-*
-* @return Current maximum retransmit value
-*/
-unsigned int coap_session_get_max_transmit(coap_session_t *session);
-
-/**
-* Get the CoAP initial ack response timeout before the next re-transmit
-*
-* Number of seconds when to expect an ACK or a response to an
-* outstanding CON message.
-*
-* @param session The CoAP session.
-*
-* @return Current ack response timeout value
-*/
-coap_fixed_point_t coap_session_get_ack_timeout(coap_session_t *session);
-
-/**
-* Get the CoAP ack randomize factor
-*
-* A factor that is used to randomize the wait time before a message
-* is retransmitted to prevent synchronization effects.
-*
-* @param session The CoAP session.
-*
-* @return Current ack randomize value
-*/
-coap_fixed_point_t coap_session_get_ack_random_factor(coap_session_t *session);
-
-/**
- * Send a ping message for the session.
- * @param session The CoAP session.
- *
- * @return COAP_INVALID_TID if there is an error
- */
-coap_tid_t coap_session_send_ping(coap_session_t *session);
-
-#endif  /* COAP_SESSION_H */
--- a/tools/sdk/esp32/include/coap/libcoap/include/coap2/net.h
+++ b/tools/sdk/esp32/include/coap/libcoap/include/coap2/net.h
@ -1,746 +0,0 @@
-/*
- * net.h -- CoAP network interface
- *
- * Copyright (C) 2010-2015 Olaf Bergmann <bergmann@tzi.org>
- *
- * This file is part of the CoAP library libcoap. Please see README for terms
- * of use.
- */
-
-#ifndef COAP_NET_H_
-#define COAP_NET_H_
-
-#include <assert.h>
-#include <stdlib.h>
-#include <string.h>
-#ifndef _WIN32
-#include <sys/time.h>
-#endif
-#include <time.h>
-
-#ifdef WITH_LWIP
-#include <lwip/ip_addr.h>
-#endif
-
-#include "coap_io.h"
-#include "coap_dtls.h"
-#include "coap_event.h"
-#include "coap_time.h"
-#include "option.h"
-#include "pdu.h"
-#include "prng.h"
-#include "coap_session.h"
-
-struct coap_queue_t;
-
-/**
- * Queue entry
- */
-typedef struct coap_queue_t {
-  struct coap_queue_t *next;
-  coap_tick_t t;                /**< when to send PDU for the next time */
-  unsigned char retransmit_cnt; /**< retransmission counter, will be removed
-                                 *    when zero */
-  unsigned int timeout;         /**< the randomized timeout value */
-  coap_session_t *session;      /**< the CoAP session */
-  coap_tid_t id;                /**< CoAP transaction id */
-  coap_pdu_t *pdu;              /**< the CoAP PDU to send */
-} coap_queue_t;
-
-/**
- * Adds @p node to given @p queue, ordered by variable t in @p node.
- *
- * @param queue Queue to add to.
- * @param node Node entry to add to Queue.
- *
- * @return @c 1 added to queue, @c 0 failure.
- */
-int coap_insert_node(coap_queue_t **queue, coap_queue_t *node);
-
-/**
- * Destroys specified @p node.
- *
- * @param node Node entry to remove.
- *
- * @return @c 1 node deleted from queue, @c 0 failure.
- */
-int coap_delete_node(coap_queue_t *node);
-
-/**
- * Removes all items from given @p queue and frees the allocated storage.
- *
- * @param queue The queue to delete.
- */
-void coap_delete_all(coap_queue_t *queue);
-
-/**
- * Creates a new node suitable for adding to the CoAP sendqueue.
- *
- * @return New node entry, or @c NULL if failure.
- */
-coap_queue_t *coap_new_node(void);
-
-struct coap_resource_t;
-struct coap_context_t;
-#ifndef WITHOUT_ASYNC
-struct coap_async_state_t;
-#endif
-
-/**
- * Response handler that is used as call-back in coap_context_t.
- *
- * @param context CoAP session.
- * @param session CoAP session.
- * @param sent The PDU that was transmitted.
- * @param received The PDU that was received.
- * @param id CoAP transaction ID.
- */
-typedef void (*coap_response_handler_t)(struct coap_context_t *context,
-                                        coap_session_t *session,
-                                        coap_pdu_t *sent,
-                                        coap_pdu_t *received,
-                                        const coap_tid_t id);
-
-/**
- * Negative Acknowedge handler that is used as call-back in coap_context_t.
- *
- * @param context CoAP session.
- * @param session CoAP session.
- * @param sent The PDU that was transmitted.
- * @param reason The reason for the NACK.
- * @param id CoAP transaction ID.
- */
-typedef void (*coap_nack_handler_t)(struct coap_context_t *context,
-                                    coap_session_t *session,
-                                    coap_pdu_t *sent,
-                                    coap_nack_reason_t reason,
-                                    const coap_tid_t id);
-
-/**
- * Recieved Ping handler that is used as call-back in coap_context_t.
- *
- * @param context CoAP session.
- * @param session CoAP session.
- * @param received The PDU that was received.
- * @param id CoAP transaction ID.
- */
-typedef void (*coap_ping_handler_t)(struct coap_context_t *context,
-                                    coap_session_t *session,
-                                    coap_pdu_t *received,
-                                    const coap_tid_t id);
-
-/**
- * Recieved Pong handler that is used as call-back in coap_context_t.
- *
- * @param context CoAP session.
- * @param session CoAP session.
- * @param received The PDU that was received.
- * @param id CoAP transaction ID.
- */
-typedef void (*coap_pong_handler_t)(struct coap_context_t *context,
-                                    coap_session_t *session,
-                                    coap_pdu_t *received,
-                                    const coap_tid_t id);
-
-/**
- * The CoAP stack's global state is stored in a coap_context_t object.
- */
-typedef struct coap_context_t {
-  coap_opt_filter_t known_options;
-  struct coap_resource_t *resources; /**< hash table or list of known
-                                          resources */
-  struct coap_resource_t *unknown_resource; /**< can be used for handling
-                                                 unknown resources */
-
-#ifndef WITHOUT_ASYNC
-  /**
-   * list of asynchronous transactions */
-  struct coap_async_state_t *async_state;
-#endif /* WITHOUT_ASYNC */
-
-  /**
-   * The time stamp in the first element of the sendqeue is relative
-   * to sendqueue_basetime. */
-  coap_tick_t sendqueue_basetime;
-  coap_queue_t *sendqueue;
-  coap_endpoint_t *endpoint;      /**< the endpoints used for listening  */
-  coap_session_t *sessions;       /**< client sessions */
-
-#ifdef WITH_CONTIKI
-  struct uip_udp_conn *conn;      /**< uIP connection object */
-  struct etimer retransmit_timer; /**< fires when the next packet must be sent */
-  struct etimer notify_timer;     /**< used to check resources periodically */
-#endif /* WITH_CONTIKI */
-
-#ifdef WITH_LWIP
-  uint8_t timer_configured;       /**< Set to 1 when a retransmission is
-                                   *   scheduled using lwIP timers for this
-                                   *   context, otherwise 0. */
-#endif /* WITH_LWIP */
-
-  coap_response_handler_t response_handler;
-  coap_nack_handler_t nack_handler;
-  coap_ping_handler_t ping_handler;
-  coap_pong_handler_t pong_handler;
-
-  /**
-   * Callback function that is used to signal events to the
-   * application.  This field is set by coap_set_event_handler().
-   */
-  coap_event_handler_t handle_event;
-
-  ssize_t (*network_send)(coap_socket_t *sock, const coap_session_t *session, const uint8_t *data, size_t datalen);
-
-  ssize_t (*network_read)(coap_socket_t *sock, struct coap_packet_t *packet);
-
-  size_t(*get_client_psk)(const coap_session_t *session, const uint8_t *hint, size_t hint_len, uint8_t *identity, size_t *identity_len, size_t max_identity_len, uint8_t *psk, size_t max_psk_len);
-  size_t(*get_server_psk)(const coap_session_t *session, const uint8_t *identity, size_t identity_len, uint8_t *psk, size_t max_psk_len);
-  size_t(*get_server_hint)(const coap_session_t *session, uint8_t *hint, size_t max_hint_len);
-
-  void *dtls_context;
-  uint8_t *psk_hint;
-  size_t psk_hint_len;
-  uint8_t *psk_key;
-  size_t psk_key_len;
-
-  unsigned int session_timeout;    /**< Number of seconds of inactivity after which an unused session will be closed. 0 means use default. */
-  unsigned int max_idle_sessions;  /**< Maximum number of simultaneous unused sessions per endpoint. 0 means no maximum. */
-  unsigned int max_handshake_sessions; /**< Maximum number of simultaneous negotating sessions per endpoint. 0 means use default. */
-  unsigned int ping_timeout;           /**< Minimum inactivity time before sending a ping message. 0 means disabled. */
-  unsigned int csm_timeout;           /**< Timeout for waiting for a CSM from the remote side. 0 means disabled. */
-
-  void *app;                       /**< application-specific data */
-} coap_context_t;
-
-/**
- * Registers a new message handler that is called whenever a response was
- * received that matches an ongoing transaction.
- *
- * @param context The context to register the handler for.
- * @param handler The response handler to register.
- */
-COAP_STATIC_INLINE void
-coap_register_response_handler(coap_context_t *context,
-                               coap_response_handler_t handler) {
-  context->response_handler = handler;
-}
-
-/**
- * Registers a new message handler that is called whenever a confirmable
- * message (request or response) is dropped after all retries have been
- * exhausted, or a rst message was received, or a network or TLS level
- * event was received that indicates delivering the message is not possible.
- *
- * @param context The context to register the handler for.
- * @param handler The nack handler to register.
- */
-COAP_STATIC_INLINE void
-coap_register_nack_handler(coap_context_t *context,
-                           coap_nack_handler_t handler) {
-  context->nack_handler = handler;
-}
-
-/**
- * Registers a new message handler that is called whenever a CoAP Ping
- * message is received.
- *
- * @param context The context to register the handler for.
- * @param handler The ping handler to register.
- */
-COAP_STATIC_INLINE void
-coap_register_ping_handler(coap_context_t *context,
-                           coap_ping_handler_t handler) {
-  context->ping_handler = handler;
-}
-
-/**
- * Registers a new message handler that is called whenever a CoAP Pong
- * message is received.
- *
- * @param context The context to register the handler for.
- * @param handler The pong handler to register.
- */
-COAP_STATIC_INLINE void
-coap_register_pong_handler(coap_context_t *context,
-                           coap_pong_handler_t handler) {
-  context->pong_handler = handler;
-}
-
-/**
- * Registers the option type @p type with the given context object @p ctx.
- *
- * @param ctx  The context to use.
- * @param type The option type to register.
- */
-COAP_STATIC_INLINE void
-coap_register_option(coap_context_t *ctx, uint16_t type) {
-  coap_option_setb(ctx->known_options, type);
-}
-
-/**
- * Set sendqueue_basetime in the given context object @p ctx to @p now. This
- * function returns the number of elements in the queue head that have timed
- * out.
- */
-unsigned int coap_adjust_basetime(coap_context_t *ctx, coap_tick_t now);
-
-/**
- * Returns the next pdu to send without removing from sendqeue.
- */
-coap_queue_t *coap_peek_next( coap_context_t *context );
-
-/**
- * Returns the next pdu to send and removes it from the sendqeue.
- */
-coap_queue_t *coap_pop_next( coap_context_t *context );
-
-/**
- * Creates a new coap_context_t object that will hold the CoAP stack status.
- */
-coap_context_t *coap_new_context(const coap_address_t *listen_addr);
-
-/**
- * Set the context's default PSK hint and/or key for a server.
- *
- * @param context The current coap_context_t object.
- * @param hint    The default PSK server hint sent to a client. If @p NULL, PSK
- *                authentication is disabled. Empty string is a valid hint.
- * @param key     The default PSK key. If @p NULL, PSK authentication will fail.
- * @param key_len The default PSK key's length. If @p 0, PSK authentication will
- *                fail.
- *
- * @return @c 1 if successful, else @c 0.
- */
-int coap_context_set_psk( coap_context_t *context, const char *hint,
-                           const uint8_t *key, size_t key_len );
-
-/**
- * Set the context's default PKI information for a server.
- *
- * @param context        The current coap_context_t object.
- * @param setup_data     If @p NULL, PKI authentication will fail. Certificate
- *                       information required.
- *
- * @return @c 1 if successful, else @c 0.
- */
-int
-coap_context_set_pki(coap_context_t *context,
-                     coap_dtls_pki_t *setup_data);
-
-/**
- * Set the context's default Root CA information for a client or server.
- *
- * @param context        The current coap_context_t object.
- * @param ca_file        If not @p NULL, is the full path name of a PEM encoded
- *                       file containing all the Root CAs to be used.
- * @param ca_dir         If not @p NULL, points to a directory containing PEM
- *                       encoded files containing all the Root CAs to be used.
- *
- * @return @c 1 if successful, else @c 0.
- */
-int
-coap_context_set_pki_root_cas(coap_context_t *context,
-                              const char *ca_file,
-                              const char *ca_dir);
-
-/**
- * Set the context keepalive timer for sessions.
- * A keepalive message will be sent after if a session has been inactive,
- * i.e. no packet sent or received, for the given number of seconds.
- * For reliable protocols, a PING message will be sent. If a PONG has not
- * been received before the next PING is due to be sent, the session will
- * considered as disconnected.
- *
- * @param context        The coap_context_t object.
- * @param seconds                 Number of seconds for the inactivity timer, or zero
- *                       to disable CoAP-level keepalive messages.
- *
- * @return 1 if successful, else 0
- */
-void coap_context_set_keepalive(coap_context_t *context, unsigned int seconds);
-
-/**
- * Returns a new message id and updates @p session->tx_mid accordingly. The
- * message id is returned in network byte order to make it easier to read in
- * tracing tools.
- *
- * @param session The current coap_session_t object.
- *
- * @return        Incremented message id in network byte order.
- */
-COAP_STATIC_INLINE uint16_t
-coap_new_message_id(coap_session_t *session) {
-  return ++session->tx_mid;
-}
-
-/**
- * CoAP stack context must be released with coap_free_context(). This function
- * clears all entries from the receive queue and send queue and deletes the
- * resources that have been registered with @p context, and frees the attached
- * endpoints.
- *
- * @param context The current coap_context_t object to free off.
- */
-void coap_free_context(coap_context_t *context);
-
-/**
- * Stores @p data with the given CoAP context. This function
- * overwrites any value that has previously been stored with @p
- * context.
- *
- * @param context The CoAP context.
- * @param data The data to store with wih the context. Note that this data
- *             must be valid during the lifetime of @p context.
- */
-void coap_set_app_data(coap_context_t *context, void *data);
-
-/**
- * Returns any application-specific data that has been stored with @p
- * context using the function coap_set_app_data(). This function will
- * return @c NULL if no data has been stored.
- *
- * @param context The CoAP context.
- *
- * @return The data previously stored or @c NULL if not data stored.
- */
-void *coap_get_app_data(const coap_context_t *context);
-
-/**
- * Creates a new ACK PDU with specified error @p code. The options specified by
- * the filter expression @p opts will be copied from the original request
- * contained in @p request. Unless @c SHORT_ERROR_RESPONSE was defined at build
- * time, the textual reason phrase for @p code will be added as payload, with
- * Content-Type @c 0.
- * This function returns a pointer to the new response message, or @c NULL on
- * error. The storage allocated for the new message must be relased with
- * coap_free().
- *
- * @param request Specification of the received (confirmable) request.
- * @param code    The error code to set.
- * @param opts    An option filter that specifies which options to copy from
- *                the original request in @p node.
- *
- * @return        A pointer to the new message or @c NULL on error.
- */
-coap_pdu_t *coap_new_error_response(coap_pdu_t *request,
-                                    unsigned char code,
-                                    coap_opt_filter_t opts);
-
-/**
- * Sends an error response with code @p code for request @p request to @p dst.
- * @p opts will be passed to coap_new_error_response() to copy marked options
- * from the request. This function returns the transaction id if the message was
- * sent, or @c COAP_INVALID_TID otherwise.
- *
- * @param session         The CoAP session.
- * @param request         The original request to respond to.
- * @param code            The response code.
- * @param opts            A filter that specifies the options to copy from the
- *                        @p request.
- *
- * @return                The transaction id if the message was sent, or @c
- *                        COAP_INVALID_TID otherwise.
- */
-coap_tid_t coap_send_error(coap_session_t *session,
-                           coap_pdu_t *request,
-                           unsigned char code,
-                           coap_opt_filter_t opts);
-
-/**
- * Helper funktion to create and send a message with @p type (usually ACK or
- * RST). This function returns @c COAP_INVALID_TID when the message was not
- * sent, a valid transaction id otherwise.
- *
- * @param session         The CoAP session.
- * @param request         The request that should be responded to.
- * @param type            Which type to set.
- * @return                transaction id on success or @c COAP_INVALID_TID
- *                        otherwise.
- */
-coap_tid_t
-coap_send_message_type(coap_session_t *session, coap_pdu_t *request, unsigned char type);
-
-/**
- * Sends an ACK message with code @c 0 for the specified @p request to @p dst.
- * This function returns the corresponding transaction id if the message was
- * sent or @c COAP_INVALID_TID on error.
- *
- * @param session         The CoAP session.
- * @param request         The request to be acknowledged.
- *
- * @return                The transaction id if ACK was sent or @c
- *                        COAP_INVALID_TID on error.
- */
-coap_tid_t coap_send_ack(coap_session_t *session, coap_pdu_t *request);
-
-/**
- * Sends an RST message with code @c 0 for the specified @p request to @p dst.
- * This function returns the corresponding transaction id if the message was
- * sent or @c COAP_INVALID_TID on error.
- *
- * @param session         The CoAP session.
- * @param request         The request to be reset.
- *
- * @return                The transaction id if RST was sent or @c
- *                        COAP_INVALID_TID on error.
- */
-COAP_STATIC_INLINE coap_tid_t
-coap_send_rst(coap_session_t *session, coap_pdu_t *request) {
-  return coap_send_message_type(session, request, COAP_MESSAGE_RST);
-}
-
-/**
-* Sends a CoAP message to given peer. The memory that is
-* allocated by pdu will be released by coap_send().
-* The caller must not use the pdu after calling coap_send().
-*
-* @param session         The CoAP session.
-* @param pdu             The CoAP PDU to send.
-*
-* @return                The message id of the sent message or @c
-*                        COAP_INVALID_TID on error.
-*/
-coap_tid_t coap_send( coap_session_t *session, coap_pdu_t *pdu );
-
-/**
- * Handles retransmissions of confirmable messages
- *
- * @param context      The CoAP context.
- * @param node         The node to retransmit.
- *
- * @return             The message id of the sent message or @c
- *                     COAP_INVALID_TID on error.
- */
-coap_tid_t coap_retransmit(coap_context_t *context, coap_queue_t *node);
-
-/**
-* For applications with their own message loop, send all pending retransmits and
-* return the list of sockets with events to wait for and the next timeout
-* The application should call coap_read, then coap_write again when any condition below is true:
-* - data is available on any of the sockets with the COAP_SOCKET_WANT_READ
-* - an incoming connection is pending in the listen queue and the COAP_SOCKET_WANT_ACCEPT flag is set
-* - at least some data can be written without blocking on any of the sockets with the COAP_SOCKET_WANT_WRITE flag set
-* - a connection event occured (success or failure) and the COAP_SOCKET_WANT_CONNECT flag is set
-* - the timeout has expired
-* Before calling coap_read or coap_write again, the application should position COAP_SOCKET_CAN_READ and COAP_SOCKET_CAN_WRITE flags as applicable.
-*
-* @param ctx The CoAP context
-* @param sockets array of socket descriptors, filled on output
-* @param max_sockets size of socket array.
-* @param num_sockets pointer to the number of valid entries in the socket arrays on output
-* @param now Current time.
-*
-* @return timeout as maxmimum number of milliseconds that the application should wait for network events or 0 if the application should wait forever.
-*/
-
-unsigned int
-coap_write(coap_context_t *ctx,
-  coap_socket_t *sockets[],
-  unsigned int max_sockets,
-  unsigned int *num_sockets,
-  coap_tick_t now
-);
-
-/**
- * For applications with their own message loop, reads all data from the network.
- *
- * @param ctx The CoAP context
- * @param now Current time
- */
-void coap_read(coap_context_t *ctx, coap_tick_t now);
-
-/**
- * The main message processing loop.
- *
- * @param ctx The CoAP context
- * @param timeout_ms Minimum number of milliseconds to wait for new messages before returning. If zero the call will block until at least one packet is sent or received.
- *
- * @return number of milliseconds spent or @c -1 if there was an error
- */
-
-int coap_run_once( coap_context_t *ctx, unsigned int timeout_ms );
-
-/**
- * Parses and interprets a CoAP datagram with context @p ctx. This function
- * returns @c 0 if the datagram was handled, or a value less than zero on
- * error.
- *
- * @param ctx    The current CoAP context.
- * @param session The current CoAP session.
- * @param data The received packet'd data.
- * @param data_len The received packet'd data length.
- *
- * @return       @c 0 if message was handled successfully, or less than zero on
- *               error.
- */
-int coap_handle_dgram(coap_context_t *ctx, coap_session_t *session, uint8_t *data, size_t data_len);
-
-/**
- * Invokes the event handler of @p context for the given @p event and
- * @p data.
- *
- * @param context The CoAP context whose event handler is to be called.
- * @param event   The event to deliver.
- * @param session The session related to @p event.
- * @return The result from the associated event handler or 0 if none was
- * registered.
- */
-int coap_handle_event(coap_context_t *context,
-                      coap_event_t event,
-                      coap_session_t *session);
-/**
- * This function removes the element with given @p id from the list given list.
- * If @p id was found, @p node is updated to point to the removed element. Note
- * that the storage allocated by @p node is @b not released. The caller must do
- * this manually using coap_delete_node(). This function returns @c 1 if the
- * element with id @p id was found, @c 0 otherwise. For a return value of @c 0,
- * the contents of @p node is undefined.
- *
- * @param queue The queue to search for @p id.
- * @param session The session to look for.
- * @param id    The transaction id to look for.
- * @param node  If found, @p node is updated to point to the removed node. You
- *              must release the storage pointed to by @p node manually.
- *
- * @return      @c 1 if @p id was found, @c 0 otherwise.
- */
-int coap_remove_from_queue(coap_queue_t **queue,
-                           coap_session_t *session,
-                           coap_tid_t id,
-                           coap_queue_t **node);
-
-coap_tid_t
-coap_wait_ack( coap_context_t *context, coap_session_t *session,
-               coap_queue_t *node);
-
-/**
- * Retrieves transaction from the queue.
- *
- * @param queue The transaction queue to be searched.
- * @param session The session to find.
- * @param id    The transaction id to find.
- *
- * @return      A pointer to the transaction object or @c NULL if not found.
- */
-coap_queue_t *coap_find_transaction(coap_queue_t *queue, coap_session_t *session, coap_tid_t id);
-
-/**
- * Cancels all outstanding messages for session @p session that have the specified
- * token.
- *
- * @param context      The context in use.
- * @param session      Session of the messages to remove.
- * @param token        Message token.
- * @param token_length Actual length of @p token.
- */
-void coap_cancel_all_messages(coap_context_t *context,
-                              coap_session_t *session,
-                              const uint8_t *token,
-                              size_t token_length);
-
-/**
-* Cancels all outstanding messages for session @p session.
-*
-* @param context      The context in use.
-* @param session      Session of the messages to remove.
-* @param reason       The reasion for the session cancellation
-*/
-void
-coap_cancel_session_messages(coap_context_t *context,
-                             coap_session_t *session,
-                             coap_nack_reason_t reason);
-
-/**
- * Dispatches the PDUs from the receive queue in given context.
- */
-void coap_dispatch(coap_context_t *context, coap_session_t *session,
-                   coap_pdu_t *pdu);
-
-/**
- * Returns 1 if there are no messages to send or to dispatch in the context's
- * queues. */
-int coap_can_exit(coap_context_t *context);
-
-/**
- * Returns the current value of an internal tick counter. The counter counts \c
- * COAP_TICKS_PER_SECOND ticks every second.
- */
-void coap_ticks(coap_tick_t *);
-
-/**
- * Verifies that @p pdu contains no unknown critical options. Options must be
- * registered at @p ctx, using the function coap_register_option(). A basic set
- * of options is registered automatically by coap_new_context(). This function
- * returns @c 1 if @p pdu is ok, @c 0 otherwise. The given filter object @p
- * unknown will be updated with the unknown options. As only @c COAP_MAX_OPT
- * options can be signalled this way, remaining options must be examined
- * manually.
- *
- * @code
-  coap_opt_filter_t f = COAP_OPT_NONE;
-  coap_opt_iterator_t opt_iter;
-
-  if (coap_option_check_critical(ctx, pdu, f) == 0) {
-    coap_option_iterator_init(pdu, &opt_iter, f);
-
-    while (coap_option_next(&opt_iter)) {
-      if (opt_iter.type & 0x01) {
-        ... handle unknown critical option in opt_iter ...
-      }
-    }
-  }
-   @endcode
- *
- * @param ctx      The context where all known options are registered.
- * @param pdu      The PDU to check.
- * @param unknown  The output filter that will be updated to indicate the
- *                 unknown critical options found in @p pdu.
- *
- * @return         @c 1 if everything was ok, @c 0 otherwise.
- */
-int coap_option_check_critical(coap_context_t *ctx,
-                               coap_pdu_t *pdu,
-                               coap_opt_filter_t unknown);
-
-/**
- * Creates a new response for given @p request with the contents of @c
- * .well-known/core. The result is NULL on error or a newly allocated PDU that
- * must be either sent with coap_sent() or released by coap_delete_pdu().
- *
- * @param context The current coap context to use.
- * @param session The CoAP session.
- * @param request The request for @c .well-known/core .
- *
- * @return        A new 2.05 response for @c .well-known/core or NULL on error.
- */
-coap_pdu_t *coap_wellknown_response(coap_context_t *context,
-                                    coap_session_t *session,
-                                    coap_pdu_t *request);
-
-/**
- * Calculates the initial timeout based on the session CoAP transmission
- * parameters 'ack_timeout', 'ack_random_factor', and COAP_TICKS_PER_SECOND.
- * The calculation requires 'ack_timeout' and 'ack_random_factor' to be in
- * Qx.FRAC_BITS fixed point notation, whereas the passed parameter @p r
- * is interpreted as the fractional part of a Q0.MAX_BITS random value.
- *
- * @param session session timeout is associated with
- * @param r  random value as fractional part of a Q0.MAX_BITS fixed point
- *           value
- * @return   COAP_TICKS_PER_SECOND * 'ack_timeout' *
- *           (1 + ('ack_random_factor' - 1) * r)
- */
-unsigned int coap_calc_timeout(coap_session_t *session, unsigned char r);
-
-/**
- * Function interface for joining a multicast group for listening
- *
- * @param ctx   The current context
- * @param groupname The name of the group that is to be joined for listening
- *
- * @return       0 on success, -1 on error
- */
-int
-coap_join_mcast_group(coap_context_t *ctx, const char *groupname);
-
-#endif /* COAP_NET_H_ */
--- a/tools/sdk/esp32/include/coap/libcoap/include/coap2/pdu.h
+++ b/tools/sdk/esp32/include/coap/libcoap/include/coap2/pdu.h
@ -1,543 +0,0 @@
-/*
- * pdu.h -- CoAP message structure
- *
- * Copyright (C) 2010-2014 Olaf Bergmann <bergmann@tzi.org>
- *
- * This file is part of the CoAP library libcoap. Please see README for terms
- * of use.
- */
-
-/**
- * @file pdu.h
- * @brief Pre-defined constants that reflect defaults for CoAP
- */
-
-#ifndef COAP_PDU_H_
-#define COAP_PDU_H_
-
-#include "uri.h"
-
-struct coap_session_t;
-
-#ifdef WITH_LWIP
-#include <lwip/pbuf.h>
-#endif
-
-#include <stdint.h>
-
-#define COAP_DEFAULT_PORT      5683 /* CoAP default UDP/TCP port */
-#define COAPS_DEFAULT_PORT     5684 /* CoAP default UDP/TCP port for secure transmission */
-#define COAP_DEFAULT_MAX_AGE     60 /* default maximum object lifetime in seconds */
-#ifndef COAP_DEFAULT_MTU
-#define COAP_DEFAULT_MTU       1152
-#endif /* COAP_DEFAULT_MTU */
-
-/* TCP Message format constants, do not modify */
-#define COAP_MESSAGE_SIZE_OFFSET_TCP8 13
-#define COAP_MESSAGE_SIZE_OFFSET_TCP16 269 /* 13 + 256 */
-#define COAP_MESSAGE_SIZE_OFFSET_TCP32 65805 /* 269 + 65536 */
-
-/* Derived message size limits */
-#define COAP_MAX_MESSAGE_SIZE_TCP0 (COAP_MESSAGE_SIZE_OFFSET_TCP8-1) /* 12 */
-#define COAP_MAX_MESSAGE_SIZE_TCP8 (COAP_MESSAGE_SIZE_OFFSET_TCP16-1) /* 268 */
-#define COAP_MAX_MESSAGE_SIZE_TCP16 (COAP_MESSAGE_SIZE_OFFSET_TCP32-1) /* 65804 */
-#define COAP_MAX_MESSAGE_SIZE_TCP32 (COAP_MESSAGE_SIZE_OFFSET_TCP32+0xFFFFFFFF)
-
-#ifndef COAP_DEFAULT_MAX_PDU_RX_SIZE
-#if defined(WITH_CONTIKI) || defined(WITH_LWIP)
-#define COAP_DEFAULT_MAX_PDU_RX_SIZE (COAP_MAX_MESSAGE_SIZE_TCP16+4)
-#else
-/* 8 MiB max-message-size plus some space for options */
-#define COAP_DEFAULT_MAX_PDU_RX_SIZE (8*1024*1024+256)
-#endif
-#endif /* COAP_DEFAULT_MAX_PDU_RX_SIZE */
-
-#ifndef COAP_DEBUG_BUF_SIZE
-#if defined(WITH_CONTIKI) || defined(WITH_LWIP)
-#define COAP_DEBUG_BUF_SIZE 128
-#else /* defined(WITH_CONTIKI) || defined(WITH_LWIP) */
-/* 1024 derived from RFC7252 4.6.  Message Size max payload */
-#define COAP_DEBUG_BUF_SIZE (8 + 1024 * 2)
-#endif /* defined(WITH_CONTIKI) || defined(WITH_LWIP) */
-#endif /* COAP_DEBUG_BUF_SIZE */
-
-#define COAP_DEFAULT_VERSION      1 /* version of CoAP supported */
-#define COAP_DEFAULT_SCHEME  "coap" /* the default scheme for CoAP URIs */
-
-/** well-known resources URI */
-#define COAP_DEFAULT_URI_WELLKNOWN ".well-known/core"
-
-/* CoAP message types */
-
-#define COAP_MESSAGE_CON       0 /* confirmable message (requires ACK/RST) */
-#define COAP_MESSAGE_NON       1 /* non-confirmable message (one-shot message) */
-#define COAP_MESSAGE_ACK       2 /* used to acknowledge confirmable messages */
-#define COAP_MESSAGE_RST       3 /* indicates error in received messages */
-
-/* CoAP request methods */
-
-#define COAP_REQUEST_GET       1
-#define COAP_REQUEST_POST      2
-#define COAP_REQUEST_PUT       3
-#define COAP_REQUEST_DELETE    4
-#define COAP_REQUEST_FETCH     5 /* RFC 8132 */
-#define COAP_REQUEST_PATCH     6 /* RFC 8132 */
-#define COAP_REQUEST_IPATCH    7 /* RFC 8132 */
-
-/*
- * CoAP option types (be sure to update coap_option_check_critical() when
- * adding options
- */
-
-#define COAP_OPTION_IF_MATCH        1 /* C, opaque, 0-8 B, (none) */
-#define COAP_OPTION_URI_HOST        3 /* C, String, 1-255 B, destination address */
-#define COAP_OPTION_ETAG            4 /* E, opaque, 1-8 B, (none) */
-#define COAP_OPTION_IF_NONE_MATCH   5 /* empty, 0 B, (none) */
-#define COAP_OPTION_URI_PORT        7 /* C, uint, 0-2 B, destination port */
-#define COAP_OPTION_LOCATION_PATH   8 /* E, String, 0-255 B, - */
-#define COAP_OPTION_URI_PATH       11 /* C, String, 0-255 B, (none) */
-#define COAP_OPTION_CONTENT_FORMAT 12 /* E, uint, 0-2 B, (none) */
-#define COAP_OPTION_CONTENT_TYPE COAP_OPTION_CONTENT_FORMAT
-#define COAP_OPTION_MAXAGE         14 /* E, uint, 0--4 B, 60 Seconds */
-#define COAP_OPTION_URI_QUERY      15 /* C, String, 1-255 B, (none) */
-#define COAP_OPTION_ACCEPT         17 /* C, uint,   0-2 B, (none) */
-#define COAP_OPTION_LOCATION_QUERY 20 /* E, String,   0-255 B, (none) */
-#define COAP_OPTION_SIZE2          28 /* E, uint, 0-4 B, (none) */
-#define COAP_OPTION_PROXY_URI      35 /* C, String, 1-1034 B, (none) */
-#define COAP_OPTION_PROXY_SCHEME   39 /* C, String, 1-255 B, (none) */
-#define COAP_OPTION_SIZE1          60 /* E, uint, 0-4 B, (none) */
-
-/* option types from RFC 7641 */
-
-#define COAP_OPTION_OBSERVE         6 /* E, empty/uint, 0 B/0-3 B, (none) */
-#define COAP_OPTION_SUBSCRIPTION  COAP_OPTION_OBSERVE
-
-/* selected option types from RFC 7959 */
-
-#define COAP_OPTION_BLOCK2         23 /* C, uint, 0--3 B, (none) */
-#define COAP_OPTION_BLOCK1         27 /* C, uint, 0--3 B, (none) */
-
-/* selected option types from RFC 7967 */
-
-#define COAP_OPTION_NORESPONSE    258 /* N, uint, 0--1 B, 0 */
-
-#define COAP_MAX_OPT            65535 /**< the highest option number we know */
-
-/* CoAP result codes (HTTP-Code / 100 * 40 + HTTP-Code % 100) */
-
-/* As of draft-ietf-core-coap-04, response codes are encoded to base
- * 32, i.e.  the three upper bits determine the response class while
- * the remaining five fine-grained information specific to that class.
- */
-#define COAP_RESPONSE_CODE(N) (((N)/100 << 5) | (N)%100)
-
-/* Determines the class of response code C */
-#define COAP_RESPONSE_CLASS(C) (((C) >> 5) & 0xFF)
-
-#ifndef SHORT_ERROR_RESPONSE
-/**
- * Returns a human-readable response phrase for the specified CoAP response @p
- * code. This function returns @c NULL if not found.
- *
- * @param code The response code for which the literal phrase should be
- *             retrieved.
- *
- * @return     A zero-terminated string describing the error, or @c NULL if not
- *             found.
- */
-const char *coap_response_phrase(unsigned char code);
-
-#define COAP_ERROR_PHRASE_LENGTH   32 /**< maximum length of error phrase */
-
-#else
-#define coap_response_phrase(x) ((char *)NULL)
-
-#define COAP_ERROR_PHRASE_LENGTH    0 /**< maximum length of error phrase */
-#endif /* SHORT_ERROR_RESPONSE */
-
-/* The following definitions exist for backwards compatibility */
-#if 0 /* this does not exist any more */
-#define COAP_RESPONSE_100      40 /* 100 Continue */
-#endif
-#define COAP_RESPONSE_200      COAP_RESPONSE_CODE(200)  /* 2.00 OK */
-#define COAP_RESPONSE_201      COAP_RESPONSE_CODE(201)  /* 2.01 Created */
-#define COAP_RESPONSE_304      COAP_RESPONSE_CODE(203)  /* 2.03 Valid */
-#define COAP_RESPONSE_400      COAP_RESPONSE_CODE(400)  /* 4.00 Bad Request */
-#define COAP_RESPONSE_404      COAP_RESPONSE_CODE(404)  /* 4.04 Not Found */
-#define COAP_RESPONSE_405      COAP_RESPONSE_CODE(405)  /* 4.05 Method Not Allowed */
-#define COAP_RESPONSE_415      COAP_RESPONSE_CODE(415)  /* 4.15 Unsupported Media Type */
-#define COAP_RESPONSE_500      COAP_RESPONSE_CODE(500)  /* 5.00 Internal Server Error */
-#define COAP_RESPONSE_501      COAP_RESPONSE_CODE(501)  /* 5.01 Not Implemented */
-#define COAP_RESPONSE_503      COAP_RESPONSE_CODE(503)  /* 5.03 Service Unavailable */
-#define COAP_RESPONSE_504      COAP_RESPONSE_CODE(504)  /* 5.04 Gateway Timeout */
-#if 0  /* these response codes do not have a valid code any more */
-#  define COAP_RESPONSE_X_240    240   /* Token Option required by server */
-#  define COAP_RESPONSE_X_241    241   /* Uri-Authority Option required by server */
-#endif
-#define COAP_RESPONSE_X_242    COAP_RESPONSE_CODE(402)  /* Critical Option not supported */
-
-#define COAP_SIGNALING_CODE(N) (((N)/100 << 5) | (N)%100)
-#define COAP_SIGNALING_CSM     COAP_SIGNALING_CODE(701)
-#define COAP_SIGNALING_PING    COAP_SIGNALING_CODE(702)
-#define COAP_SIGNALING_PONG    COAP_SIGNALING_CODE(703)
-#define COAP_SIGNALING_RELEASE COAP_SIGNALING_CODE(704)
-#define COAP_SIGNALING_ABORT   COAP_SIGNALING_CODE(705)
-
-/* Applies to COAP_SIGNALING_CSM */
-#define COAP_SIGNALING_OPTION_MAX_MESSAGE_SIZE 2
-#define COAP_SIGNALING_OPTION_BLOCK_WISE_TRANSFER 4
-/* Applies to COAP_SIGNALING_PING / COAP_SIGNALING_PONG */
-#define COAP_SIGNALING_OPTION_CUSTODY 2
-/* Applies to COAP_SIGNALING_RELEASE */
-#define COAP_SIGNALING_OPTION_ALTERNATIVE_ADDRESS 2
-#define COAP_SIGNALING_OPTION_HOLD_OFF 4
-/* Applies to COAP_SIGNALING_ABORT */
-#define COAP_SIGNALING_OPTION_BAD_CSM_OPTION 2
-
-/* CoAP media type encoding */
-
-#define COAP_MEDIATYPE_TEXT_PLAIN                 0 /* text/plain (UTF-8) */
-#define COAP_MEDIATYPE_APPLICATION_LINK_FORMAT   40 /* application/link-format */
-#define COAP_MEDIATYPE_APPLICATION_XML           41 /* application/xml */
-#define COAP_MEDIATYPE_APPLICATION_OCTET_STREAM  42 /* application/octet-stream */
-#define COAP_MEDIATYPE_APPLICATION_RDF_XML       43 /* application/rdf+xml */
-#define COAP_MEDIATYPE_APPLICATION_EXI           47 /* application/exi  */
-#define COAP_MEDIATYPE_APPLICATION_JSON          50 /* application/json  */
-#define COAP_MEDIATYPE_APPLICATION_CBOR          60 /* application/cbor  */
-
-/* Content formats from RFC 8152 */
-#define COAP_MEDIATYPE_APPLICATION_COSE_SIGN     98 /* application/cose; cose-type="cose-sign"     */
-#define COAP_MEDIATYPE_APPLICATION_COSE_SIGN1    18 /* application/cose; cose-type="cose-sign1"    */
-#define COAP_MEDIATYPE_APPLICATION_COSE_ENCRYPT  96 /* application/cose; cose-type="cose-encrypt"  */
-#define COAP_MEDIATYPE_APPLICATION_COSE_ENCRYPT0 16 /* application/cose; cose-type="cose-encrypt0" */
-#define COAP_MEDIATYPE_APPLICATION_COSE_MAC      97 /* application/cose; cose-type="cose-mac"      */
-#define COAP_MEDIATYPE_APPLICATION_COSE_MAC0     17 /* application/cose; cose-type="cose-mac0"     */
-
-#define COAP_MEDIATYPE_APPLICATION_COSE_KEY     101 /* application/cose-key  */
-#define COAP_MEDIATYPE_APPLICATION_COSE_KEY_SET 102 /* application/cose-key-set  */
-
-/* Content formats from RFC 8428 */
-#define COAP_MEDIATYPE_APPLICATION_SENML_JSON   110 /* application/senml+json  */
-#define COAP_MEDIATYPE_APPLICATION_SENSML_JSON  111 /* application/sensml+json */
-#define COAP_MEDIATYPE_APPLICATION_SENML_CBOR   112 /* application/senml+cbor  */
-#define COAP_MEDIATYPE_APPLICATION_SENSML_CBOR  113 /* application/sensml+cbor */
-#define COAP_MEDIATYPE_APPLICATION_SENML_EXI    114 /* application/senml-exi   */
-#define COAP_MEDIATYPE_APPLICATION_SENSML_EXI   115 /* application/sensml-exi  */
-#define COAP_MEDIATYPE_APPLICATION_SENML_XML    310 /* application/senml+xml   */
-#define COAP_MEDIATYPE_APPLICATION_SENSML_XML   311 /* application/sensml+xml  */
-
-/* Note that identifiers for registered media types are in the range 0-65535. We
- * use an unallocated type here and hope for the best. */
-#define COAP_MEDIATYPE_ANY                         0xff /* any media type */
-
-/**
- * coap_tid_t is used to store CoAP transaction id, i.e. a hash value
- * built from the remote transport address and the message id of a
- * CoAP PDU.  Valid transaction ids are greater or equal zero.
- */
-typedef int coap_tid_t;
-
-/** Indicates an invalid transaction id. */
-#define COAP_INVALID_TID -1
-
-/**
- * Indicates that a response is suppressed. This will occur for error
- * responses if the request was received via IP multicast.
- */
-#define COAP_DROPPED_RESPONSE -2
-
-#define COAP_PDU_DELAYED -3
-
-#define COAP_OPT_LONG 0x0F      /* OC == 0b1111 indicates that the option list
-                                 * in a CoAP message is limited by 0b11110000
-                                 * marker */
-
-#define COAP_OPT_END 0xF0       /* end marker */
-
-#define COAP_PAYLOAD_START 0xFF /* payload marker */
-
-/**
- * @deprecated Use coap_optlist_t instead.
- *
- * Structures for more convenient handling of options. (To be used with ordered
- * coap_list_t.) The option's data will be added to the end of the coap_option
- * structure (see macro COAP_OPTION_DATA).
- */
-COAP_DEPRECATED typedef struct {
-  uint16_t key;           /* the option key (no delta coding) */
-  unsigned int length;
-} coap_option;
-
-#define COAP_OPTION_KEY(option) (option).key
-#define COAP_OPTION_LENGTH(option) (option).length
-#define COAP_OPTION_DATA(option) ((unsigned char *)&(option) + sizeof(coap_option))
-
-/**
- * structure for CoAP PDUs
- * token, if any, follows the fixed size header, then options until
- * payload marker (0xff), then the payload if stored inline.
- * Memory layout is:
- * <---header--->|<---token---><---options--->0xff<---payload--->
- * header is addressed with a negative offset to token, its maximum size is
- * max_hdr_size.
- * options starts at token + token_length
- * payload starts at data, its length is used_size - (data - token)
- */
-
-typedef struct coap_pdu_t {
-  uint8_t type;             /**< message type */
-  uint8_t code;             /**< request method (value 1--10) or response code (value 40-255) */
-  uint8_t max_hdr_size;     /**< space reserved for protocol-specific header */
-  uint8_t hdr_size;         /**< actaul size used for protocol-specific header */
-  uint8_t token_length;     /**< length of Token */
-  uint16_t tid;             /**< transaction id, if any, in regular host byte order */
-  uint16_t max_delta;       /**< highest option number */
-  size_t alloc_size;        /**< allocated storage for token, options and payload */
-  size_t used_size;         /**< used bytes of storage for token, options and payload */
-  size_t max_size;          /**< maximum size for token, options and payload, or zero for variable size pdu */
-  uint8_t *token;           /**< first byte of token, if any, or options */
-  uint8_t *data;            /**< first byte of payload, if any */
-#ifdef WITH_LWIP
-  struct pbuf *pbuf;        /**< lwIP PBUF. The package data will always reside
-                             *   inside the pbuf's payload, but this pointer
-                             *   has to be kept because no exact offset can be
-                             *   given. This field must not be accessed from
-                             *   outside, because the pbuf's reference count
-                             *   is checked to be 1 when the pbuf is assigned
-                             *   to the pdu, and the pbuf stays exclusive to
-                             *   this pdu. */
-#endif
-} coap_pdu_t;
-
-#define COAP_PDU_IS_EMPTY(pdu)     ((pdu)->code == 0)
-#define COAP_PDU_IS_REQUEST(pdu)   (!COAP_PDU_IS_EMPTY(pdu) && (pdu)->code < 32)
-#define COAP_PDU_IS_RESPONSE(pdu)  ((pdu)->code >= 64 && (pdu)->code < 224)
-#define COAP_PDU_IS_SIGNALING(pdu) ((pdu)->code >= 224)
-
-#define COAP_PDU_MAX_UDP_HEADER_SIZE 4
-#define COAP_PDU_MAX_TCP_HEADER_SIZE 6
-
-#ifdef WITH_LWIP
-/**
- * Creates a CoAP PDU from an lwIP @p pbuf, whose reference is passed on to this
- * function.
- *
- * The pbuf is checked for being contiguous, and for having only one reference.
- * The reference is stored in the PDU and will be freed when the PDU is freed.
- *
- * (For now, these are fatal errors; in future, a new pbuf might be allocated,
- * the data copied and the passed pbuf freed).
- *
- * This behaves like coap_pdu_init(0, 0, 0, pbuf->tot_len), and afterwards
- * copying the contents of the pbuf to the pdu.
- *
- * @return A pointer to the new PDU object or @c NULL on error.
- */
-coap_pdu_t * coap_pdu_from_pbuf(struct pbuf *pbuf);
-#endif
-
-typedef uint8_t coap_proto_t;
-/**
-* coap_proto_t values
-*/
-#define COAP_PROTO_NONE         0
-#define COAP_PROTO_UDP          1
-#define COAP_PROTO_DTLS         2
-#define COAP_PROTO_TCP          3
-#define COAP_PROTO_TLS          4
-
-/**
- * Creates a new CoAP PDU with at least enough storage space for the given
- * @p size maximum message size. The function returns a pointer to the
- * node coap_pdu_t object on success, or @c NULL on error. The storage allocated
- * for the result must be released with coap_delete_pdu() if coap_send() is not
- * called.
- *
- * @param type The type of the PDU (one of COAP_MESSAGE_CON, COAP_MESSAGE_NON,
- *             COAP_MESSAGE_ACK, COAP_MESSAGE_RST).
- * @param code The message code.
- * @param tid  The transcation id to set or 0 if unknown / not applicable.
- * @param size The maximum allowed number of byte for the message.
- * @return     A pointer to the new PDU object or @c NULL on error.
- */
-coap_pdu_t *
-coap_pdu_init(uint8_t type, uint8_t code, uint16_t tid, size_t size);
-
-/**
- * Dynamically grows the size of @p pdu to @p new_size. The new size
- * must not exceed the PDU's configure maximum size. On success, this
- * function returns 1, otherwise 0.
- *
- * @param pdu      The PDU to resize.
- * @param new_size The new size in bytes.
- * @return         1 if the operation succeeded, 0 otherwise.
- */
-int coap_pdu_resize(coap_pdu_t *pdu, size_t new_size);
-
-/**
- * Clears any contents from @p pdu and resets @c used_size,
- * and @c data pointers. @c max_size is set to @p size, any
- * other field is set to @c 0. Note that @p pdu must be a valid
- * pointer to a coap_pdu_t object created e.g. by coap_pdu_init().
- */
-void coap_pdu_clear(coap_pdu_t *pdu, size_t size);
-
-/**
- * Creates a new CoAP PDU.
- */
-coap_pdu_t *coap_new_pdu(const struct coap_session_t *session);
-
-/**
- * Dispose of an CoAP PDU and frees associated storage.
- * Not that in general you should not call this function directly.
- * When a PDU is sent with coap_send(), coap_delete_pdu() will be
- * called automatically for you.
- */
-
-void coap_delete_pdu(coap_pdu_t *);
-
-/**
-* Interprets @p data to determine the number of bytes in the header.
-* This function returns @c 0 on error or a number greater than zero on success.
-*
-* @param proto  Session's protocol
-* @param data   The first byte of raw data to parse as CoAP PDU.
-*
-* @return       A value greater than zero on success or @c 0 on error.
-*/
-size_t coap_pdu_parse_header_size(coap_proto_t proto,
-                                 const uint8_t *data);
-
-/**
- * Parses @p data to extract the message size.
- * @p length must be at least coap_pdu_parse_header_size(proto, data).
- * This function returns @c 0 on error or a number greater than zero on success.
- *
- * @param proto  Session's protocol
- * @param data   The raw data to parse as CoAP PDU.
- * @param length The actual size of @p data.
- *
- * @return       A value greater than zero on success or @c 0 on error.
- */
-size_t coap_pdu_parse_size(coap_proto_t proto,
-                           const uint8_t *data,
-                           size_t length);
-
-/**
- * Decode the protocol specific header for the specified PDU.
- * @param pdu A newly received PDU.
- * @param proto The target wire protocol.
- * @return 1 for success or 0 on error.
- */
-
-int coap_pdu_parse_header(coap_pdu_t *pdu, coap_proto_t proto);
-
-/**
- * Verify consistency in the given CoAP PDU structure and locate the data.
- * This function returns @c 0 on error or a number greater than zero on
- * success.
- * This function only parses the token and options, up to the payload start
- * marker.
- *
- * @param pdu     The PDU structure to.
- *
- * @return       1 on success or @c 0 on error.
- */
-int coap_pdu_parse_opt(coap_pdu_t *pdu);
-
-/**
-* Parses @p data into the CoAP PDU structure given in @p result.
-* The target pdu must be large enough to
-* This function returns @c 0 on error or a number greater than zero on success.
-*
-* @param proto   Session's protocol
-* @param data    The raw data to parse as CoAP PDU.
-* @param length  The actual size of @p data.
-* @param pdu     The PDU structure to fill. Note that the structure must
-*                provide space to hold at least the token and options
-*                part of the message.
-*
-* @return       1 on success or @c 0 on error.
-*/
-int coap_pdu_parse(coap_proto_t proto,
-                   const uint8_t *data,
-                   size_t length,
-                   coap_pdu_t *pdu);
-/**
- * Adds token of length @p len to @p pdu.
- * Adding the token destroys any following contents of the pdu. Hence options
- * and data must be added after coap_add_token() has been called. In @p pdu,
- * length is set to @p len + @c 4, and max_delta is set to @c 0. This function
- * returns @c 0 on error or a value greater than zero on success.
- *
- * @param pdu  The PDU where the token is to be added.
- * @param len  The length of the new token.
- * @param data The token to add.
- *
- * @return     A value greater than zero on success, or @c 0 on error.
- */
-int coap_add_token(coap_pdu_t *pdu,
-                  size_t len,
-                  const uint8_t *data);
-
-/**
- * Adds option of given type to pdu that is passed as first
- * parameter.
- * coap_add_option() destroys the PDU's data, so coap_add_data() must be called
- * after all options have been added. As coap_add_token() destroys the options
- * following the token, the token must be added before coap_add_option() is
- * called. This function returns the number of bytes written or @c 0 on error.
- */
-size_t coap_add_option(coap_pdu_t *pdu,
-                       uint16_t type,
-                       size_t len,
-                       const uint8_t *data);
-
-/**
- * Adds option of given type to pdu that is passed as first parameter, but does
- * not write a value. It works like coap_add_option with respect to calling
- * sequence (i.e. after token and before data). This function returns a memory
- * address to which the option data has to be written before the PDU can be
- * sent, or @c NULL on error.
- */
-uint8_t *coap_add_option_later(coap_pdu_t *pdu,
-                               uint16_t type,
-                               size_t len);
-
-/**
- * Adds given data to the pdu that is passed as first parameter. Note that the
- * PDU's data is destroyed by coap_add_option(). coap_add_data() must be called
- * only once per PDU, otherwise the result is undefined.
- */
-int coap_add_data(coap_pdu_t *pdu,
-                  size_t len,
-                  const uint8_t *data);
-
-/**
- * Adds given data to the pdu that is passed as first parameter but does not
- * copyt it. Note that the PDU's data is destroyed by coap_add_option().
- * coap_add_data() must be have been called once for this PDU, otherwise the
- * result is undefined.
- * The actual data must be copied at the returned location.
- */
-uint8_t *coap_add_data_after(coap_pdu_t *pdu, size_t len);
-
-/**
- * Retrieves the length and data pointer of specified PDU. Returns 0 on error or
- * 1 if *len and *data have correct values. Note that these values are destroyed
- * with the pdu.
- */
-int coap_get_data(const coap_pdu_t *pdu,
-                  size_t *len,
-                  uint8_t **data);
-
-/**
- * Compose the protocol specific header for the specified PDU.
- * @param pdu A newly composed PDU.
- * @param proto The target wire protocol.
- * @return Number of header bytes prepended before pdu->token or 0 on error.
- */
-
-size_t coap_pdu_encode_header(coap_pdu_t *pdu, coap_proto_t proto);
-
-#endif /* COAP_PDU_H_ */
--- a/tools/sdk/esp32/include/coap/libcoap/include/coap2/prng.h
+++ b/tools/sdk/esp32/include/coap/libcoap/include/coap2/prng.h
@ -1,127 +0,0 @@
-/*
- * prng.h -- Pseudo Random Numbers
- *
- * Copyright (C) 2010-2011 Olaf Bergmann <bergmann@tzi.org>
- *
- * This file is part of the CoAP library libcoap. Please see README for terms
- * of use.
- */
-
-/**
- * @file prng.h
- * @brief Pseudo Random Numbers
- */
-
-#ifndef COAP_PRNG_H_
-#define COAP_PRNG_H_
-
-/**
- * @defgroup prng Pseudo Random Numbers
- * API functions for gerating pseudo random numbers
- * @{
- */
-
-#if defined(WITH_CONTIKI)
-#include <string.h>
-
-/**
- * Fills \p buf with \p len random bytes. This is the default implementation for
- * prng(). You might want to change prng() to use a better PRNG on your specific
- * platform.
- */
-COAP_STATIC_INLINE int
-contiki_prng_impl(unsigned char *buf, size_t len) {
-  uint16_t v = random_rand();
-  while (len > sizeof(v)) {
-    memcpy(buf, &v, sizeof(v));
-    len -= sizeof(v);
-    buf += sizeof(v);
-    v = random_rand();
-  }
-
-  memcpy(buf, &v, len);
-  return 1;
-}
-
-#define prng(Buf,Length) contiki_prng_impl((Buf), (Length))
-#define prng_init(Value) random_init((uint16_t)(Value))
-#elif defined(WITH_LWIP) && defined(LWIP_RAND)
-COAP_STATIC_INLINE int
-lwip_prng_impl(unsigned char *buf, size_t len) {
-  u32_t v = LWIP_RAND();
-  while (len > sizeof(v)) {
-    memcpy(buf, &v, sizeof(v));
-    len -= sizeof(v);
-    buf += sizeof(v);
-    v = LWIP_RAND();
-  }
-
-  memcpy(buf, &v, len);
-  return 1;
-}
-
-#define prng(Buf,Length) lwip_prng_impl((Buf), (Length))
-#define prng_init(Value)
-#elif defined(_WIN32)
-#define prng_init(Value)
-errno_t __cdecl rand_s( _Out_ unsigned int* _RandomValue );
- /**
- * Fills \p buf with \p len random bytes. This is the default implementation for
- * prng(). You might want to change prng() to use a better PRNG on your specific
- * platform.
- */
-COAP_STATIC_INLINE int
-coap_prng_impl( unsigned char *buf, size_t len ) {
-        while ( len != 0 ) {
-                uint32_t r = 0;
-                size_t i;
-                if ( rand_s( &r ) != 0 )
-                        return 0;
-                for ( i = 0; i < len && i < 4; i++ ) {
-                        *buf++ = (uint8_t)r;
-                        r >>= 8;
-                }
-                len -= i;
-        }
-        return 1;
-}
-
-#else
-#include <stdlib.h>
-
- /**
- * Fills \p buf with \p len random bytes. This is the default implementation for
- * prng(). You might want to change prng() to use a better PRNG on your specific
- * platform.
- */
-COAP_STATIC_INLINE int
-coap_prng_impl( unsigned char *buf, size_t len ) {
-        while ( len-- )
-                *buf++ = rand() & 0xFF;
-        return 1;
-}
-#endif
-
-
-#ifndef prng
-/**
- * Fills \p Buf with \p Length bytes of random data.
- *
- * @hideinitializer
- */
-#define prng(Buf,Length) coap_prng_impl((Buf), (Length))
-#endif
-
-#ifndef prng_init
-/**
- * Called to set the PRNG seed. You may want to re-define this to allow for a
- * better PRNG.
- *
- * @hideinitializer
- */
-#define prng_init(Value) srand((unsigned long)(Value))
-#endif
-
-/** @} */
-
-#endif /* COAP_PRNG_H_ */
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Anthony Elder	15bbd0a187	Add ALPN support to WiFiClientSecure (#5633 ) This adds a function to WiFiClientSecure to set the ALPN protocol. This is required for an MQTT client to connect to AWS IoT when using an AWS Custom Authorizer, as described here. Example code snippet: ... WiFiClientSecure wiFiClient; // ALPN protocol, needed with AWS custom authorizer const char *aws_protos[] = {"mqtt", NULL}; void setup() { wiFiClient.setCACert(AWSCAPEM); wiFiClient.setAlpnProtocols(aws_protos); } ...	2021-10-25 09:20:47 +03:00
Hideaki Tai	02c3ec01cc	remove _user_defined_size from EEPROM (#5775 ) Summary Related to the issue #5773 and #2280. _user_defined_size is removed from EEPROMClass because it is redundant in the current code EEPROMClass::length() returns _size that is the true available size of EEPROM Impact _user_defined_size is removed from EEPROMClass EEPROMClass::length() returns _size that is the true available size of EEPROM	2021-10-25 09:15:47 +03:00
George White	cb5a490616	Correct CDC on boot custom menu for Deneyap Mini (#5767 ) The Deneyap Mini used a SerialMode custom menu item, which is not defined. The correct item, CDCOnBoot, has replaced it.	2021-10-25 09:13:48 +03:00
Me No Dev	f257d6f126	IDF release/v4.4 2720d45e71 (#5801 )	2021-10-25 09:12:37 +03:00
P-R-O-C-H-Y	aabbed0bbc	analogRead() now return value according to value set in analogReadResulotion() (#5776 ) Function analogReadResolution set how many bits will analogRead return. Find out that this functionality was added back 2017 by @me-no-dev in #161. Related issues: #5163	2021-10-24 13:01:05 +03:00
Rodrigo Garcia	a418058a66	log statement missing parameter #5778 (#5796 )	2021-10-23 11:34:00 -03:00
Rodrigo Garcia	96ad341451	Merge pull request #5795 from SuGlider/esp_eth_clear_default_handlers removes deprecated esp_eth_set_default_handlers()	2021-10-22 22:13:08 -03:00
Rodrigo Garcia	2673b88582	removes deprecated esp_eth_set_default_handlers()	2021-10-22 21:56:14 -03:00
Rodrigo Garcia	67c99142d2	Allows spiram malloc with wifi dynamic buffers - better free heap (#5791 ) Summary Modifies WiFi lib to allow dynamic buffer allocation along with SPIRAM MALLOC enabled This gives more heap space to the users Related PR in Arduino Lib Builder: espressif/esp32-arduino-lib-builder#47 Impact WiFi will work the same as it was in version 1.0.6, restoring free heap. close #5630 close #5474 close #5699 close #5697	2021-10-22 02:22:20 +03:00
michlv	951c8bece5	libraries/SPI/src/SPI.h: SPIClass: add method to get SS pin number (#5788 ) * SPI.h add new call to return a SS pin number used. As code example states, the SS pin needs to be explicitly set for output for SPI to work, but the pin number have to be coded in addition to the SPI logic in the library, which means this duplicates code. It is much better to just be able to get the pin number from library itself. * Update SPI_Multiple_Buses.ino to use new pinSS method Simplify the example case, to show usage of pinSS method. This also simplifies the example, removing duplicated code.	2021-10-21 16:48:55 +03:00
Me No Dev	4413dbbd87	IDF master 4e03a9c34c (#5792 ) esp-dsp: master e05fc36 esp-face: master f108a83 esp-rainmaker: f1b82c7 esp32-camera: master 3022601 esp_littlefs: master 05d55ab	2021-10-21 16:27:28 +03:00
Me No Dev	ed53b6c8d4	Merge pull request #5746 from espressif/i2c-slave I2C Slave Implementation	2021-10-14 12:52:20 +03:00
Me No Dev	2e53300da5	IDF master b86fe0c66c esp-dsp: master e05fc36 esp-face: master f108a83 esp-rainmaker: f1b82c7 esp32-camera: master 3022601 esp_littlefs: master f6e7108	2021-10-14 12:51:25 +03:00
Pedro Minatel	64c7f746fd	Merge pull request #5753 from pedrominatel/docs/troubleshooting_python_not_found [Docs] Added Python is missing on the troubleshooting section	2021-10-14 09:48:15 +01:00
Pedro Minatel	1049be7d56	Merge branch 'master' into docs/troubleshooting_python_not_found	2021-10-14 09:37:12 +01:00
me-no-dev	34c81be93b	IDF master b86fe0c66c	2021-10-13 18:21:12 +00:00
me-no-dev	2fb2ef54ce	Calculate properly Firmware MSC fat table sectors	2021-10-13 15:39:36 +03:00
pedro.minatel	49f525c91d	Added Python is missing on the troubleshooting section	2021-10-12 13:26:13 +01:00
me-no-dev	b145e65975	API Optimizations - Support Wire::end() for Slave - Prevent Master operations when in Slave mode	2021-10-11 14:46:31 +03:00
Me No Dev	951c32056a	Merge branch 'master' into i2c-slave	2021-10-11 13:13:13 +03:00
Me No Dev	7a7bd37e51	feat: Add the ability to get the peer certificate of an SSL connection Summary New feature: Add the ability to get the peer certificate of an SSL connectio. This is useful for IoT when the root/cert trust chain has a shorter lifecylce than the device itself. Includes example code. It adds two methods to the WiFiClientSecure client: bool getFingerprintSHA256( uint8_t fingerprint_remote_sha256[32]) -- return true and the fingerprint (i.e. the SHA256 of the raw x509 as a DER - identical to what you see in for example your webbrowser). Or false on error. const mbedtls_x509_crt* getPeerCertificate(); -- return the actual X509 struct or NULL on error. Impact No impact; backwards compatible (only adds to the API)	2021-10-11 13:04:13 +03:00
otakuto	a75602dc68	Add support M5Stack Unit CAM (#5748 ) In this PR, we add support for M5Stack Unit CAM to CameraWebServer. https://docs.m5stack.com/en/unit/unit_cam	2021-10-11 13:01:10 +03:00
Uri Shaked	88789cd817	Fix build error when compiling with verbose logging (#5747 ) When compiling with verbose logging, the build would error with a message saying `len` is not defined in `tud_vendor_rx_cb()`. This change fixes the error.	2021-10-11 13:00:25 +03:00
me-no-dev	335cedf4f7	Update CMakeLists.txt	2021-10-09 14:37:10 +03:00
me-no-dev	f9f70d2f73	I2C Slave Implementation	2021-10-09 14:30:20 +03:00
P-R-O-C-H-Y	5b207104aa	Fix: SD_MMC deinit (#5732 ) * SD.open() new feature for creating all folders in path This PR adds to the SD.open() function option to create all folders to the file. SD.open(const char* path, const char* mode, const bool create) Default value of create is false. When true folders are created. From issue #5019 * Update vfs_api.cpp memccpy -> memcpy * SD_MMC deinit fix Wrong deinit function was called.	2021-10-09 14:12:25 +03:00
Dirk-Willem van Gulik	1706af4656	Add the ability to get the peer certificate of an SSL connection; useful for IoT when the root/cert trust chain has a shorter lifecylce than the device itself. Includes example	2021-10-08 14:20:43 +02:00
Michał Szczepaniak	bd54ee442b	Remove git submodule update (#5696 ) We don't have submodules.	2021-10-01 18:11:59 +03:00
Me No Dev	00214d5c2a	IDF master 3e370c4296 * Fix build compilation due to changes in the HW_TIMER's structs * Fix compilation warnings and errors with USB * Update USBCDC.cpp * Update CMakeLists.txt * Update HWCDC.cpp	2021-10-01 17:52:29 +03:00
me-no-dev	381e88ec75	[UART] check if write data is valid	2021-10-01 17:36:59 +03:00
Me No Dev	f87107dedb	Implement Thread-Safe I2C based on ESP-IDF API (#5683 ) * Implement Thread-Safe I2C based on ESP-IDF API * Update esp32-hal.h * use proper types for size and timeout * Allow disabling of the HAL locks * Limit frequency settings to prevent Interrupt WDT	2021-10-01 17:34:20 +03:00
Akash Mankar	ce85cf03cc	added comment for user clarity (#5724 )	2021-10-01 17:17:42 +03:00
P-R-O-C-H-Y	f2a20e8a38	SD.open() new feature for creating all folders in path (#5721 ) * SD.open() new feature for creating all folders in path This PR adds to the SD.open() function option to create all folders to the file. SD.open(const char* path, const char* mode, const bool create) Default value of create is false. When true folders are created. From issue #5019 * Update vfs_api.cpp memccpy -> memcpy * File f = open() edit added false for create	2021-10-01 17:16:59 +03:00
Ha Thach	c5bb8334d7	include pin_arduino.h for variant USB defines (#5719 )	2021-10-01 16:15:15 +03:00
Ha Thach	6de7f16f28	update adafruit boards for 2.0 (#5718 )	2021-10-01 16:14:50 +03:00
Carter Nelson	1688b7c179	Fix analogWidth for ESP32S2 in esp32-hal-adc.c (#5711 )	2021-10-01 16:13:24 +03:00
kokke	36ff442698	bugfix: off-by-one error (#5648 )	2021-10-01 15:48:35 +03:00
Serguei S. Dukachev	93f10609f4	SDMMC frequency selection based on board type (#5688 ) * SDMMC frequency selection based on board type On Olimex ESP32 EVB I/O operations with SD card can cause error when LAN is used in same time. Problem is disappearing if SD MMC frequency lower down from SDMMC_FREQ_HIGHSPEED to SDMMC_FREQ_DEFAULT. No problem if WiFi used instead LAN. * Code rewritten according to https://github.com/espressif/arduino-esp32/pull/5688#pullrequestreview-759359645	2021-10-01 15:48:20 +03:00
Felix Collins	67583e84d6	Return size_t instead of uint8_t from BLECharacteristic::getLength(). Allows large MTU to be used. (#5687 )	2021-10-01 15:47:42 +03:00
Thomas Bertels	108e467164	Enable progress bar on ArduinoOTA upload (platform.txt) (#5657 )	2021-10-01 15:06:55 +03:00
Clemens Kirchgatterer	91bca6c074	Fix compilation of HardwareSerial.cpp (#5677 ) Fix compilation in case NO_GLOBAL_INSTANCES \|\| NO_GLOBAL_SERIAL is defined.	2021-10-01 15:06:16 +03:00
long_long_float	204f360dce	Append '/' to an URL with empty path in HTTPClient::begin (#5634 ) * Add an error check for empty path of an URL * Append '/' to an URL with empty path instead of returning an error	2021-10-01 15:04:09 +03:00
Danylo Ulianych	3f06a38f69	SD_MMC max_freq_khz is set to HIGHSPEED by default (#5631 )	2021-10-01 15:03:38 +03:00
Eddie Espinal	2f6f251400	Fixes boards.txt entries for the atmegazero_esp32s2, and also the platform.txt --flash_size which is not letting the board compile due to its 32MB size. (#5673 )	2021-10-01 14:39:08 +03:00
liebman	e4acfbc54a	only use ksz8081 for idf versions later than 4.3 (this fixes compile as component for idf 4.3) (#5599 ) esp_eth_phy_new_ksz8081 was added in IDF after version 4.3 and generates a compilation error with IDF-4.3. This change will only use esp_eth_phy_new_ksz8081 for IDF versions after 4.3	2021-10-01 14:38:45 +03:00
Marius Kintel	79d53bdc4c	Update ESP.getChipModel() to support ESP32-S2 (#5598 )	2021-10-01 14:37:17 +03:00
thambirm	f3f6dad14a	TTGO T-OI PLUS RISC-V ESP32-C3 Development Board Added (#5576 )	2021-10-01 14:24:44 +03:00
Pedro Minatel	317be68cef	Merge pull request #5685 from pedrominatel/docs/integration_with_wokwi Docs integration with Wokwi - Blink Tutorial	2021-09-21 15:31:44 +01:00
Pedro Minatel	1f4dd7f131	Merge branch 'master' into docs/integration_with_wokwi	2021-09-21 14:55:27 +01:00
pedro.minatel	8be2f7b1cc	Changes according to the PR review	2021-09-21 14:34:21 +01:00
Vojtěch Bartoška	9f827a66d5	Update README.MD - "Type: For reference" labels link (#5619 ) * Create PULL_REQUEST_TEMPLATE.md Adding first version of PULL_REQUEST_TEMPLATE.md. The purpose of this template is to improve and simplify writing more accurate Release Notes. * Update PULL_REQUEST_TEMPLATE.md Fix typo. * Update README.MD - "Type: For reference" labels link Updating a link to issues labeled with "Type: For reference". The old one is not working due to the updates of labels in the past.	2021-09-21 11:36:36 +03:00
pedro.minatel	e1cdbd7816	Minor changes on the blink tutorial	2021-09-20 12:39:05 +01:00
pedro.minatel	7a35be3e7e	Added blink example with Wokwi embedded simulation	2021-09-20 12:00:52 +01:00
Me No Dev	078671d273	[HWCDC] Improve HW CDC Implementation (#5643 ) This pull request contains a few fixes and improvements to the HWCDC implementation. - Rework `HWCDC::write()` to accept unlimited data - Add Semaphore to guard the TX Ring Buffer - Add events support - Remove unnecessary 1200bps touch for flashing over HWCDC - Fix `HardwareSerial::setDebugOutput()` not resetting `putc` if the port is already selected, causing debug output to also show on HWCDC even when not selected.	2021-09-15 19:37:09 +03:00
Me No Dev	541cef9149	[USB CDC] Fix data might not be transmitted until more is written (#5652 ) Depending on `tud_cdc_tx_complete_cb` can cause in some cases the last packet to not be transmitted until more data is written and flushed. It's a rare case, but if the other end is expecting those last bytes, transmission will hang. This PR also fixes debug output on CDC	2021-09-15 15:23:11 +03:00
Tomas Sebestik	6dfaf6cdd4	Add dummy test for self hosted GitHub runners (#5521 ) * Add dummy test for self hosted GitHub runners	2021-09-15 15:02:04 +03:00
Pedro Minatel	92ce408f4c	Merge pull request #5616 from pedrominatel/docs/update_for_release_2-0-0 Supported devices table updated due the 2.0.0 release	2021-08-31 12:16:57 +01:00
pedro.minatel	453af3800c	Supported devices table updated due the 2.0.0 release	2021-08-31 11:29:10 +01:00