Prvni ulozeni z chegewara githubu

libraries/ESP32/examples/AnalogOut/LEDCSoftwareFade/LEDCSoftwareFade.ino

@@ -0,0 +1,57 @@
+/*
+ LEDC Software Fade
+
+ This example shows how to software fade LED
+ using the ledcWrite function.
+
+ Code adapted from original Arduino Fade example:
+ https://www.arduino.cc/en/Tutorial/Fade
+
+ This example code is in the public domain.
+ */
+
+// use first channel of 16 channels (started from zero)
+#define LEDC_CHANNEL_0     0
+
+// use 12 bit precission for LEDC timer
+#define LEDC_TIMER_12_BIT  12
+
+// use 5000 Hz as a LEDC base frequency
+#define LEDC_BASE_FREQ     5000
+
+// fade LED PIN (replace with LED_BUILTIN constant for built-in LED)
+#define LED_PIN            5
+
+int brightness = 0;    // how bright the LED is
+int fadeAmount = 5;    // how many points to fade the LED by
+
+// Arduino like analogWrite
+// value has to be between 0 and valueMax
+void ledcAnalogWrite(uint8_t channel, uint32_t value, uint32_t valueMax = 255) {
+  // calculate duty, 4095 from 2 ^ 12 - 1
+  uint32_t duty = (4095 / valueMax) * min(value, valueMax);
+
+  // write duty to LEDC
+  ledcWrite(channel, duty);
+}
+
+void setup() {
+  // Setup timer and attach timer to a led pin
+  ledcSetup(LEDC_CHANNEL_0, LEDC_BASE_FREQ, LEDC_TIMER_12_BIT);
+  ledcAttachPin(LED_PIN, LEDC_CHANNEL_0);
+}
+
+void loop() {
+  // set the brightness on LEDC channel 0
+  ledcAnalogWrite(LEDC_CHANNEL_0, brightness);
+
+  // change the brightness for next time through the loop:
+  brightness = brightness + fadeAmount;
+
+  // reverse the direction of the fading at the ends of the fade:
+  if (brightness <= 0 || brightness >= 255) {
+    fadeAmount = -fadeAmount;
+  }
+  // wait for 30 milliseconds to see the dimming effect
+  delay(30);
+}

libraries/ESP32/examples/AnalogOut/SigmaDelta/SigmaDelta.ino

@@ -0,0 +1,16 @@
+void setup()
+{
+    //setup on pin 18, channel 0 with frequency 312500 Hz
+    sigmaDeltaSetup(18,0, 312500);
+    //initialize channel 0 to off
+    sigmaDeltaWrite(0, 0);
+}
+
+void loop()
+{
+    //slowly ramp-up the value
+    //will overflow at 256
+    static uint8_t i = 0;
+    sigmaDeltaWrite(0, i++);
+    delay(100);
+}

libraries/ESP32/examples/AnalogOut/ledcWrite_RGB/ledcWrite_RGB.ino

@@ -0,0 +1,130 @@
+/*
+  ledcWrite_RGB.ino
+  Runs through the full 255 color spectrum for an rgb led 
+  Demonstrate ledcWrite functionality for driving leds with PWM on ESP32
+ 
+  This example code is in the public domain.
+  
+  Some basic modifications were made by vseven, mostly commenting.
+ */
+ 
+// Set up the rgb led names
+uint8_t ledR = 2;
+uint8_t ledG = 4;
+uint8_t ledB = 5; 
+
+uint8_t ledArray[3] = {1, 2, 3}; // three led channels
+
+const boolean invert = true; // set true if common anode, false if common cathode
+
+uint8_t color = 0;          // a value from 0 to 255 representing the hue
+uint32_t R, G, B;           // the Red Green and Blue color components
+uint8_t brightness = 255;  // 255 is maximum brightness, but can be changed.  Might need 256 for common anode to fully turn off.
+
+// the setup routine runs once when you press reset:
+void setup() 
+{            
+  Serial.begin(115200);
+  delay(10); 
+  
+  ledcAttachPin(ledR, 1); // assign RGB led pins to channels
+  ledcAttachPin(ledG, 2);
+  ledcAttachPin(ledB, 3);
+  
+  // Initialize channels 
+  // channels 0-15, resolution 1-16 bits, freq limits depend on resolution
+  // ledcSetup(uint8_t channel, uint32_t freq, uint8_t resolution_bits);
+  ledcSetup(1, 12000, 8); // 12 kHz PWM, 8-bit resolution
+  ledcSetup(2, 12000, 8);
+  ledcSetup(3, 12000, 8);
+}
+
+// void loop runs over and over again
+void loop() 
+{
+  Serial.println("Send all LEDs a 255 and wait 2 seconds.");
+  // If your RGB LED turns off instead of on here you should check if the LED is common anode or cathode.
+  // If it doesn't fully turn off and is common anode try using 256.
+  ledcWrite(1, 255);
+  ledcWrite(2, 255);
+  ledcWrite(3, 255);
+  delay(2000);
+  Serial.println("Send all LEDs a 0 and wait 2 seconds.");
+  ledcWrite(1, 0);
+  ledcWrite(2, 0);
+  ledcWrite(3, 0);
+  delay(2000);
+ 
+  Serial.println("Starting color fade loop.");
+  
+ for (color = 0; color < 255; color++) { // Slew through the color spectrum
+
+  hueToRGB(color, brightness);  // call function to convert hue to RGB
+
+  // write the RGB values to the pins
+  ledcWrite(1, R); // write red component to channel 1, etc.
+  ledcWrite(2, G);   
+  ledcWrite(3, B); 
+ 
+  delay(100); // full cycle of rgb over 256 colors takes 26 seconds
+ }
+ 
+}
+
+// Courtesy http://www.instructables.com/id/How-to-Use-an-RGB-LED/?ALLSTEPS
+// function to convert a color to its Red, Green, and Blue components.
+
+void hueToRGB(uint8_t hue, uint8_t brightness)
+{
+    uint16_t scaledHue = (hue * 6);
+    uint8_t segment = scaledHue / 256; // segment 0 to 5 around the
+                                            // color wheel
+    uint16_t segmentOffset =
+      scaledHue - (segment * 256); // position within the segment
+
+    uint8_t complement = 0;
+    uint16_t prev = (brightness * ( 255 -  segmentOffset)) / 256;
+    uint16_t next = (brightness *  segmentOffset) / 256;
+
+    if(invert)
+    {
+      brightness = 255 - brightness;
+      complement = 255;
+      prev = 255 - prev;
+      next = 255 - next;
+    }
+
+    switch(segment ) {
+    case 0:      // red
+        R = brightness;
+        G = next;
+        B = complement;
+    break;
+    case 1:     // yellow
+        R = prev;
+        G = brightness;
+        B = complement;
+    break;
+    case 2:     // green
+        R = complement;
+        G = brightness;
+        B = next;
+    break;
+    case 3:    // cyan
+        R = complement;
+        G = prev;
+        B = brightness;
+    break;
+    case 4:    // blue
+        R = next;
+        G = complement;
+        B = brightness;
+    break;
+   case 5:      // magenta
+    default:
+        R = brightness;
+        G = complement;
+        B = prev;
+    break;
+    }
+}

libraries/ESP32/examples/AnalogRead/AnalogRead.ino

@@ -0,0 +1,19 @@
+void setup() {
+  // initialize serial communication at 115200 bits per second:
+  Serial.begin(115200);
+  
+  //set the resolution to 12 bits (0-4096)
+  analogReadResolution(12);
+}
+
+void loop() {
+  // read the analog / millivolts value for pin 2:
+  int analogValue = analogRead(2);
+  int analogVolts = analogReadMilliVolts(2);
+  
+  // print out the values you read:
+  Serial.printf("ADC analog value = %d\n",analogValue);
+  Serial.printf("ADC millivolts value = %d\n",analogVolts);
+  
+  delay(100);  // delay in between reads for clear read from serial
+}

libraries/ESP32/examples/ArduinoStackSize/ArduinoStackSize.ino

@@ -0,0 +1,36 @@
+/*
+    ESP32 Arduino creates a task to run setup() and then to execute loop() continuously
+    This task can be found at https://github.com/espressif/arduino-esp32/blob/master/cores/esp32/main.cpp
+
+    By default "loopTask" will be created with a stack size of 8KB.
+    This should be plenty for most general sketches.
+
+    There is a way to change the stack size of this task by using
+    SET_LOOP_TASK_STACK_SIZE(size);
+    It will bypass the default stack size of 8KB and allow the user to define a new size.
+
+    It is recommend this value to be higher than 8KB, for instance 16KB.
+    This increasing may be necessary for the sketches that use deep recursion for instance.
+
+    In this example, you can verify it by changing or just commenting out SET_LOOP_TASK_STACK_SIZE();
+*/
+
+
+// This sets Arduino Stack Size - comment this line to use default 8K stack size
+SET_LOOP_TASK_STACK_SIZE(16*1024); // 16KB
+
+void setup() {
+  Serial.begin(115200);
+
+  Serial.printf("Arduino Stack was set to %d bytes", getArduinoLoopTaskStackSize());
+
+  // Print unused stack for the task that is running setup()
+  Serial.printf("\nSetup() - Free Stack Space: %d", uxTaskGetStackHighWaterMark(NULL));
+}
+
+void loop() {
+  delay(1000);
+
+  // Print unused stack for the task that is running loop() - the same as for setup()
+  Serial.printf("\nLoop() - Free Stack Space: %d", uxTaskGetStackHighWaterMark(NULL));
+}

libraries/ESP32/examples/Camera/CameraWebServer/CameraWebServer.ino

@@ -0,0 +1,147 @@
+#include "esp_camera.h"
+#include <WiFi.h>
+
+//
+// WARNING!!! PSRAM IC required for UXGA resolution and high JPEG quality
+//            Ensure ESP32 Wrover Module or other board with PSRAM is selected
+//            Partial images will be transmitted if image exceeds buffer size
+//
+//            You must select partition scheme from the board menu that has at least 3MB APP space.
+//            Face Recognition is DISABLED for ESP32 and ESP32-S2, because it takes up from 15 
+//            seconds to process single frame. Face Detection is ENABLED if PSRAM is enabled as well
+
+// ===================
+// Select camera model
+// ===================
+//#define CAMERA_MODEL_WROVER_KIT // Has PSRAM
+//#define CAMERA_MODEL_ESP_EYE // Has PSRAM
+//#define CAMERA_MODEL_ESP32S3_EYE // Has PSRAM
+//#define CAMERA_MODEL_M5STACK_PSRAM // Has PSRAM
+//#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
+// ** Espressif Internal Boards **
+//#define CAMERA_MODEL_ESP32_CAM_BOARD
+//#define CAMERA_MODEL_ESP32S2_CAM_BOARD
+//#define CAMERA_MODEL_ESP32S3_CAM_LCD
+
+#include "camera_pins.h"
+
+// ===========================
+// Enter your WiFi credentials
+// ===========================
+const char* ssid = "**********";
+const char* password = "**********";
+
+void startCameraServer();
+
+void setup() {
+  Serial.begin(115200);
+  Serial.setDebugOutput(true);
+  Serial.println();
+
+  camera_config_t config;
+  config.ledc_channel = LEDC_CHANNEL_0;
+  config.ledc_timer = LEDC_TIMER_0;
+  config.pin_d0 = Y2_GPIO_NUM;
+  config.pin_d1 = Y3_GPIO_NUM;
+  config.pin_d2 = Y4_GPIO_NUM;
+  config.pin_d3 = Y5_GPIO_NUM;
+  config.pin_d4 = Y6_GPIO_NUM;
+  config.pin_d5 = Y7_GPIO_NUM;
+  config.pin_d6 = Y8_GPIO_NUM;
+  config.pin_d7 = Y9_GPIO_NUM;
+  config.pin_xclk = XCLK_GPIO_NUM;
+  config.pin_pclk = PCLK_GPIO_NUM;
+  config.pin_vsync = VSYNC_GPIO_NUM;
+  config.pin_href = HREF_GPIO_NUM;
+  config.pin_sscb_sda = SIOD_GPIO_NUM;
+  config.pin_sscb_scl = SIOC_GPIO_NUM;
+  config.pin_pwdn = PWDN_GPIO_NUM;
+  config.pin_reset = RESET_GPIO_NUM;
+  config.xclk_freq_hz = 20000000;
+  config.frame_size = FRAMESIZE_UXGA;
+  config.pixel_format = PIXFORMAT_JPEG; // for streaming
+  //config.pixel_format = PIXFORMAT_RGB565; // for face detection/recognition
+  config.grab_mode = CAMERA_GRAB_WHEN_EMPTY;
+  config.fb_location = CAMERA_FB_IN_PSRAM;
+  config.jpeg_quality = 12;
+  config.fb_count = 1;
+  
+  // if PSRAM IC present, init with UXGA resolution and higher JPEG quality
+  //                      for larger pre-allocated frame buffer.
+  if(config.pixel_format == PIXFORMAT_JPEG){
+    if(psramFound()){
+      config.jpeg_quality = 10;
+      config.fb_count = 2;
+      config.grab_mode = CAMERA_GRAB_LATEST;
+    } else {
+      // Limit the frame size when PSRAM is not available
+      config.frame_size = FRAMESIZE_SVGA;
+      config.fb_location = CAMERA_FB_IN_DRAM;
+    }
+  } else {
+    // Best option for face detection/recognition
+    config.frame_size = FRAMESIZE_240X240;
+#if CONFIG_IDF_TARGET_ESP32S3
+    config.fb_count = 2;
+#endif
+  }
+
+#if defined(CAMERA_MODEL_ESP_EYE)
+  pinMode(13, INPUT_PULLUP);
+  pinMode(14, INPUT_PULLUP);
+#endif
+
+  // camera init
+  esp_err_t err = esp_camera_init(&config);
+  if (err != ESP_OK) {
+    Serial.printf("Camera init failed with error 0x%x", err);
+    return;
+  }
+
+  sensor_t * s = esp_camera_sensor_get();
+  // initial sensors are flipped vertically and colors are a bit saturated
+  if (s->id.PID == OV3660_PID) {
+    s->set_vflip(s, 1); // flip it back
+    s->set_brightness(s, 1); // up the brightness just a bit
+    s->set_saturation(s, -2); // lower the saturation
+  }
+  // drop down frame size for higher initial frame rate
+  if(config.pixel_format == PIXFORMAT_JPEG){
+    s->set_framesize(s, FRAMESIZE_QVGA);
+  }
+
+#if defined(CAMERA_MODEL_M5STACK_WIDE) || defined(CAMERA_MODEL_M5STACK_ESP32CAM)
+  s->set_vflip(s, 1);
+  s->set_hmirror(s, 1);
+#endif
+
+#if defined(CAMERA_MODEL_ESP32S3_EYE)
+  s->set_vflip(s, 1);
+#endif
+
+  WiFi.begin(ssid, password);
+  WiFi.setSleep(false);
+
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(500);
+    Serial.print(".");
+  }
+  Serial.println("");
+  Serial.println("WiFi connected");
+
+  startCameraServer();
+
+  Serial.print("Camera Ready! Use 'http://");
+  Serial.print(WiFi.localIP());
+  Serial.println("' to connect");
+}
+
+void loop() {
+  // Do nothing. Everything is done in another task by the web server
+  delay(10000);
+}

libraries/ESP32/examples/Camera/CameraWebServer/camera_pins.h

@@ -0,0 +1,273 @@
+
+#if defined(CAMERA_MODEL_WROVER_KIT)
+#define PWDN_GPIO_NUM    -1
+#define RESET_GPIO_NUM   -1
+#define XCLK_GPIO_NUM    21
+#define SIOD_GPIO_NUM    26
+#define SIOC_GPIO_NUM    27
+
+#define Y9_GPIO_NUM      35
+#define Y8_GPIO_NUM      34
+#define Y7_GPIO_NUM      39
+#define Y6_GPIO_NUM      36
+#define Y5_GPIO_NUM      19
+#define Y4_GPIO_NUM      18
+#define Y3_GPIO_NUM       5
+#define Y2_GPIO_NUM       4
+#define VSYNC_GPIO_NUM   25
+#define HREF_GPIO_NUM    23
+#define PCLK_GPIO_NUM    22
+
+#elif defined(CAMERA_MODEL_ESP_EYE)
+#define PWDN_GPIO_NUM    -1
+#define RESET_GPIO_NUM   -1
+#define XCLK_GPIO_NUM    4
+#define SIOD_GPIO_NUM    18
+#define SIOC_GPIO_NUM    23
+
+#define Y9_GPIO_NUM      36
+#define Y8_GPIO_NUM      37
+#define Y7_GPIO_NUM      38
+#define Y6_GPIO_NUM      39
+#define Y5_GPIO_NUM      35
+#define Y4_GPIO_NUM      14
+#define Y3_GPIO_NUM      13
+#define Y2_GPIO_NUM      34
+#define VSYNC_GPIO_NUM   5
+#define HREF_GPIO_NUM    27
+#define PCLK_GPIO_NUM    25
+
+#elif defined(CAMERA_MODEL_M5STACK_PSRAM)
+#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_M5STACK_V2_PSRAM)
+#define PWDN_GPIO_NUM     -1
+#define RESET_GPIO_NUM    15
+#define XCLK_GPIO_NUM     27
+#define SIOD_GPIO_NUM     22
+#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    25
+#define HREF_GPIO_NUM     26
+#define PCLK_GPIO_NUM     21
+
+#elif defined(CAMERA_MODEL_M5STACK_WIDE)
+#define PWDN_GPIO_NUM     -1
+#define RESET_GPIO_NUM    15
+#define XCLK_GPIO_NUM     27
+#define SIOD_GPIO_NUM     22
+#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    25
+#define HREF_GPIO_NUM     26
+#define PCLK_GPIO_NUM     21
+
+#elif defined(CAMERA_MODEL_M5STACK_ESP32CAM)
+#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       17
+#define VSYNC_GPIO_NUM    22
+#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
+#define XCLK_GPIO_NUM      0
+#define SIOD_GPIO_NUM     26
+#define SIOC_GPIO_NUM     27
+
+#define Y9_GPIO_NUM       35
+#define Y8_GPIO_NUM       34
+#define Y7_GPIO_NUM       39
+#define Y6_GPIO_NUM       36
+#define Y5_GPIO_NUM       21
+#define Y4_GPIO_NUM       19
+#define Y3_GPIO_NUM       18
+#define Y2_GPIO_NUM        5
+#define VSYNC_GPIO_NUM    25
+#define HREF_GPIO_NUM     23
+#define PCLK_GPIO_NUM     22
+
+#elif defined(CAMERA_MODEL_TTGO_T_JOURNAL)
+#define PWDN_GPIO_NUM      0
+#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       17
+#define VSYNC_GPIO_NUM    22
+#define HREF_GPIO_NUM     26
+#define PCLK_GPIO_NUM     21
+
+
+#elif defined(CAMERA_MODEL_ESP32_CAM_BOARD)
+// The 18 pin header on the board has Y5 and Y3 swapped
+#define USE_BOARD_HEADER 0 
+#define PWDN_GPIO_NUM    32
+#define RESET_GPIO_NUM   33
+#define XCLK_GPIO_NUM     4
+#define SIOD_GPIO_NUM    18
+#define SIOC_GPIO_NUM    23
+
+#define Y9_GPIO_NUM      36
+#define Y8_GPIO_NUM      19
+#define Y7_GPIO_NUM      21
+#define Y6_GPIO_NUM      39
+#if USE_BOARD_HEADER
+#define Y5_GPIO_NUM      13
+#else
+#define Y5_GPIO_NUM      35
+#endif
+#define Y4_GPIO_NUM      14
+#if USE_BOARD_HEADER
+#define Y3_GPIO_NUM      35
+#else
+#define Y3_GPIO_NUM      13
+#endif
+#define Y2_GPIO_NUM      34
+#define VSYNC_GPIO_NUM    5
+#define HREF_GPIO_NUM    27
+#define PCLK_GPIO_NUM    25
+
+#elif defined(CAMERA_MODEL_ESP32S3_CAM_LCD)
+#define PWDN_GPIO_NUM     -1
+#define RESET_GPIO_NUM    -1
+#define XCLK_GPIO_NUM     40
+#define SIOD_GPIO_NUM     17
+#define SIOC_GPIO_NUM     18
+
+#define Y9_GPIO_NUM       39
+#define Y8_GPIO_NUM       41
+#define Y7_GPIO_NUM       42
+#define Y6_GPIO_NUM       12
+#define Y5_GPIO_NUM       3
+#define Y4_GPIO_NUM       14
+#define Y3_GPIO_NUM       47
+#define Y2_GPIO_NUM       13
+#define VSYNC_GPIO_NUM    21
+#define HREF_GPIO_NUM     38
+#define PCLK_GPIO_NUM     11
+
+#elif defined(CAMERA_MODEL_ESP32S2_CAM_BOARD)
+// The 18 pin header on the board has Y5 and Y3 swapped
+#define USE_BOARD_HEADER 0
+#define PWDN_GPIO_NUM     1
+#define RESET_GPIO_NUM    2
+#define XCLK_GPIO_NUM     42
+#define SIOD_GPIO_NUM     41
+#define SIOC_GPIO_NUM     18
+
+#define Y9_GPIO_NUM       16
+#define Y8_GPIO_NUM       39
+#define Y7_GPIO_NUM       40
+#define Y6_GPIO_NUM       15
+#if USE_BOARD_HEADER
+#define Y5_GPIO_NUM       12
+#else
+#define Y5_GPIO_NUM       13
+#endif
+#define Y4_GPIO_NUM       5
+#if USE_BOARD_HEADER
+#define Y3_GPIO_NUM       13
+#else
+#define Y3_GPIO_NUM       12
+#endif
+#define Y2_GPIO_NUM       14
+#define VSYNC_GPIO_NUM    38
+#define HREF_GPIO_NUM     4
+#define PCLK_GPIO_NUM     3
+
+#elif defined(CAMERA_MODEL_ESP32S3_EYE)
+#define PWDN_GPIO_NUM -1
+#define RESET_GPIO_NUM -1
+#define XCLK_GPIO_NUM 15
+#define SIOD_GPIO_NUM 4
+#define SIOC_GPIO_NUM 5
+
+#define Y2_GPIO_NUM 11
+#define Y3_GPIO_NUM 9
+#define Y4_GPIO_NUM 8
+#define Y5_GPIO_NUM 10
+#define Y6_GPIO_NUM 12
+#define Y7_GPIO_NUM 18
+#define Y8_GPIO_NUM 17
+#define Y9_GPIO_NUM 16
+
+#define VSYNC_GPIO_NUM 6
+#define HREF_GPIO_NUM 7
+#define PCLK_GPIO_NUM 13
+
+#else
+#error "Camera model not selected"
+#endif

libraries/ESP32/examples/Camera/CameraWebServer/partitions.csv

@@ -0,0 +1,5 @@
+# Name,   Type,  SubType, Offset,   Size,    Flags
+nvs,      data,  nvs,     0x9000,   0x5000,
+otadata,  data,  ota,     0xe000,   0x2000,
+app0,     app,   ota_0,   0x10000,  0x3d0000,
+fr,       data,        ,  0x3e0000, 0x20000,

libraries/ESP32/examples/ChipID/GetChipID/GetChipID.ino

@@ -0,0 +1,30 @@
+/* The true ESP32 chip ID is essentially its MAC address.
+This sketch provides an alternate chip ID that matches 
+the output of the ESP.getChipId() function on ESP8266 
+(i.e. a 32-bit integer matching the last 3 bytes of 
+the MAC address. This is less unique than the 
+MAC address chip ID, but is helpful when you need 
+an identifier that can be no more than a 32-bit integer 
+(like for switch...case).
+
+created 2020-06-07 by cweinhofer
+with help from Cicicok */
+	
+uint32_t chipId = 0;
+
+void setup() {
+	Serial.begin(115200);
+}
+
+void loop() {
+	for(int i=0; i<17; i=i+8) {
+	  chipId |= ((ESP.getEfuseMac() >> (40 - i)) & 0xff) << i;
+	}
+
+	Serial.printf("ESP32 Chip model = %s Rev %d\n", ESP.getChipModel(), ESP.getChipRevision());
+	Serial.printf("This chip has %d cores\n", ESP.getChipCores());
+  Serial.print("Chip ID: "); Serial.println(chipId);
+  
+	delay(3000);
+
+}

libraries/ESP32/examples/DeepSleep/ExternalWakeUp/ExternalWakeUp.ino

@@ -0,0 +1,82 @@
+/*
+Deep Sleep with External Wake Up
+=====================================
+This code displays how to use deep sleep with
+an external trigger as a wake up source and how
+to store data in RTC memory to use it over reboots
+
+This code is under Public Domain License.
+
+Hardware Connections
+======================
+Push Button to GPIO 33 pulled down with a 10K Ohm
+resistor
+
+NOTE:
+======
+Only RTC IO can be used as a source for external wake
+source. They are pins: 0,2,4,12-15,25-27,32-39.
+
+Author:
+Pranav Cherukupalli <cherukupallip@gmail.com>
+*/
+
+#define BUTTON_PIN_BITMASK 0x200000000 // 2^33 in hex
+
+RTC_DATA_ATTR int bootCount = 0;
+
+/*
+Method to print the reason by which ESP32
+has been awaken from sleep
+*/
+void print_wakeup_reason(){
+  esp_sleep_wakeup_cause_t wakeup_reason;
+
+  wakeup_reason = esp_sleep_get_wakeup_cause();
+
+  switch(wakeup_reason)
+  {
+    case ESP_SLEEP_WAKEUP_EXT0 : Serial.println("Wakeup caused by external signal using RTC_IO"); break;
+    case ESP_SLEEP_WAKEUP_EXT1 : Serial.println("Wakeup caused by external signal using RTC_CNTL"); break;
+    case ESP_SLEEP_WAKEUP_TIMER : Serial.println("Wakeup caused by timer"); break;
+    case ESP_SLEEP_WAKEUP_TOUCHPAD : Serial.println("Wakeup caused by touchpad"); break;
+    case ESP_SLEEP_WAKEUP_ULP : Serial.println("Wakeup caused by ULP program"); break;
+    default : Serial.printf("Wakeup was not caused by deep sleep: %d\n",wakeup_reason); break;
+  }
+}
+
+void setup(){
+  Serial.begin(115200);
+  delay(1000); //Take some time to open up the Serial Monitor
+
+  //Increment boot number and print it every reboot
+  ++bootCount;
+  Serial.println("Boot number: " + String(bootCount));
+
+  //Print the wakeup reason for ESP32
+  print_wakeup_reason();
+
+  /*
+  First we configure the wake up source
+  We set our ESP32 to wake up for an external trigger.
+  There are two types for ESP32, ext0 and ext1 .
+  ext0 uses RTC_IO to wakeup thus requires RTC peripherals
+  to be on while ext1 uses RTC Controller so doesnt need
+  peripherals to be powered on.
+  Note that using internal pullups/pulldowns also requires
+  RTC peripherals to be turned on.
+  */
+  esp_sleep_enable_ext0_wakeup(GPIO_NUM_33,1); //1 = High, 0 = Low
+
+  //If you were to use ext1, you would use it like
+  //esp_sleep_enable_ext1_wakeup(BUTTON_PIN_BITMASK,ESP_EXT1_WAKEUP_ANY_HIGH);
+
+  //Go to sleep now
+  Serial.println("Going to sleep now");
+  esp_deep_sleep_start();
+  Serial.println("This will never be printed");
+}
+
+void loop(){
+  //This is not going to be called
+}

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

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

libraries/ESP32/examples/DeepSleep/TimerWakeUp/TimerWakeUp.ino

@@ -0,0 +1,94 @@
+/*
+Simple Deep Sleep with Timer Wake Up
+=====================================
+ESP32 offers a deep sleep mode for effective power
+saving as power is an important factor for IoT
+applications. In this mode CPUs, most of the RAM,
+and all the digital peripherals which are clocked
+from APB_CLK are powered off. The only parts of
+the chip which can still be powered on are:
+RTC controller, RTC peripherals ,and RTC memories
+
+This code displays the most basic deep sleep with
+a timer to wake it up and how to store data in
+RTC memory to use it over reboots
+
+This code is under Public Domain License.
+
+Author:
+Pranav Cherukupalli <cherukupallip@gmail.com>
+*/
+
+#define uS_TO_S_FACTOR 1000000ULL  /* Conversion factor for micro seconds to seconds */
+#define TIME_TO_SLEEP  5        /* Time ESP32 will go to sleep (in seconds) */
+
+RTC_DATA_ATTR int bootCount = 0;
+
+/*
+Method to print the reason by which ESP32
+has been awaken from sleep
+*/
+void print_wakeup_reason(){
+  esp_sleep_wakeup_cause_t wakeup_reason;
+
+  wakeup_reason = esp_sleep_get_wakeup_cause();
+
+  switch(wakeup_reason)
+  {
+    case ESP_SLEEP_WAKEUP_EXT0 : Serial.println("Wakeup caused by external signal using RTC_IO"); break;
+    case ESP_SLEEP_WAKEUP_EXT1 : Serial.println("Wakeup caused by external signal using RTC_CNTL"); break;
+    case ESP_SLEEP_WAKEUP_TIMER : Serial.println("Wakeup caused by timer"); break;
+    case ESP_SLEEP_WAKEUP_TOUCHPAD : Serial.println("Wakeup caused by touchpad"); break;
+    case ESP_SLEEP_WAKEUP_ULP : Serial.println("Wakeup caused by ULP program"); break;
+    default : Serial.printf("Wakeup was not caused by deep sleep: %d\n",wakeup_reason); break;
+  }
+}
+
+void setup(){
+  Serial.begin(115200);
+  delay(1000); //Take some time to open up the Serial Monitor
+
+  //Increment boot number and print it every reboot
+  ++bootCount;
+  Serial.println("Boot number: " + String(bootCount));
+
+  //Print the wakeup reason for ESP32
+  print_wakeup_reason();
+
+  /*
+  First we configure the wake up source
+  We set our ESP32 to wake up every 5 seconds
+  */
+  esp_sleep_enable_timer_wakeup(TIME_TO_SLEEP * uS_TO_S_FACTOR);
+  Serial.println("Setup ESP32 to sleep for every " + String(TIME_TO_SLEEP) +
+  " Seconds");
+
+  /*
+  Next we decide what all peripherals to shut down/keep on
+  By default, ESP32 will automatically power down the peripherals
+  not needed by the wakeup source, but if you want to be a poweruser
+  this is for you. Read in detail at the API docs
+  http://esp-idf.readthedocs.io/en/latest/api-reference/system/deep_sleep.html
+  Left the line commented as an example of how to configure peripherals.
+  The line below turns off all RTC peripherals in deep sleep.
+  */
+  //esp_deep_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_OFF);
+  //Serial.println("Configured all RTC Peripherals to be powered down in sleep");
+
+  /*
+  Now that we have setup a wake cause and if needed setup the
+  peripherals state in deep sleep, we can now start going to
+  deep sleep.
+  In the case that no wake up sources were provided but deep
+  sleep was started, it will sleep forever unless hardware
+  reset occurs.
+  */
+  Serial.println("Going to sleep now");
+  Serial.flush(); 
+  esp_deep_sleep_start();
+  Serial.println("This will never be printed");
+}
+
+void loop(){
+  //This is not going to be called
+}

libraries/ESP32/examples/DeepSleep/TouchWakeUp/TouchWakeUp.ino

@@ -0,0 +1,91 @@
+/*
+Deep Sleep with Touch Wake Up
+=====================================
+This code displays how to use deep sleep with
+a touch as a wake up source and how to store data in
+RTC memory to use it over reboots
+
+This code is under Public Domain License.
+
+Author:
+Pranav Cherukupalli <cherukupallip@gmail.com>
+*/
+
+#define Threshold 40 /* Greater the value, more the sensitivity */
+
+RTC_DATA_ATTR int bootCount = 0;
+touch_pad_t touchPin;
+/*
+Method to print the reason by which ESP32
+has been awaken from sleep
+*/
+void print_wakeup_reason(){
+  esp_sleep_wakeup_cause_t wakeup_reason;
+
+  wakeup_reason = esp_sleep_get_wakeup_cause();
+
+  switch(wakeup_reason)
+  {
+    case ESP_SLEEP_WAKEUP_EXT0 : Serial.println("Wakeup caused by external signal using RTC_IO"); break;
+    case ESP_SLEEP_WAKEUP_EXT1 : Serial.println("Wakeup caused by external signal using RTC_CNTL"); break;
+    case ESP_SLEEP_WAKEUP_TIMER : Serial.println("Wakeup caused by timer"); break;
+    case ESP_SLEEP_WAKEUP_TOUCHPAD : Serial.println("Wakeup caused by touchpad"); break;
+    case ESP_SLEEP_WAKEUP_ULP : Serial.println("Wakeup caused by ULP program"); break;
+    default : Serial.printf("Wakeup was not caused by deep sleep: %d\n",wakeup_reason); break;
+  }
+}
+
+/*
+Method to print the touchpad by which ESP32
+has been awaken from sleep
+*/
+void print_wakeup_touchpad(){
+  touchPin = esp_sleep_get_touchpad_wakeup_status();
+
+  switch(touchPin)
+  {
+    case 0  : Serial.println("Touch detected on GPIO 4"); break;
+    case 1  : Serial.println("Touch detected on GPIO 0"); break;
+    case 2  : Serial.println("Touch detected on GPIO 2"); break;
+    case 3  : Serial.println("Touch detected on GPIO 15"); break;
+    case 4  : Serial.println("Touch detected on GPIO 13"); break;
+    case 5  : Serial.println("Touch detected on GPIO 12"); break;
+    case 6  : Serial.println("Touch detected on GPIO 14"); break;
+    case 7  : Serial.println("Touch detected on GPIO 27"); break;
+    case 8  : Serial.println("Touch detected on GPIO 33"); break;
+    case 9  : Serial.println("Touch detected on GPIO 32"); break;
+    default : Serial.println("Wakeup not by touchpad"); break;
+  }
+}
+
+void callback(){
+  //placeholder callback function
+}
+
+void setup(){
+  Serial.begin(115200);
+  delay(1000); //Take some time to open up the Serial Monitor
+
+  //Increment boot number and print it every reboot
+  ++bootCount;
+  Serial.println("Boot number: " + String(bootCount));
+
+  //Print the wakeup reason for ESP32 and touchpad too
+  print_wakeup_reason();
+  print_wakeup_touchpad();
+
+  //Setup interrupt on Touch Pad 3 (GPIO15)
+  touchAttachInterrupt(T3, callback, Threshold);
+
+  //Configure Touchpad as wakeup source
+  esp_sleep_enable_touchpad_wakeup();
+
+  //Go to sleep now
+  Serial.println("Going to sleep now");
+  esp_deep_sleep_start();
+  Serial.println("This will never be printed");
+}
+
+void loop(){
+  //This will never be reached
+}

libraries/ESP32/examples/ESPNow/Basic/Master/Master.ino

@@ -0,0 +1,262 @@
+/**
+   ESPNOW - Basic communication - Master
+   Date: 26th September 2017
+   Author: Arvind Ravulavaru <https://github.com/arvindr21>
+   Purpose: ESPNow Communication between a Master ESP32 and a Slave ESP32
+   Description: This sketch consists of the code for the Master module.
+   Resources: (A bit outdated)
+   a. https://espressif.com/sites/default/files/documentation/esp-now_user_guide_en.pdf
+   b. http://www.esploradores.com/practica-6-conexion-esp-now/
+
+   << This Device Master >>
+
+   Flow: Master
+   Step 1 : ESPNow Init on Master and set it in STA mode
+   Step 2 : Start scanning for Slave ESP32 (we have added a prefix of `slave` to the SSID of slave for an easy setup)
+   Step 3 : Once found, add Slave as peer
+   Step 4 : Register for send callback
+   Step 5 : Start Transmitting data from Master to Slave
+
+   Flow: Slave
+   Step 1 : ESPNow Init on Slave
+   Step 2 : Update the SSID of Slave with a prefix of `slave`
+   Step 3 : Set Slave in AP mode
+   Step 4 : Register for receive callback and wait for data
+   Step 5 : Once data arrives, print it in the serial monitor
+
+   Note: Master and Slave have been defined to easily understand the setup.
+         Based on the ESPNOW API, there is no concept of Master and Slave.
+         Any devices can act as master or salve.
+*/
+
+#include <esp_now.h>
+#include <WiFi.h>
+#include <esp_wifi.h> // only for esp_wifi_set_channel()
+
+// Global copy of slave
+esp_now_peer_info_t slave;
+#define CHANNEL 1
+#define PRINTSCANRESULTS 0
+#define DELETEBEFOREPAIR 0
+
+// Init ESP Now with fallback
+void InitESPNow() {
+  WiFi.disconnect();
+  if (esp_now_init() == ESP_OK) {
+    Serial.println("ESPNow Init Success");
+  }
+  else {
+    Serial.println("ESPNow Init Failed");
+    // Retry InitESPNow, add a counte and then restart?
+    // InitESPNow();
+    // or Simply Restart
+    ESP.restart();
+  }
+}
+
+// Scan for slaves in AP mode
+void ScanForSlave() {
+  int16_t scanResults = WiFi.scanNetworks(false, false, false, 300, CHANNEL); // Scan only on one channel
+  // reset on each scan
+  bool slaveFound = 0;
+  memset(&slave, 0, sizeof(slave));
+
+  Serial.println("");
+  if (scanResults == 0) {
+    Serial.println("No WiFi devices in AP Mode found");
+  } else {
+    Serial.print("Found "); Serial.print(scanResults); Serial.println(" devices ");
+    for (int i = 0; i < scanResults; ++i) {
+      // Print SSID and RSSI for each device found
+      String SSID = WiFi.SSID(i);
+      int32_t RSSI = WiFi.RSSI(i);
+      String BSSIDstr = WiFi.BSSIDstr(i);
+
+      if (PRINTSCANRESULTS) {
+        Serial.print(i + 1);
+        Serial.print(": ");
+        Serial.print(SSID);
+        Serial.print(" (");
+        Serial.print(RSSI);
+        Serial.print(")");
+        Serial.println("");
+      }
+      delay(10);
+      // Check if the current device starts with `Slave`
+      if (SSID.indexOf("Slave") == 0) {
+        // SSID of interest
+        Serial.println("Found a Slave.");
+        Serial.print(i + 1); Serial.print(": "); Serial.print(SSID); Serial.print(" ["); Serial.print(BSSIDstr); Serial.print("]"); Serial.print(" ("); Serial.print(RSSI); Serial.print(")"); Serial.println("");
+        // Get BSSID => Mac Address of the Slave
+        int mac[6];
+        if ( 6 == sscanf(BSSIDstr.c_str(), "%x:%x:%x:%x:%x:%x",  &mac[0], &mac[1], &mac[2], &mac[3], &mac[4], &mac[5] ) ) {
+          for (int ii = 0; ii < 6; ++ii ) {
+            slave.peer_addr[ii] = (uint8_t) mac[ii];
+          }
+        }
+
+        slave.channel = CHANNEL; // pick a channel
+        slave.encrypt = 0; // no encryption
+
+        slaveFound = 1;
+        // we are planning to have only one slave in this example;
+        // Hence, break after we find one, to be a bit efficient
+        break;
+      }
+    }
+  }
+
+  if (slaveFound) {
+    Serial.println("Slave Found, processing..");
+  } else {
+    Serial.println("Slave Not Found, trying again.");
+  }
+
+  // clean up ram
+  WiFi.scanDelete();
+}
+
+// Check if the slave is already paired with the master.
+// If not, pair the slave with master
+bool manageSlave() {
+  if (slave.channel == CHANNEL) {
+    if (DELETEBEFOREPAIR) {
+      deletePeer();
+    }
+
+    Serial.print("Slave Status: ");
+    // check if the peer exists
+    bool exists = esp_now_is_peer_exist(slave.peer_addr);
+    if ( exists) {
+      // Slave already paired.
+      Serial.println("Already Paired");
+      return true;
+    } else {
+      // Slave not paired, attempt pair
+      esp_err_t addStatus = esp_now_add_peer(&slave);
+      if (addStatus == ESP_OK) {
+        // Pair success
+        Serial.println("Pair success");
+        return true;
+      } else if (addStatus == ESP_ERR_ESPNOW_NOT_INIT) {
+        // How did we get so far!!
+        Serial.println("ESPNOW Not Init");
+        return false;
+      } else if (addStatus == ESP_ERR_ESPNOW_ARG) {
+        Serial.println("Invalid Argument");
+        return false;
+      } else if (addStatus == ESP_ERR_ESPNOW_FULL) {
+        Serial.println("Peer list full");
+        return false;
+      } else if (addStatus == ESP_ERR_ESPNOW_NO_MEM) {
+        Serial.println("Out of memory");
+        return false;
+      } else if (addStatus == ESP_ERR_ESPNOW_EXIST) {
+        Serial.println("Peer Exists");
+        return true;
+      } else {
+        Serial.println("Not sure what happened");
+        return false;
+      }
+    }
+  } else {
+    // No slave found to process
+    Serial.println("No Slave found to process");
+    return false;
+  }
+}
+
+void deletePeer() {
+  esp_err_t delStatus = esp_now_del_peer(slave.peer_addr);
+  Serial.print("Slave Delete Status: ");
+  if (delStatus == ESP_OK) {
+    // Delete success
+    Serial.println("Success");
+  } else if (delStatus == ESP_ERR_ESPNOW_NOT_INIT) {
+    // How did we get so far!!
+    Serial.println("ESPNOW Not Init");
+  } else if (delStatus == ESP_ERR_ESPNOW_ARG) {
+    Serial.println("Invalid Argument");
+  } else if (delStatus == ESP_ERR_ESPNOW_NOT_FOUND) {
+    Serial.println("Peer not found.");
+  } else {
+    Serial.println("Not sure what happened");
+  }
+}
+
+uint8_t data = 0;
+// send data
+void sendData() {
+  data++;
+  const uint8_t *peer_addr = slave.peer_addr;
+  Serial.print("Sending: "); Serial.println(data);
+  esp_err_t result = esp_now_send(peer_addr, &data, sizeof(data));
+  Serial.print("Send Status: ");
+  if (result == ESP_OK) {
+    Serial.println("Success");
+  } else if (result == ESP_ERR_ESPNOW_NOT_INIT) {
+    // How did we get so far!!
+    Serial.println("ESPNOW not Init.");
+  } else if (result == ESP_ERR_ESPNOW_ARG) {
+    Serial.println("Invalid Argument");
+  } else if (result == ESP_ERR_ESPNOW_INTERNAL) {
+    Serial.println("Internal Error");
+  } else if (result == ESP_ERR_ESPNOW_NO_MEM) {
+    Serial.println("ESP_ERR_ESPNOW_NO_MEM");
+  } else if (result == ESP_ERR_ESPNOW_NOT_FOUND) {
+    Serial.println("Peer not found.");
+  } else {
+    Serial.println("Not sure what happened");
+  }
+}
+
+// callback when data is sent from Master to Slave
+void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
+  char macStr[18];
+  snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",
+           mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);
+  Serial.print("Last Packet Sent to: "); Serial.println(macStr);
+  Serial.print("Last Packet Send Status: "); Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
+}
+
+void setup() {
+  Serial.begin(115200);
+  //Set device in STA mode to begin with
+  WiFi.mode(WIFI_STA);
+  esp_wifi_set_channel(CHANNEL, WIFI_SECOND_CHAN_NONE);
+  Serial.println("ESPNow/Basic/Master Example");
+  // This is the mac address of the Master in Station Mode
+  Serial.print("STA MAC: "); Serial.println(WiFi.macAddress());
+  Serial.print("STA CHANNEL "); Serial.println(WiFi.channel());
+  // Init ESPNow with a fallback logic
+  InitESPNow();
+  // Once ESPNow is successfully Init, we will register for Send CB to
+  // get the status of Trasnmitted packet
+  esp_now_register_send_cb(OnDataSent);
+}
+
+void loop() {
+  // In the loop we scan for slave
+  ScanForSlave();
+  // If Slave is found, it would be populate in `slave` variable
+  // We will check if `slave` is defined and then we proceed further
+  if (slave.channel == CHANNEL) { // check if slave channel is defined
+    // `slave` is defined
+    // Add slave as peer if it has not been added already
+    bool isPaired = manageSlave();
+    if (isPaired) {
+      // pair success or already paired
+      // Send data to device
+      sendData();
+    } else {
+      // slave pair failed
+      Serial.println("Slave pair failed!");
+    }
+  }
+  else {
+    // No slave found to process
+  }
+
+  // wait for 3seconds to run the logic again
+  delay(3000);
+}

libraries/ESP32/examples/ESPNow/Basic/Slave/Slave.ino

@@ -0,0 +1,92 @@
+/**
+   ESPNOW - Basic communication - Slave
+   Date: 26th September 2017
+   Author: Arvind Ravulavaru <https://github.com/arvindr21>
+   Purpose: ESPNow Communication between a Master ESP32 and a Slave ESP32
+   Description: This sketch consists of the code for the Slave module.
+   Resources: (A bit outdated)
+   a. https://espressif.com/sites/default/files/documentation/esp-now_user_guide_en.pdf
+   b. http://www.esploradores.com/practica-6-conexion-esp-now/
+
+   << This Device Slave >>
+
+   Flow: Master
+   Step 1 : ESPNow Init on Master and set it in STA mode
+   Step 2 : Start scanning for Slave ESP32 (we have added a prefix of `slave` to the SSID of slave for an easy setup)
+   Step 3 : Once found, add Slave as peer
+   Step 4 : Register for send callback
+   Step 5 : Start Transmitting data from Master to Slave
+
+   Flow: Slave
+   Step 1 : ESPNow Init on Slave
+   Step 2 : Update the SSID of Slave with a prefix of `slave`
+   Step 3 : Set Slave in AP mode
+   Step 4 : Register for receive callback and wait for data
+   Step 5 : Once data arrives, print it in the serial monitor
+
+   Note: Master and Slave have been defined to easily understand the setup.
+         Based on the ESPNOW API, there is no concept of Master and Slave.
+         Any devices can act as master or salve.
+*/
+
+#include <esp_now.h>
+#include <WiFi.h>
+
+#define CHANNEL 1
+
+// Init ESP Now with fallback
+void InitESPNow() {
+  WiFi.disconnect();
+  if (esp_now_init() == ESP_OK) {
+    Serial.println("ESPNow Init Success");
+  }
+  else {
+    Serial.println("ESPNow Init Failed");
+    // Retry InitESPNow, add a counte and then restart?
+    // InitESPNow();
+    // or Simply Restart
+    ESP.restart();
+  }
+}
+
+// config AP SSID
+void configDeviceAP() {
+  const char *SSID = "Slave_1";
+  bool result = WiFi.softAP(SSID, "Slave_1_Password", CHANNEL, 0);
+  if (!result) {
+    Serial.println("AP Config failed.");
+  } else {
+    Serial.println("AP Config Success. Broadcasting with AP: " + String(SSID));
+    Serial.print("AP CHANNEL "); Serial.println(WiFi.channel());
+  }
+}
+
+void setup() {
+  Serial.begin(115200);
+  Serial.println("ESPNow/Basic/Slave Example");
+  //Set device in AP mode to begin with
+  WiFi.mode(WIFI_AP);
+  // configure device AP mode
+  configDeviceAP();
+  // This is the mac address of the Slave in AP Mode
+  Serial.print("AP MAC: "); Serial.println(WiFi.softAPmacAddress());
+  // Init ESPNow with a fallback logic
+  InitESPNow();
+  // Once ESPNow is successfully Init, we will register for recv CB to
+  // get recv packer info.
+  esp_now_register_recv_cb(OnDataRecv);
+}
+
+// callback when data is recv from Master
+void OnDataRecv(const uint8_t *mac_addr, const uint8_t *data, int data_len) {
+  char macStr[18];
+  snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",
+           mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);
+  Serial.print("Last Packet Recv from: "); Serial.println(macStr);
+  Serial.print("Last Packet Recv Data: "); Serial.println(*data);
+  Serial.println("");
+}
+
+void loop() {
+  // Chill
+}

libraries/ESP32/examples/ESPNow/Multi-Slave/Master/Master.ino

@@ -0,0 +1,244 @@
+/**
+   ESPNOW - Basic communication - Master
+   Date: 26th September 2017
+   Author: Arvind Ravulavaru <https://github.com/arvindr21>
+   Purpose: ESPNow Communication between a Master ESP32 and multiple ESP32 Slaves
+   Description: This sketch consists of the code for the Master module.
+   Resources: (A bit outdated)
+   a. https://espressif.com/sites/default/files/documentation/esp-now_user_guide_en.pdf
+   b. http://www.esploradores.com/practica-6-conexion-esp-now/
+
+   << This Device Master >>
+
+   Flow: Master
+   Step 1 : ESPNow Init on Master and set it in STA mode
+   Step 2 : Start scanning for Slave ESP32 (we have added a prefix of `slave` to the SSID of slave for an easy setup)
+   Step 3 : Once found, add Slave as peer
+   Step 4 : Register for send callback
+   Step 5 : Start Transmitting data from Master to Slave(s)
+
+   Flow: Slave
+   Step 1 : ESPNow Init on Slave
+   Step 2 : Update the SSID of Slave with a prefix of `slave`
+   Step 3 : Set Slave in AP mode
+   Step 4 : Register for receive callback and wait for data
+   Step 5 : Once data arrives, print it in the serial monitor
+
+   Note: Master and Slave have been defined to easily understand the setup.
+         Based on the ESPNOW API, there is no concept of Master and Slave.
+         Any devices can act as master or salve.
+
+
+  // Sample Serial log with 1 master & 2 slaves
+      Found 12 devices 
+      1: Slave:24:0A:C4:81:CF:A4 [24:0A:C4:81:CF:A5] (-44)
+      3: Slave:30:AE:A4:02:6D:CC [30:AE:A4:02:6D:CD] (-55)
+      2 Slave(s) found, processing..
+      Processing: 24:A:C4:81:CF:A5 Status: Already Paired
+      Processing: 30:AE:A4:2:6D:CD Status: Already Paired
+      Sending: 9
+      Send Status: Success
+      Last Packet Sent to: 24:0a:c4:81:cf:a5
+      Last Packet Send Status: Delivery Success
+      Send Status: Success
+      Last Packet Sent to: 30:ae:a4:02:6d:cd
+      Last Packet Send Status: Delivery Success
+
+*/
+
+#include <esp_now.h>
+#include <WiFi.h>
+
+// Global copy of slave
+#define NUMSLAVES 20
+esp_now_peer_info_t slaves[NUMSLAVES] = {};
+int SlaveCnt = 0;
+
+#define CHANNEL 3
+#define PRINTSCANRESULTS 0
+
+// Init ESP Now with fallback
+void InitESPNow() {
+  WiFi.disconnect();
+  if (esp_now_init() == ESP_OK) {
+    Serial.println("ESPNow Init Success");
+  }
+  else {
+    Serial.println("ESPNow Init Failed");
+    // Retry InitESPNow, add a counte and then restart?
+    // InitESPNow();
+    // or Simply Restart
+    ESP.restart();
+  }
+}
+
+// Scan for slaves in AP mode
+void ScanForSlave() {
+  int8_t scanResults = WiFi.scanNetworks();
+  //reset slaves
+  memset(slaves, 0, sizeof(slaves));
+  SlaveCnt = 0;
+  Serial.println("");
+  if (scanResults == 0) {
+    Serial.println("No WiFi devices in AP Mode found");
+  } else {
+    Serial.print("Found "); Serial.print(scanResults); Serial.println(" devices ");
+    for (int i = 0; i < scanResults; ++i) {
+      // Print SSID and RSSI for each device found
+      String SSID = WiFi.SSID(i);
+      int32_t RSSI = WiFi.RSSI(i);
+      String BSSIDstr = WiFi.BSSIDstr(i);
+
+      if (PRINTSCANRESULTS) {
+        Serial.print(i + 1); Serial.print(": "); Serial.print(SSID); Serial.print(" ["); Serial.print(BSSIDstr); Serial.print("]"); Serial.print(" ("); Serial.print(RSSI); Serial.print(")"); Serial.println("");
+      }
+      delay(10);
+      // Check if the current device starts with `Slave`
+      if (SSID.indexOf("Slave") == 0) {
+        // SSID of interest
+        Serial.print(i + 1); Serial.print(": "); Serial.print(SSID); Serial.print(" ["); Serial.print(BSSIDstr); Serial.print("]"); Serial.print(" ("); Serial.print(RSSI); Serial.print(")"); Serial.println("");
+        // Get BSSID => Mac Address of the Slave
+        int mac[6];
+
+        if ( 6 == sscanf(BSSIDstr.c_str(), "%x:%x:%x:%x:%x:%x",  &mac[0], &mac[1], &mac[2], &mac[3], &mac[4], &mac[5] ) ) {
+          for (int ii = 0; ii < 6; ++ii ) {
+            slaves[SlaveCnt].peer_addr[ii] = (uint8_t) mac[ii];
+          }
+        }
+        slaves[SlaveCnt].channel = CHANNEL; // pick a channel
+        slaves[SlaveCnt].encrypt = 0; // no encryption
+        SlaveCnt++;
+      }
+    }
+  }
+
+  if (SlaveCnt > 0) {
+    Serial.print(SlaveCnt); Serial.println(" Slave(s) found, processing..");
+  } else {
+    Serial.println("No Slave Found, trying again.");
+  }
+
+  // clean up ram
+  WiFi.scanDelete();
+}
+
+// Check if the slave is already paired with the master.
+// If not, pair the slave with master
+void manageSlave() {
+  if (SlaveCnt > 0) {
+    for (int i = 0; i < SlaveCnt; i++) {
+      Serial.print("Processing: ");
+      for (int ii = 0; ii < 6; ++ii ) {
+        Serial.print((uint8_t) slaves[i].peer_addr[ii], HEX);
+        if (ii != 5) Serial.print(":");
+      }
+      Serial.print(" Status: ");
+      // check if the peer exists
+      bool exists = esp_now_is_peer_exist(slaves[i].peer_addr);
+      if (exists) {
+        // Slave already paired.
+        Serial.println("Already Paired");
+      } else {
+        // Slave not paired, attempt pair
+        esp_err_t addStatus = esp_now_add_peer(&slaves[i]);
+        if (addStatus == ESP_OK) {
+          // Pair success
+          Serial.println("Pair success");
+        } else if (addStatus == ESP_ERR_ESPNOW_NOT_INIT) {
+          // How did we get so far!!
+          Serial.println("ESPNOW Not Init");
+        } else if (addStatus == ESP_ERR_ESPNOW_ARG) {
+          Serial.println("Add Peer - Invalid Argument");
+        } else if (addStatus == ESP_ERR_ESPNOW_FULL) {
+          Serial.println("Peer list full");
+        } else if (addStatus == ESP_ERR_ESPNOW_NO_MEM) {
+          Serial.println("Out of memory");
+        } else if (addStatus == ESP_ERR_ESPNOW_EXIST) {
+          Serial.println("Peer Exists");
+        } else {
+          Serial.println("Not sure what happened");
+        }
+        delay(100);
+      }
+    }
+  } else {
+    // No slave found to process
+    Serial.println("No Slave found to process");
+  }
+}
+
+
+uint8_t data = 0;
+// send data
+void sendData() {
+  data++;
+  for (int i = 0; i < SlaveCnt; i++) {
+    const uint8_t *peer_addr = slaves[i].peer_addr;
+    if (i == 0) { // print only for first slave
+      Serial.print("Sending: ");
+      Serial.println(data);
+    }
+    esp_err_t result = esp_now_send(peer_addr, &data, sizeof(data));
+    Serial.print("Send Status: ");
+    if (result == ESP_OK) {
+      Serial.println("Success");
+    } else if (result == ESP_ERR_ESPNOW_NOT_INIT) {
+      // How did we get so far!!
+      Serial.println("ESPNOW not Init.");
+    } else if (result == ESP_ERR_ESPNOW_ARG) {
+      Serial.println("Invalid Argument");
+    } else if (result == ESP_ERR_ESPNOW_INTERNAL) {
+      Serial.println("Internal Error");
+    } else if (result == ESP_ERR_ESPNOW_NO_MEM) {
+      Serial.println("ESP_ERR_ESPNOW_NO_MEM");
+    } else if (result == ESP_ERR_ESPNOW_NOT_FOUND) {
+      Serial.println("Peer not found.");
+    } else {
+      Serial.println("Not sure what happened");
+    }
+    delay(100);
+  }
+}
+
+// callback when data is sent from Master to Slave
+void OnDataSent(const uint8_t *mac_addr, esp_now_send_status_t status) {
+  char macStr[18];
+  snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",
+           mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);
+  Serial.print("Last Packet Sent to: "); Serial.println(macStr);
+  Serial.print("Last Packet Send Status: "); Serial.println(status == ESP_NOW_SEND_SUCCESS ? "Delivery Success" : "Delivery Fail");
+}
+
+void setup() {
+  Serial.begin(115200);
+  //Set device in STA mode to begin with
+  WiFi.mode(WIFI_STA);
+  Serial.println("ESPNow/Multi-Slave/Master Example");
+  // This is the mac address of the Master in Station Mode
+  Serial.print("STA MAC: "); Serial.println(WiFi.macAddress());
+  // Init ESPNow with a fallback logic
+  InitESPNow();
+  // Once ESPNow is successfully Init, we will register for Send CB to
+  // get the status of Trasnmitted packet
+  esp_now_register_send_cb(OnDataSent);
+}
+
+void loop() {
+  // In the loop we scan for slave
+  ScanForSlave();
+  // If Slave is found, it would be populate in `slave` variable
+  // We will check if `slave` is defined and then we proceed further
+  if (SlaveCnt > 0) { // check if slave channel is defined
+    // `slave` is defined
+    // Add slave as peer if it has not been added already
+    manageSlave();
+    // pair success or already paired
+    // Send data to device
+    sendData();
+  } else {
+    // No slave found to process
+  }
+
+  // wait for 3seconds to run the logic again
+  delay(1000);
+}

libraries/ESP32/examples/ESPNow/Multi-Slave/Slave/Slave.ino

@@ -0,0 +1,94 @@
+/**
+   ESPNOW - Basic communication - Slave
+   Date: 26th September 2017
+   Author: Arvind Ravulavaru <https://github.com/arvindr21>
+   Purpose: ESPNow Communication between a Master ESP32 and multiple ESP32 Slaves
+   Description: This sketch consists of the code for the Slave module.
+   Resources: (A bit outdated)
+   a. https://espressif.com/sites/default/files/documentation/esp-now_user_guide_en.pdf
+   b. http://www.esploradores.com/practica-6-conexion-esp-now/
+
+   << This Device Slave >>
+
+   Flow: Master
+   Step 1 : ESPNow Init on Master and set it in STA mode
+   Step 2 : Start scanning for Slave ESP32 (we have added a prefix of `slave` to the SSID of slave for an easy setup)
+   Step 3 : Once found, add Slave as peer
+   Step 4 : Register for send callback
+   Step 5 : Start Transmitting data from Master to Slave(s)
+
+   Flow: Slave
+   Step 1 : ESPNow Init on Slave
+   Step 2 : Update the SSID of Slave with a prefix of `slave`
+   Step 3 : Set Slave in AP mode
+   Step 4 : Register for receive callback and wait for data
+   Step 5 : Once data arrives, print it in the serial monitor
+
+   Note: Master and Slave have been defined to easily understand the setup.
+         Based on the ESPNOW API, there is no concept of Master and Slave.
+         Any devices can act as master or salve.
+*/
+
+#include <esp_now.h>
+#include <WiFi.h>
+
+#define CHANNEL 1
+
+// Init ESP Now with fallback
+void InitESPNow() {
+  WiFi.disconnect();
+  if (esp_now_init() == ESP_OK) {
+    Serial.println("ESPNow Init Success");
+  }
+  else {
+    Serial.println("ESPNow Init Failed");
+    // Retry InitESPNow, add a counte and then restart?
+    // InitESPNow();
+    // or Simply Restart
+    ESP.restart();
+  }
+}
+
+// config AP SSID
+void configDeviceAP() {
+  String Prefix = "Slave:";
+  String Mac = WiFi.macAddress();
+  String SSID = Prefix + Mac;
+  String Password = "123456789";
+  bool result = WiFi.softAP(SSID.c_str(), Password.c_str(), CHANNEL, 0);
+  if (!result) {
+    Serial.println("AP Config failed.");
+  } else {
+    Serial.println("AP Config Success. Broadcasting with AP: " + String(SSID));
+  }
+}
+
+void setup() {
+  Serial.begin(115200);
+  Serial.println("ESPNow/Basic/Slave Example");
+  //Set device in AP mode to begin with
+  WiFi.mode(WIFI_AP);
+  // configure device AP mode
+  configDeviceAP();
+  // This is the mac address of the Slave in AP Mode
+  Serial.print("AP MAC: "); Serial.println(WiFi.softAPmacAddress());
+  // Init ESPNow with a fallback logic
+  InitESPNow();
+  // Once ESPNow is successfully Init, we will register for recv CB to
+  // get recv packer info.
+  esp_now_register_recv_cb(OnDataRecv);
+}
+
+// callback when data is recv from Master
+void OnDataRecv(const uint8_t *mac_addr, const uint8_t *data, int data_len) {
+  char macStr[18];
+  snprintf(macStr, sizeof(macStr), "%02x:%02x:%02x:%02x:%02x:%02x",
+           mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);
+  Serial.print("Last Packet Recv from: "); Serial.println(macStr);
+  Serial.print("Last Packet Recv Data: "); Serial.println(*data);
+  Serial.println("");
+}
+
+void loop() {
+  // Chill
+}

libraries/ESP32/examples/FreeRTOS/FreeRTOS.ino

@@ -0,0 +1,97 @@
+#if CONFIG_FREERTOS_UNICORE
+#define ARDUINO_RUNNING_CORE 0
+#else
+#define ARDUINO_RUNNING_CORE 1
+#endif
+
+#ifndef LED_BUILTIN
+#define LED_BUILTIN 13
+#endif
+
+// define two tasks for Blink & AnalogRead
+void TaskBlink( void *pvParameters );
+void TaskAnalogReadA3( void *pvParameters );
+
+// the setup function runs once when you press reset or power the board
+void setup() {
+  
+  // initialize serial communication at 115200 bits per second:
+  Serial.begin(115200);
+  
+  // Now set up two tasks to run independently.
+  xTaskCreatePinnedToCore(
+    TaskBlink
+    ,  "TaskBlink"   // A name just for humans
+    ,  1024  // This stack size can be checked & adjusted by reading the Stack Highwater
+    ,  NULL
+    ,  2  // Priority, with 3 (configMAX_PRIORITIES - 1) being the highest, and 0 being the lowest.
+    ,  NULL 
+    ,  ARDUINO_RUNNING_CORE);
+
+  xTaskCreatePinnedToCore(
+    TaskAnalogReadA3
+    ,  "AnalogReadA3"
+    ,  1024  // Stack size
+    ,  NULL
+    ,  1  // Priority
+    ,  NULL 
+    ,  ARDUINO_RUNNING_CORE);
+
+  // Now the task scheduler, which takes over control of scheduling individual tasks, is automatically started.
+}
+
+void loop()
+{
+  // Empty. Things are done in Tasks.
+}
+
+/*--------------------------------------------------*/
+/*---------------------- Tasks ---------------------*/
+/*--------------------------------------------------*/
+
+void TaskBlink(void *pvParameters)  // This is a task.
+{
+  (void) pvParameters;
+
+/*
+  Blink
+  Turns on an LED on for one second, then off for one second, repeatedly.
+    
+  If you want to know what pin the on-board LED is connected to on your ESP32 model, check
+  the Technical Specs of your board.
+*/
+
+  // initialize digital LED_BUILTIN on pin 13 as an output.
+  pinMode(LED_BUILTIN, OUTPUT);
+
+  for (;;) // A Task shall never return or exit.
+  {
+    digitalWrite(LED_BUILTIN, HIGH);   // turn the LED on (HIGH is the voltage level)
+    vTaskDelay(100);  // one tick delay (15ms) in between reads for stability
+    digitalWrite(LED_BUILTIN, LOW);    // turn the LED off by making the voltage LOW
+    vTaskDelay(100);  // one tick delay (15ms) in between reads for stability
+  }
+}
+
+void TaskAnalogReadA3(void *pvParameters)  // This is a task.
+{
+  (void) pvParameters;
+  
+/*
+  AnalogReadSerial
+  Reads an analog input on pin A3, prints the result to the serial monitor.
+  Graphical representation is available using serial plotter (Tools > Serial Plotter menu)
+  Attach the center pin of a potentiometer to pin A3, and the outside pins to +5V and ground.
+
+  This example code is in the public domain.
+*/
+
+  for (;;)
+  {
+    // read the input on analog pin A3:
+    int sensorValueA3 = analogRead(A3);
+    // print out the value you read:
+    Serial.println(sensorValueA3);
+    vTaskDelay(10);  // one tick delay (15ms) in between reads for stability
+  }
+}

libraries/ESP32/examples/GPIO/BlinkRGB/BlinkRGB.ino

@@ -0,0 +1,39 @@
+/*
+  BlinkRGB
+
+  Demonstrates usage of onboard RGB LED on some ESP dev boards.
+
+  Calling digitalWrite(RGB_BUILTIN, HIGH) will use hidden RGB driver.
+    
+  RGBLedWrite demonstrates controll of each channel:
+  void neopixelWrite(uint8_t pin, uint8_t red_val, uint8_t green_val, uint8_t blue_val)
+
+  WARNING: After using digitalWrite to drive RGB LED it will be impossible to drive the same pin
+    with normal HIGH/LOW level
+*/
+//#define RGB_BRIGHTNESS 64 // Change white brightness (max 255)
+
+// the setup function runs once when you press reset or power the board
+
+void setup() {
+  // No need to initialize the RGB LED
+}
+
+// the loop function runs over and over again forever
+void loop() {
+#ifdef RGB_BUILTIN
+  digitalWrite(RGB_BUILTIN, HIGH);   // Turn the RGB LED white
+  delay(1000);
+  digitalWrite(RGB_BUILTIN, LOW);    // Turn the RGB LED off
+  delay(1000);
+
+  neopixelWrite(RGB_BUILTIN,RGB_BRIGHTNESS,0,0); // Red
+  delay(1000);
+  neopixelWrite(RGB_BUILTIN,0,RGB_BRIGHTNESS,0); // Green
+  delay(1000);
+  neopixelWrite(RGB_BUILTIN,0,0,RGB_BRIGHTNESS); // Blue
+  delay(1000);
+  neopixelWrite(RGB_BUILTIN,0,0,0); // Off / black
+  delay(1000);
+#endif
+}

libraries/ESP32/examples/GPIO/FunctionalInterrupt/FunctionalInterrupt.ino

@@ -0,0 +1,47 @@
+#include <Arduino.h>
+#include <FunctionalInterrupt.h>
+
+#define BUTTON1 16
+#define BUTTON2 17
+
+class Button
+{
+public:
+	Button(uint8_t reqPin) : PIN(reqPin){
+		pinMode(PIN, INPUT_PULLUP);
+		attachInterrupt(PIN, std::bind(&Button::isr,this), FALLING);
+	};
+	~Button() {
+		detachInterrupt(PIN);
+	}
+
+	void ARDUINO_ISR_ATTR isr() {
+		numberKeyPresses += 1;
+		pressed = true;
+	}
+
+	void checkPressed() {
+		if (pressed) {
+			Serial.printf("Button on pin %u has been pressed %u times\n", PIN, numberKeyPresses);
+			pressed = false;
+		}
+	}
+
+private:
+	const uint8_t PIN;
+    volatile uint32_t numberKeyPresses;
+    volatile bool pressed;
+};
+
+Button button1(BUTTON1);
+Button button2(BUTTON2);
+
+
+void setup() {
+    Serial.begin(115200);
+}
+
+void loop() {
+	button1.checkPressed();
+	button2.checkPressed();
+}

libraries/ESP32/examples/GPIO/GPIOInterrupt/GPIOInterrupt.ino

@@ -0,0 +1,45 @@
+#include <Arduino.h>
+
+struct Button {
+    const uint8_t PIN;
+    uint32_t numberKeyPresses;
+    bool pressed;
+};
+
+Button button1 = {23, 0, false};
+Button button2 = {18, 0, false};
+
+void ARDUINO_ISR_ATTR isr(void* arg) {
+    Button* s = static_cast<Button*>(arg);
+    s->numberKeyPresses += 1;
+    s->pressed = true;
+}
+
+void ARDUINO_ISR_ATTR isr() {
+    button2.numberKeyPresses += 1;
+    button2.pressed = true;
+}
+
+void setup() {
+    Serial.begin(115200);
+    pinMode(button1.PIN, INPUT_PULLUP);
+    attachInterruptArg(button1.PIN, isr, &button1, FALLING);
+    pinMode(button2.PIN, INPUT_PULLUP);
+    attachInterrupt(button2.PIN, isr, FALLING);
+}
+
+void loop() {
+    if (button1.pressed) {
+        Serial.printf("Button 1 has been pressed %u times\n", button1.numberKeyPresses);
+        button1.pressed = false;
+    }
+    if (button2.pressed) {
+        Serial.printf("Button 2 has been pressed %u times\n", button2.numberKeyPresses);
+        button2.pressed = false;
+    }
+    static uint32_t lastMillis = 0;
+    if (millis() - lastMillis > 10000) {
+      lastMillis = millis();
+      detachInterrupt(button1.PIN);
+    }
+}

libraries/ESP32/examples/HallSensor/HallSensor.ino

@@ -0,0 +1,15 @@
+//Simple sketch to access the internal hall effect detector on the esp32.
+//values can be quite low. 
+//Brian Degger / @sctv  
+int val = 0;
+void setup() {
+  Serial.begin(9600);
+    }
+
+void loop() {
+  // put your main code here, to run repeatedly:
+  val = hallRead();
+  // print the results to the serial monitor:
+  //Serial.print("sensor = ");
+  Serial.println(val);//to graph 
+}

libraries/ESP32/examples/I2S/HiFreq_ADC/HiFreq_ADC.ino

@@ -0,0 +1,133 @@
+/*
+  This example demonstrates I2S ADC capability to sample high frequency analog signals.
+  The PWM signal generated with ledc is only for ease of use when first trying out.
+  To sample the generated signal connect default pins 27(PWM) and 32(Sampling) together.
+  If you do not wish to generate PWM simply comment out the definition of constant GENERATE_PWM
+  Try to change the PWM_DUTY_PERCENT and see how to averaged value changes.
+
+  The maximum for I2S ADC sampling frequency is 5MHz (value 5000000), however there will be many values repeated because the real
+  sampling frequency is much lower -
+
+  By default this example will print values compatible with Arduino plotter
+  1. signal - all values
+  2. signal - averaged value
+
+  You can change the number of sample over which is the signal averaged by changing value of AVERAGE_EVERY_N_SAMPLES
+  If you comment the definition altogether the averaging will not be performed nor printed.
+
+  If you do not wish to print every value, simply comment definition of constant PRINT_ALL_VALUES
+
+  Note: ESP prints messages at startup which will pollute Arduino IDE Serial plotter legend.
+  To avoid this pollution, start the plotter after startup (op restart)
+*/
+#include <driver/i2s.h>
+
+// I2S
+#define I2S_SAMPLE_RATE (277777) // Max sampling frequency = 277.777 kHz
+#define ADC_INPUT (ADC1_CHANNEL_4) //pin 32
+#define I2S_DMA_BUF_LEN (1024)
+
+// PWM
+#define GENERATE_PWM
+#define OUTPUT_PIN (27)
+#define PWM_FREQUENCY ((I2S_SAMPLE_RATE)/4)
+#define PWM_DUTY_PERCENT (50)
+#define PWM_RESOLUTION_BITS (2) // Lower bit resolution enables higher frequency
+#define PWM_DUTY_VALUE ((((1<<(PWM_RESOLUTION_BITS)))*(PWM_DUTY_PERCENT))/100) // Duty value used for setup function based on resolution
+
+// Sample post processing
+#define PRINT_ALL_VALUES
+#define AVERAGE_EVERY_N_SAMPLES (100)
+
+void i2sInit(){
+  i2s_config_t i2s_config = {
+    .mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_RX | I2S_MODE_ADC_BUILT_IN),
+    .sample_rate =  I2S_SAMPLE_RATE,              // The format of the signal using ADC_BUILT_IN
+    .bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT, // is fixed at 12bit, stereo, MSB
+    .channel_format = I2S_CHANNEL_FMT_RIGHT_LEFT,
+    .communication_format = I2S_COMM_FORMAT_STAND_I2S,
+    .intr_alloc_flags = ESP_INTR_FLAG_LEVEL1,
+    .dma_buf_count = 8,
+    .dma_buf_len = I2S_DMA_BUF_LEN,
+    .use_apll = false,
+    .tx_desc_auto_clear = false,
+    .fixed_mclk = 0
+  };
+  Serial.printf("Attempting to setup I2S ADC with sampling frequency %d Hz\n", I2S_SAMPLE_RATE);
+  if(ESP_OK != i2s_driver_install(I2S_NUM_0, &i2s_config, 0, NULL)){
+    Serial.printf("Error installing I2S. Halt!");
+    while(1);
+  }
+  if(ESP_OK != i2s_set_adc_mode(ADC_UNIT_1, ADC_INPUT)){
+    Serial.printf("Error setting up ADC. Halt!");
+    while(1);
+  }
+  if(ESP_OK != adc1_config_channel_atten(ADC_INPUT, ADC_ATTEN_DB_11)){
+    Serial.printf("Error setting up ADC attenuation. Halt!");
+    while(1);
+  }
+
+  if(ESP_OK != i2s_adc_enable(I2S_NUM_0)){
+    Serial.printf("Error enabling ADC. Halt!");
+    while(1);
+  }
+  Serial.printf("I2S ADC setup ok\n");
+}
+
+void setup() {
+  Serial.begin(115200);
+
+#ifdef GENERATE_PWM
+  // PWM setup
+  Serial.printf("Setting up PWM: frequency = %d; resolution bits %d; Duty cycle = %d; duty value = %d, Output pin = %d\n", PWM_FREQUENCY, PWM_RESOLUTION_BITS, PWM_DUTY_PERCENT, PWM_DUTY_VALUE, OUTPUT_PIN);
+  uint32_t freq = ledcSetup(0, PWM_FREQUENCY, PWM_RESOLUTION_BITS);
+  if(freq != PWM_FREQUENCY){
+    Serial.printf("Error setting up PWM. Halt!");
+    while(1);
+  }
+  ledcAttachPin(OUTPUT_PIN, 0);
+  ledcWrite(0, PWM_DUTY_VALUE);
+  Serial.printf("PWM setup ok\n");
+#endif
+
+  // Initialize the I2S peripheral
+  i2sInit();
+}
+
+void loop(){
+// The 4 high bits are the channel, and the data is inverted
+  size_t bytes_read;
+  uint16_t buffer[I2S_DMA_BUF_LEN] = {0};
+
+#ifdef AVERAGE_EVERY_N_SAMPLES
+  uint32_t read_counter = 0;
+  uint32_t averaged_reading = 0;
+  uint64_t read_sum = 0;
+#endif
+
+  while(1){
+    i2s_read(I2S_NUM_0, &buffer, sizeof(buffer), &bytes_read, 15);
+    //Serial.printf("read %d Bytes\n", bytes_read);
+
+    for(int i = 0; i < bytes_read/2; ++i){
+#ifdef PRINT_ALL_VALUES
+      //Serial.printf("[%d] = %d\n", i, buffer[i] & 0x0FFF); // Print with indexes
+      Serial.printf("Signal:%d ", buffer[i] & 0x0FFF); // Print compatible with Arduino Plotter
+#endif
+#ifdef AVERAGE_EVERY_N_SAMPLES
+      read_sum += buffer[i] & 0x0FFF;
+      ++read_counter;
+      if(read_counter == AVERAGE_EVERY_N_SAMPLES){
+        averaged_reading = read_sum / AVERAGE_EVERY_N_SAMPLES;
+        //Serial.printf("averaged_reading = %d over %d samples\n", averaged_reading, read_counter); // Print with additional info
+        Serial.printf("Averaged_signal:%d", averaged_reading); // Print compatible with Arduino Plotter
+        read_counter = 0;
+        read_sum = 0;
+      }
+#endif
+#if defined(PRINT_ALL_VALUES) || defined (AVERAGE_EVERY_N_SAMPLES)
+      Serial.printf("\n");
+#endif
+    } // for
+  } // while
+}

libraries/ESP32/examples/RMT/RMTCallback/RMTCallback.ino

@@ -0,0 +1,67 @@
+#include "Arduino.h"
+#include "esp32-hal.h"
+
+extern "C" void receive_trampoline(uint32_t *data, size_t len, void * arg);
+
+class MyProcessor {
+  private:
+    rmt_obj_t* rmt_recv = NULL;
+    float realNanoTick;
+    uint32_t buff; // rolling buffer of most recent 32 bits.
+    int at = 0;
+
+  public:
+    MyProcessor(uint8_t pin, float nanoTicks) {
+      if ((rmt_recv = rmtInit(pin, RMT_RX_MODE, RMT_MEM_192)) == NULL)
+      {
+        Serial.println("init receiver failed\n");
+      }
+
+      realNanoTick = rmtSetTick(rmt_recv, nanoTicks);
+    };
+    void begin() {
+      rmtRead(rmt_recv, receive_trampoline, this);
+    };
+
+    void process(rmt_data_t *data, size_t len) {
+      for (int i = 0; len; len--) {
+        if (data[i].duration0 == 0)
+          break;
+        buff = (buff << 1) | (data[i].level0 ? 1 : 0);
+        i++;
+
+        if (data[i].duration1 == 0)
+          break;
+        buff = (buff << 1) | (data[i].level1 ? 1 : 0);
+        i++;
+      };
+    };
+    uint32_t val() {
+      return buff;
+    }
+};
+
+void receive_trampoline(uint32_t *data, size_t len, void * arg)
+{
+  MyProcessor * p = (MyProcessor *)arg;
+  p->process((rmt_data_t*) data, len);
+}
+
+// Attach 3 processors to GPIO 4, 5 and 10 with different tick/speeds.
+MyProcessor mp1 = MyProcessor(4, 1000);
+MyProcessor mp2 = MyProcessor(5, 1000);
+MyProcessor mp3 = MyProcessor(10, 500);
+
+void setup()
+{
+  Serial.begin(115200);
+  mp1.begin();
+  mp2.begin();
+  mp3.begin();
+}
+
+void loop()
+{
+  Serial.printf("GPIO 4: %08x 5: %08x 10: %08x\n", mp1.val(), mp2.val(), mp3.val());
+  delay(500);
+}

libraries/ESP32/examples/RMT/RMTLoopback/RMTLoopback.ino

@@ -0,0 +1,74 @@
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/event_groups.h"
+#include "Arduino.h"
+
+#include "esp32-hal.h"
+
+#if CONFIG_IDF_TARGET_ESP32C3
+// ESP32 C3 has only 2 channels for RX and 2 for TX, thus MAX RMT_MEM is 128
+#define RMT_TX_PIN 4
+#define RMT_RX_PIN 5
+#define RMT_MEM_RX RMT_MEM_128
+#else 
+#define RMT_TX_PIN 18
+#define RMT_RX_PIN 21
+#define RMT_MEM_RX RMT_MEM_192
+#endif
+
+rmt_data_t my_data[256];
+rmt_data_t data[256];
+
+rmt_obj_t* rmt_send = NULL;
+rmt_obj_t* rmt_recv = NULL;
+
+static EventGroupHandle_t events;
+
+void setup() 
+{
+    Serial.begin(115200);
+    events = xEventGroupCreate();
+    
+    if ((rmt_send = rmtInit(RMT_TX_PIN, RMT_TX_MODE, RMT_MEM_64)) == NULL)
+    {
+        Serial.println("init sender failed\n");
+    }
+    if ((rmt_recv = rmtInit(RMT_RX_PIN, RMT_RX_MODE, RMT_MEM_RX)) == NULL)
+    {
+        Serial.println("init receiver failed\n");
+    }
+
+    float realTick = rmtSetTick(rmt_send, 100);
+    printf("real tick set to: %fns\n", realTick);
+    // both will keep same tick 
+    realTick = rmtSetTick(rmt_recv, 100);
+}
+
+void loop() 
+{
+    // Init data
+    int i;
+    for (i=0; i<255; i++) {
+        data[i].val = 0x80010001 + ((i%13)<<16) + 13-(i%13);
+    }
+    data[255].val = 0;
+
+    // Start receiving
+    rmtReadAsync(rmt_recv, my_data, 100, events, false, 0);
+
+    // Send in continous mode
+    rmtWrite(rmt_send, data, 100);
+
+    // Wait for data
+    xEventGroupWaitBits(events, RMT_FLAG_RX_DONE, 1, 1, portMAX_DELAY);
+
+    // Printout the received data plus the original values
+    for (i=0; i<60; i++)
+    {
+        Serial.printf("%08x=%08x ", my_data[i].val, data[i].val );
+        if (!((i+1)%4)) Serial.println("\n");
+    }
+    Serial.println("\n");
+
+    delay(2000);
+}

libraries/ESP32/examples/RMT/RMTReadXJT/RMTReadXJT.ino

@@ -0,0 +1,203 @@
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/event_groups.h"
+#include "Arduino.h"
+
+#include "esp32-hal.h"
+
+//
+// Note: This example uses a FrSKY device communication 
+//          using XJT D12 protocol 
+//
+// ; 0 bit = 6us low/10us high
+// ; 1 bit = 14us low/10us high
+// ;
+// ; --------+       +----------+                 +----------+
+// ;         |       |          |                 |          |
+// ;         |   0   |          |        1        |          |
+// ;         |       |          |                 |          |
+// ;         |       |          |                 |          |
+// ;         +-------+          +-----------------+          +---------
+// ;
+// ;         |  6us      10us   |       14us          10us   |
+// ;         |-------|----------|-----------------|----------|--------
+// ;         |       16us       |            24us            |
+
+//  Typedef of received frame
+//  
+// ; 0x00 - Sync, 0x7E (sync header ID)
+// ; 0x01 - Rx ID, 0x?? (receiver ID number, 0x00-0x??)
+// ; 0x02 - Flags 1, 0x?? (used for failsafe and binding)
+// ; 0x03 - Flags 2, 0x00 (reserved)
+// ; 0x04-0x06, Channels 1/9 and 2/10
+// ; 0x07-0x09, Channels 3/11 and 4/12
+// ; 0x0A-0x0C, Channels 5/13 and 6/14
+// ; 0x0D-0x0F, Channels 7/15 and 8/16
+// ; 0x10 - 0x00, always zero
+// ; 0x11 - CRC-16 High
+// ; 0x12 - CRC-16 Low
+// ; 0x13 - Tail, 0x7E (tail ID)
+typedef union {
+        struct {
+                uint8_t head;//0x7E
+                uint8_t rxid;//Receiver Number
+                uint8_t flags;//Range:0x20, Bind:0x01
+                uint8_t reserved0;//0x00
+                union {
+                        struct {
+                                uint8_t ch0_l;
+                                uint8_t ch0_h:4;
+                                uint8_t ch1_l:4;
+                                uint8_t ch1_h;
+                        };
+                        uint8_t bytes[3];
+                } channels[4];
+                uint8_t reserved1;//0x00
+                uint8_t crc_h;
+                uint8_t crc_l;
+                uint8_t tail;//0x7E
+        };
+        uint8_t buffer[20];
+} xjt_packet_t;
+
+#define XJT_VALID(i) (i->level0 && !i->level1 && i->duration0 >= 8 && i->duration0 <= 11)
+
+rmt_obj_t* rmt_recv = NULL;
+
+static uint32_t *s_channels;
+static uint32_t channels[16];
+static uint8_t xjt_flags = 0x0;
+static uint8_t xjt_rxid = 0x0;
+
+static bool xjtReceiveBit(size_t index, bool bit){
+    static xjt_packet_t xjt;
+    static uint8_t xjt_bit_index = 8;
+    static uint8_t xht_byte_index = 0;
+    static uint8_t xht_ones = 0;
+
+    if(!index){
+        xjt_bit_index = 8;
+        xht_byte_index = 0;
+        xht_ones = 0;
+    }
+
+    if(xht_byte_index > 19){
+        //fail!
+        return false;
+    }
+    if(bit){
+        xht_ones++;
+        if(xht_ones > 5 && xht_byte_index && xht_byte_index < 19){
+            //fail!
+            return false;
+        }
+        //add bit
+        xjt.buffer[xht_byte_index] |= (1 << --xjt_bit_index);
+    } else if(xht_ones == 5 && xht_byte_index && xht_byte_index < 19){
+        xht_ones = 0;
+        //skip bit
+        return true;
+    } else {
+        xht_ones = 0;
+        //add bit
+        xjt.buffer[xht_byte_index] &= ~(1 << --xjt_bit_index);
+    }
+    if ((!xjt_bit_index) || (xjt_bit_index==1 && xht_byte_index==19) ) {
+        xjt_bit_index = 8;
+        if(!xht_byte_index && xjt.buffer[0] != 0x7E){
+            //fail!
+            return false;
+        }
+        xht_byte_index++;
+        if(xht_byte_index == 20){
+            //done
+            if(xjt.buffer[19] != 0x7E){
+                //fail!
+                return false;
+            }
+            //check crc?
+
+            xjt_flags = xjt.flags;
+            xjt_rxid = xjt.rxid;
+            for(int i=0; i<4; i++){
+                uint16_t ch0 = xjt.channels[i].ch0_l | ((uint16_t)(xjt.channels[i].ch0_h & 0x7) << 8);
+                ch0 = ((ch0 * 2) + 2452) / 3;
+                uint16_t ch1 = xjt.channels[i].ch1_l | ((uint16_t)(xjt.channels[i].ch1_h & 0x7F) << 4);
+                ch1 = ((ch1 * 2) + 2452) / 3;
+                uint8_t c0n = i*2;
+                if(xjt.channels[i].ch0_h & 0x8){
+                    c0n += 8;
+                }
+                uint8_t c1n = i*2+1;
+                if(xjt.channels[i].ch1_h & 0x80){
+                    c1n += 8;
+                }
+                s_channels[c0n] = ch0;
+                s_channels[c1n] = ch1;
+            }
+        }
+    }
+    return true;
+}
+
+void parseRmt(rmt_data_t* items, size_t len, uint32_t* channels){
+    bool valid = true;
+    rmt_data_t* it = NULL;
+
+    if (!channels)  {
+        log_e("Please provide data block for storing channel info");
+        return;
+    }
+    s_channels = channels;
+
+    it = &items[0];
+    for(size_t i = 0; i<len; i++){
+
+        if(!valid){
+            break;
+        }
+        it = &items[i];
+        if(XJT_VALID(it)){
+            if(it->duration1 >= 5 && it->duration1 <= 8){
+                valid = xjtReceiveBit(i, false);
+            } else if(it->duration1 >= 13 && it->duration1 <= 16){
+                valid = xjtReceiveBit(i, true);
+            } else {
+                valid = false;
+            }
+        } else if(!it->duration1 && !it->level1 && it->duration0 >= 5 && it->duration0 <= 8) {
+                    valid = xjtReceiveBit(i, false);
+
+        }
+    }
+}
+
+extern "C" void receive_data(uint32_t *data, size_t len, void * arg)
+{
+    parseRmt((rmt_data_t*) data, len, channels);
+}
+
+void setup() 
+{
+    Serial.begin(115200);
+    
+    // Initialize the channel to capture up to 192 items
+    if ((rmt_recv = rmtInit(21, RMT_RX_MODE, RMT_MEM_192)) == NULL)
+    {
+        Serial.println("init receiver failed\n");
+    }
+
+    // Setup 1us tick
+    float realTick = rmtSetTick(rmt_recv, 1000);
+    Serial.printf("real tick set to: %fns\n", realTick);
+
+    // Ask to start reading
+    rmtRead(rmt_recv, receive_data, NULL);
+}
+
+void loop() 
+{
+    // printout some of the channels
+    Serial.printf("%04x %04x %04x %04x\n", channels[0], channels[1], channels[2], channels[3]);
+    delay(500);
+}

libraries/ESP32/examples/RMT/RMTWriteNeoPixel/RMTWriteNeoPixel.ino

@@ -0,0 +1,100 @@
+#include "freertos/FreeRTOS.h"
+#include "freertos/task.h"
+#include "freertos/event_groups.h"
+#include "Arduino.h"
+
+#include "esp32-hal.h"
+
+// The effect seen in ESP32C3, ESP32S2 and ESP32S3 is like a Blink of RGB LED
+#if CONFIG_IDF_TARGET_ESP32S2
+#define BUILTIN_RGBLED_PIN   18
+#elif CONFIG_IDF_TARGET_ESP32S3
+#define BUILTIN_RGBLED_PIN   48
+#elif CONFIG_IDF_TARGET_ESP32C3
+#define BUILTIN_RGBLED_PIN   8
+#else
+#define BUILTIN_RGBLED_PIN   21   // ESP32 has no builtin RGB LED
+#endif
+
+#define NR_OF_LEDS   8*4
+#define NR_OF_ALL_BITS 24*NR_OF_LEDS
+
+//
+// Note: This example uses Neopixel LED board, 32 LEDs chained one
+//      after another, each RGB LED has its 24 bit value 
+//      for color configuration (8b for each color)
+//
+//      Bits encoded as pulses as follows:
+//
+//      "0":
+//         +-------+              +--
+//         |       |              |
+//         |       |              |
+//         |       |              |
+//      ---|       |--------------|
+//         +       +              +
+//         | 0.4us |   0.85 0us   |
+//
+//      "1":
+//         +-------------+       +--
+//         |             |       |
+//         |             |       |
+//         |             |       |
+//         |             |       |
+//      ---+             +-------+
+//         |    0.8us    | 0.4us |
+
+rmt_data_t led_data[NR_OF_ALL_BITS];
+
+rmt_obj_t* rmt_send = NULL;
+
+void setup() 
+{
+    Serial.begin(115200);
+    
+    if ((rmt_send = rmtInit(BUILTIN_RGBLED_PIN, RMT_TX_MODE, RMT_MEM_64)) == NULL)
+    {
+        Serial.println("init sender failed\n");
+    }
+
+    float realTick = rmtSetTick(rmt_send, 100);
+    Serial.printf("real tick set to: %fns\n", realTick);
+
+}
+
+int color[] =  { 0x55, 0x11, 0x77 };  // RGB value
+int led_index = 0;
+
+void loop() 
+{
+    // Init data with only one led ON
+    int led, col, bit;
+    int i=0;
+    for (led=0; led<NR_OF_LEDS; led++) {
+        for (col=0; col<3; col++ ) {
+            for (bit=0; bit<8; bit++){
+                if ( (color[col] & (1<<(7-bit))) && (led == led_index) ) {
+                    led_data[i].level0 = 1;
+                    led_data[i].duration0 = 8;
+                    led_data[i].level1 = 0;
+                    led_data[i].duration1 = 4;
+                } else {
+                    led_data[i].level0 = 1;
+                    led_data[i].duration0 = 4;
+                    led_data[i].level1 = 0;
+                    led_data[i].duration1 = 8;
+                }
+                i++;
+            }
+        }
+    }
+    // make the led travel in the pannel
+    if ((++led_index)>=NR_OF_LEDS) {
+        led_index = 0;
+    }
+
+    // Send the data
+    rmtWrite(rmt_send, led_data, NR_OF_ALL_BITS);
+
+    delay(100);
+}

libraries/ESP32/examples/ResetReason/ResetReason.ino

@@ -0,0 +1,161 @@
+/*
+*  Print last reset reason of ESP32
+*  =================================
+*
+*  Use either of the methods print_reset_reason
+*  or verbose_print_reset_reason to display the
+*  cause for the last reset of this device.
+*
+*  Public Domain License.
+*
+*  Author:
+*  Evandro Luis Copercini - 2017
+*/
+
+#ifdef ESP_IDF_VERSION_MAJOR // IDF 4+
+#if CONFIG_IDF_TARGET_ESP32 // ESP32/PICO-D4
+#include "esp32/rom/rtc.h"
+#elif CONFIG_IDF_TARGET_ESP32S2
+#include "esp32s2/rom/rtc.h"
+#elif CONFIG_IDF_TARGET_ESP32C3
+#include "esp32c3/rom/rtc.h"
+#elif CONFIG_IDF_TARGET_ESP32S3
+#include "esp32s3/rom/rtc.h"
+#else 
+#error Target CONFIG_IDF_TARGET is not supported
+#endif
+#else // ESP32 Before IDF 4.0
+#include "rom/rtc.h"
+#endif
+
+#define uS_TO_S_FACTOR 1000000  /* Conversion factor for micro seconds to seconds */
+
+void print_reset_reason(int reason)
+{
+  switch ( reason)
+  {
+    case 1 : Serial.println ("POWERON_RESET");break;          /**<1,  Vbat power on reset*/
+    case 3 : Serial.println ("SW_RESET");break;               /**<3,  Software reset digital core*/
+    case 4 : Serial.println ("OWDT_RESET");break;             /**<4,  Legacy watch dog reset digital core*/
+    case 5 : Serial.println ("DEEPSLEEP_RESET");break;        /**<5,  Deep Sleep reset digital core*/
+    case 6 : Serial.println ("SDIO_RESET");break;             /**<6,  Reset by SLC module, reset digital core*/
+    case 7 : Serial.println ("TG0WDT_SYS_RESET");break;       /**<7,  Timer Group0 Watch dog reset digital core*/
+    case 8 : Serial.println ("TG1WDT_SYS_RESET");break;       /**<8,  Timer Group1 Watch dog reset digital core*/
+    case 9 : Serial.println ("RTCWDT_SYS_RESET");break;       /**<9,  RTC Watch dog Reset digital core*/
+    case 10 : Serial.println ("INTRUSION_RESET");break;       /**<10, Instrusion tested to reset CPU*/
+    case 11 : Serial.println ("TGWDT_CPU_RESET");break;       /**<11, Time Group reset CPU*/
+    case 12 : Serial.println ("SW_CPU_RESET");break;          /**<12, Software reset CPU*/
+    case 13 : Serial.println ("RTCWDT_CPU_RESET");break;      /**<13, RTC Watch dog Reset CPU*/
+    case 14 : Serial.println ("EXT_CPU_RESET");break;         /**<14, for APP CPU, reseted by PRO CPU*/
+    case 15 : Serial.println ("RTCWDT_BROWN_OUT_RESET");break;/**<15, Reset when the vdd voltage is not stable*/
+    case 16 : Serial.println ("RTCWDT_RTC_RESET");break;      /**<16, RTC Watch dog reset digital core and rtc module*/
+    default : Serial.println ("NO_MEAN");
+  }
+}
+
+void verbose_print_reset_reason(int reason)
+{
+  switch ( reason)
+  {
+    case 1  : Serial.println ("Vbat power on reset");break;
+    case 3  : Serial.println ("Software reset digital core");break;
+    case 4  : Serial.println ("Legacy watch dog reset digital core");break;
+    case 5  : Serial.println ("Deep Sleep reset digital core");break;
+    case 6  : Serial.println ("Reset by SLC module, reset digital core");break;
+    case 7  : Serial.println ("Timer Group0 Watch dog reset digital core");break;
+    case 8  : Serial.println ("Timer Group1 Watch dog reset digital core");break;
+    case 9  : Serial.println ("RTC Watch dog Reset digital core");break;
+    case 10 : Serial.println ("Instrusion tested to reset CPU");break;
+    case 11 : Serial.println ("Time Group reset CPU");break;
+    case 12 : Serial.println ("Software reset CPU");break;
+    case 13 : Serial.println ("RTC Watch dog Reset CPU");break;
+    case 14 : Serial.println ("for APP CPU, reseted by PRO CPU");break;
+    case 15 : Serial.println ("Reset when the vdd voltage is not stable");break;
+    case 16 : Serial.println ("RTC Watch dog reset digital core and rtc module");break;
+    default : Serial.println ("NO_MEAN");
+  }
+}
+
+void setup() {
+  // put your setup code here, to run once:
+  Serial.begin(115200);
+  delay(2000);
+
+  Serial.println("CPU0 reset reason:");
+  print_reset_reason(rtc_get_reset_reason(0));
+  verbose_print_reset_reason(rtc_get_reset_reason(0));
+
+  Serial.println("CPU1 reset reason:");
+  print_reset_reason(rtc_get_reset_reason(1));
+  verbose_print_reset_reason(rtc_get_reset_reason(1));
+
+  // Set ESP32 to go to deep sleep to see a variation
+  // in the reset reason. Device will sleep for 5 seconds.
+  esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_OFF);
+  Serial.println("Going to sleep");
+  esp_deep_sleep(5 * uS_TO_S_FACTOR);
+}
+
+void loop() {
+  // put your main code here, to run repeatedly:
+
+}
+
+/*
+  Example Serial Log:
+  ====================
+
+rst:0x10 (RTCWDT_RTC_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
+configsip: 0, SPIWP:0x00
+clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
+mode:DIO, clock div:1
+load:0x3fff0008,len:8
+load:0x3fff0010,len:160
+load:0x40078000,len:10632
+load:0x40080000,len:252
+entry 0x40080034
+CPU0 reset reason:
+RTCWDT_RTC_RESET
+RTC Watch dog reset digital core and rtc module
+CPU1 reset reason:
+EXT_CPU_RESET
+for APP CPU, reseted by PRO CPU
+Going to sleep
+ets Jun  8 2016 00:22:57
+
+rst:0x5 (DEEPSLEEP_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
+configsip: 0, SPIWP:0x00
+clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
+mode:DIO, clock div:1
+load:0x3fff0008,len:8
+load:0x3fff0010,len:160
+load:0x40078000,len:10632
+load:0x40080000,len:252
+entry 0x40080034
+CPU0 reset reason:
+DEEPSLEEP_RESET
+Deep Sleep reset digital core
+CPU1 reset reason:
+EXT_CPU_RESET
+for APP CPU, reseted by PRO CPU
+Going to sleep
+ets Jun  8 2016 00:22:57
+
+rst:0x5 (DEEPSLEEP_RESET),boot:0x13 (SPI_FAST_FLASH_BOOT)
+configsip: 0, SPIWP:0x00
+clk_drv:0x00,q_drv:0x00,d_drv:0x00,cs0_drv:0x00,hd_drv:0x00,wp_drv:0x00
+mode:DIO, clock div:1
+load:0x3fff0008,len:8
+load:0x3fff0010,len:160
+load:0x40078000,len:10632
+load:0x40080000,len:252
+entry 0x40080034
+CPU0 reset reason:
+DEEPSLEEP_RESET
+Deep Sleep reset digital core
+CPU1 reset reason:
+EXT_CPU_RESET
+for APP CPU, reseted by PRO CPU
+Going to sleep
+
+*/

libraries/ESP32/examples/Time/SimpleTime/SimpleTime.ino

@@ -0,0 +1,78 @@
+#include <WiFi.h>
+#include "time.h"
+#include "sntp.h"
+
+const char* ssid       = "YOUR_SSID";
+const char* password   = "YOUR_PASS";
+
+const char* ntpServer1 = "pool.ntp.org";
+const char* ntpServer2 = "time.nist.gov";
+const long  gmtOffset_sec = 3600;
+const int   daylightOffset_sec = 3600;
+
+const char* time_zone = "CET-1CEST,M3.5.0,M10.5.0/3";  // TimeZone rule for Europe/Rome including daylight adjustment rules (optional)
+
+void printLocalTime()
+{
+  struct tm timeinfo;
+  if(!getLocalTime(&timeinfo)){
+    Serial.println("No time available (yet)");
+    return;
+  }
+  Serial.println(&timeinfo, "%A, %B %d %Y %H:%M:%S");
+}
+
+// Callback function (get's called when time adjusts via NTP)
+void timeavailable(struct timeval *t)
+{
+  Serial.println("Got time adjustment from NTP!");
+  printLocalTime();
+}
+
+void setup()
+{
+  Serial.begin(115200);
+
+  // set notification call-back function
+  sntp_set_time_sync_notification_cb( timeavailable );
+
+  /**
+   * NTP server address could be aquired via DHCP,
+   *
+   * NOTE: This call should be made BEFORE esp32 aquires IP address via DHCP,
+   * otherwise SNTP option 42 would be rejected by default.
+   * NOTE: configTime() function call if made AFTER DHCP-client run
+   * will OVERRIDE aquired NTP server address
+   */
+  sntp_servermode_dhcp(1);    // (optional)
+
+  /**
+   * This will set configured ntp servers and constant TimeZone/daylightOffset
+   * should be OK if your time zone does not need to adjust daylightOffset twice a year,
+   * in such a case time adjustment won't be handled automagicaly.
+   */
+  configTime(gmtOffset_sec, daylightOffset_sec, ntpServer1, ntpServer2);
+
+  /**
+   * A more convenient approach to handle TimeZones with daylightOffset 
+   * would be to specify a environmnet variable with TimeZone definition including daylight adjustmnet rules.
+   * A list of rules for your zone could be obtained from https://github.com/esp8266/Arduino/blob/master/cores/esp8266/TZ.h
+   */
+  //configTzTime(time_zone, ntpServer1, ntpServer2);
+
+  //connect to WiFi
+  Serial.printf("Connecting to %s ", ssid);
+  WiFi.begin(ssid, password);
+  while (WiFi.status() != WL_CONNECTED) {
+      delay(500);
+      Serial.print(".");
+  }
+  Serial.println(" CONNECTED");
+
+}
+
+void loop()
+{
+  delay(5000);
+  printLocalTime();     // it will take some time to sync time :)
+}

libraries/ESP32/examples/Timer/RepeatTimer/RepeatTimer.ino

@@ -0,0 +1,82 @@
+/*
+ Repeat timer example
+
+ This example shows how to use hardware timer in ESP32. The timer calls onTimer
+ function every second. The timer can be stopped with button attached to PIN 0
+ (IO0).
+
+ This example code is in the public domain.
+ */
+
+// Stop button is attached to PIN 0 (IO0)
+#define BTN_STOP_ALARM    0
+
+hw_timer_t * timer = NULL;
+volatile SemaphoreHandle_t timerSemaphore;
+portMUX_TYPE timerMux = portMUX_INITIALIZER_UNLOCKED;
+
+volatile uint32_t isrCounter = 0;
+volatile uint32_t lastIsrAt = 0;
+
+void ARDUINO_ISR_ATTR onTimer(){
+  // Increment the counter and set the time of ISR
+  portENTER_CRITICAL_ISR(&timerMux);
+  isrCounter++;
+  lastIsrAt = millis();
+  portEXIT_CRITICAL_ISR(&timerMux);
+  // Give a semaphore that we can check in the loop
+  xSemaphoreGiveFromISR(timerSemaphore, NULL);
+  // It is safe to use digitalRead/Write here if you want to toggle an output
+}
+
+void setup() {
+  Serial.begin(115200);
+
+  // Set BTN_STOP_ALARM to input mode
+  pinMode(BTN_STOP_ALARM, INPUT);
+
+  // Create semaphore to inform us when the timer has fired
+  timerSemaphore = xSemaphoreCreateBinary();
+
+  // Use 1st timer of 4 (counted from zero).
+  // Set 80 divider for prescaler (see ESP32 Technical Reference Manual for more
+  // info).
+  timer = timerBegin(0, 80, true);
+
+  // Attach onTimer function to our timer.
+  timerAttachInterrupt(timer, &onTimer, true);
+
+  // Set alarm to call onTimer function every second (value in microseconds).
+  // Repeat the alarm (third parameter)
+  timerAlarmWrite(timer, 1000000, true);
+
+  // Start an alarm
+  timerAlarmEnable(timer);
+}
+
+void loop() {
+  // If Timer has fired
+  if (xSemaphoreTake(timerSemaphore, 0) == pdTRUE){
+    uint32_t isrCount = 0, isrTime = 0;
+    // Read the interrupt count and time
+    portENTER_CRITICAL(&timerMux);
+    isrCount = isrCounter;
+    isrTime = lastIsrAt;
+    portEXIT_CRITICAL(&timerMux);
+    // Print it
+    Serial.print("onTimer no. ");
+    Serial.print(isrCount);
+    Serial.print(" at ");
+    Serial.print(isrTime);
+    Serial.println(" ms");
+  }
+  // If button is pressed
+  if (digitalRead(BTN_STOP_ALARM) == LOW) {
+    // If timer is still running
+    if (timer) {
+      // Stop and free timer
+      timerEnd(timer);
+      timer = NULL;
+    }
+  }
+}

libraries/ESP32/examples/Timer/WatchdogTimer/WatchdogTimer.ino

@@ -0,0 +1,39 @@
+#include "esp_system.h"
+
+const int button = 0;         //gpio to use to trigger delay
+const int wdtTimeout = 3000;  //time in ms to trigger the watchdog
+hw_timer_t *timer = NULL;
+
+void ARDUINO_ISR_ATTR resetModule() {
+  ets_printf("reboot\n");
+  esp_restart();
+}
+
+void setup() {
+  Serial.begin(115200);
+  Serial.println();
+  Serial.println("running setup");
+
+  pinMode(button, INPUT_PULLUP);                    //init control pin
+  timer = timerBegin(0, 80, true);                  //timer 0, div 80
+  timerAttachInterrupt(timer, &resetModule, true);  //attach callback
+  timerAlarmWrite(timer, wdtTimeout * 1000, false); //set time in us
+  timerAlarmEnable(timer);                          //enable interrupt
+}
+
+void loop() {
+  Serial.println("running main loop");
+
+  timerWrite(timer, 0); //reset timer (feed watchdog)
+  long loopTime = millis();
+  //while button is pressed, delay up to 3 seconds to trigger the timer
+  while (!digitalRead(button)) {
+    Serial.println("button pressed");
+    delay(500);
+  }
+  delay(1000); //simulate work
+  loopTime = millis() - loopTime;
+  
+  Serial.print("loop time is = ");
+  Serial.println(loopTime); //should be under 3000
+}

libraries/ESP32/examples/Touch/TouchButton/TouchButton.ino

@@ -0,0 +1,46 @@
+/*
+
+This is an example how to use Touch Intrrerupts
+The sketh will tell when it is touched and then relesased as like a push-button
+
+This method based on touchInterruptSetThresholdDirection() is only available for ESP32
+*/
+
+#include "Arduino.h"
+
+int threshold = 40;
+bool touchActive = false;
+bool lastTouchActive = false;
+bool testingLower = true;
+
+void gotTouchEvent(){
+  if (lastTouchActive != testingLower) {
+    touchActive = !touchActive;
+    testingLower = !testingLower;
+    // Touch ISR will be inverted: Lower <--> Higher than the Threshold after ISR event is noticed
+    touchInterruptSetThresholdDirection(testingLower);
+  }
+}
+
+void setup() {
+  Serial.begin(115200);
+  delay(1000); // give me time to bring up serial monitor
+  Serial.println("ESP32 Touch Interrupt Test");
+  touchAttachInterrupt(T2, gotTouchEvent, threshold);
+
+  // Touch ISR will be activated when touchRead is lower than the Threshold
+  touchInterruptSetThresholdDirection(testingLower);
+}
+
+void loop(){
+  if(lastTouchActive != touchActive){
+    lastTouchActive = touchActive;
+    if (touchActive) {
+      Serial.println("  ---- Touch was Pressed");
+    } else {
+      Serial.println("  ---- Touch was Released");
+    }
+  }
+  Serial.printf("T2 pin2 = %d \n", touchRead(T2));
+  delay(125);
+}

libraries/ESP32/examples/Touch/TouchButtonV2/TouchButtonV2.ino

@@ -0,0 +1,51 @@
+/*
+
+This is an example how to use Touch Intrrerupts
+The sketh will tell when it is touched and then relesased as like a push-button
+
+This method based on touchInterruptGetLastStatus() is only available for ESP32 S2 and S3
+*/
+
+#include "Arduino.h"
+
+int threshold = 1500;   // ESP32S2 
+bool touch1detected = false;
+bool touch2detected = false;
+
+void gotTouch1() {
+  touch1detected = true;
+}
+
+void gotTouch2() {
+  touch2detected = true;
+}
+
+void setup() {
+  Serial.begin(115200);
+  delay(1000); // give me time to bring up serial monitor
+
+  Serial.println("\n ESP32 Touch Interrupt Test\n");
+  touchAttachInterrupt(T1, gotTouch1, threshold); 
+  touchAttachInterrupt(T2, gotTouch2, threshold);
+}
+
+void loop() {
+  if (touch1detected) {
+    touch1detected = false;
+    if (touchInterruptGetLastStatus(T1)) {
+        Serial.println(" --- T1 Touched");
+    } else {
+        Serial.println(" --- T1 Released");
+    }
+  }
+  if (touch2detected) {
+    touch2detected = false;
+    if (touchInterruptGetLastStatus(T2)) {
+        Serial.println(" --- T2 Touched");
+    } else {
+        Serial.println(" --- T2 Released");
+    }
+  }
+
+  delay(80);
+}

libraries/ESP32/examples/Touch/TouchInterrupt/TouchInterrupt.ino

@@ -0,0 +1,35 @@
+/*
+This is an example how to use Touch Intrrerupts
+The bigger the threshold, the more sensible is the touch
+*/
+
+int threshold = 40;
+bool touch1detected = false;
+bool touch2detected = false;
+
+void gotTouch1(){
+ touch1detected = true;
+}
+
+void gotTouch2(){
+ touch2detected = true;
+}
+
+void setup() {
+  Serial.begin(115200);
+  delay(1000); // give me time to bring up serial monitor
+  Serial.println("ESP32 Touch Interrupt Test");
+  touchAttachInterrupt(T2, gotTouch1, threshold);
+  touchAttachInterrupt(T3, gotTouch2, threshold);
+}
+
+void loop(){
+  if(touch1detected){
+    touch1detected = false;
+    Serial.println("Touch 1 detected");
+  }
+  if(touch2detected){
+    touch2detected = false;
+    Serial.println("Touch 2 detected");
+  }
+}

libraries/ESP32/examples/Touch/TouchRead/TouchRead.ino

@@ -0,0 +1,15 @@
+// ESP32 Touch Test
+// Just test touch pin - Touch0 is T0 which is on GPIO 4.
+
+void setup()
+{
+  Serial.begin(115200);
+  delay(1000); // give me time to bring up serial monitor
+  Serial.println("ESP32 Touch Test");
+}
+
+void loop()
+{
+  Serial.println(touchRead(T1));  // get value using T0
+  delay(1000);
+}