ESP32 Arduino Core

https://docs.espressif.com/projects/arduino-esp32/en/latest
Admin
This documentation provides comprehensive information for the ESP32 Arduino Core, enabling users to...
Tokens:400,259
Snippets:4,405
Trust Score:10
Update:1 month ago
Show doc for...
Tokens:
Raw
### Real World Example: Setup function using Preferences

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/tutorials/preferences.html

An example setup() function that initializes system configuration based on whether it's the first run or a subsequent run, using Preferences to store and retrieve settings.

```cpp
#include <Preferences.h>

#define RW_MODE false
#define RO_MODE true

Preferences stcPrefs;

void setup() {

   // not the complete setup(), but in setup(), include this...

   stcPrefs.begin("STCPrefs", RO_MODE);           // Open our namespace (or create it
                                                  //  if it doesn't exist) in RO mode.

   bool tpInit = stcPrefs.isKey("nvsInit");       // Test for the existence
                                                  //  of the "already initialized" key.

   if (tpInit == false) {
      // If tpInit is 'false', the key "nvsInit" does not yet exist therefore this
      //  must be our first-time run. We need to set up our Preferences namespace keys. So...
      stcPrefs.end();                             // close the namespace in RO mode and...
      stcPrefs.begin("STCPrefs", RW_MODE);        //  reopen it in RW mode.


      // The .begin() method created the "STCPrefs" namespace and since this is our
      //  first-time run we will create
      //  our keys and store the initial "factory default" values.
      stcPrefs.putUChar("curBright", 10);
      stcPrefs.putString("talChan", "one");
      stcPrefs.putLong("talMax", -220226);
      stcPrefs.putBool("ctMde", true);

      stcPrefs.putBool("nvsInit", true);          // Create the "already initialized"
                                                  //  key and store a value.

      // The "factory defaults" are created and stored so...
      stcPrefs.end();                             // Close the namespace in RW mode and...
      stcPrefs.begin("STCPrefs", RO_MODE);        //  reopen it in RO mode so the setup code
                                                  //  outside this first-time run 'if' block
                                                  //  can retrieve the run-time values
                                                  //  from the "STCPrefs" namespace.
   }

   // Retrieve the operational parameters from the namespace
   //  and save them into their run-time variables.
   currentBrightness = stcPrefs.getUChar("curBright");  //
   tChannel = stcPrefs.getString("talChan");            //   The LHS variables were defined
   tChanMax = stcPrefs.getLong("talMax");               //   earlier in the sketch.
   ctMode = stcPrefs.getBool("ctMde");                  //

   // All done. Last run state (or the factory default) is now restored.
   stcPrefs.end();                                      // Close our preferences namespace.

   // Carry on with the rest of your setup code...

   // When the sketch is running, it updates any changes to an operational parameter
   //  to the appropriate key-value pair in the namespace.

}
```

--------------------------------

### Joiner implementation example

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/openthread/openthread_core.html

Demonstrates the sequence of calls to start the stack, configure the channel, and perform the join operation.

```cpp
OThread.begin(false);
OThread.setChannel(15);
OThread.networkInterfaceUp();

otError err = OThread.startJoiner("J01NME");
if (err == OT_ERROR_NONE) {
    OThread.start();                 // enable Thread with provisioned dataset
} else {
    Serial.printf("Join failed: %d\r\n", err);
}
```

--------------------------------

### Quick start: Advertise a service with OThreadDNSSD

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/openthread/openthread_dnssd.html

This example demonstrates how to initialize the OpenThread stack, configure the network dataset, and advertise a service using OThreadDNSSD.

```cpp
#include <OThread.h>
#include <OThreadDNSSD.h>

void setup() {
  Serial.begin(115200);
  OThread.begin(false);
  // Set Network Key to match the OTBR; other dataset fields are learned on attach.
  DataSet ds;
  ds.clear();
  ds.setNetworkKey(/* OTBR network key */);
  OThread.commitDataSet(ds);
  OThread.networkInterfaceUp();
  OThread.start();
  // ... wait until attached ...

  if (!OThreadDNSSD.begin("sensor-1")) {
    Serial.println("OThreadDNSSD.begin failed");
    while (true) {
      delay(1000);  // do not return from setup() — loop() would still run
    }
  }
  OThreadDNSSD.addService("ot", "udp", 12345);
  OThreadDNSSD.addServiceTxt("ot", "udp", "path", "/status");

  if (OThreadDNSSD.waitForAnnounce(30000)) {
    Serial.println("Service announced");
  } else {
    Serial.println("Announce timed out (no SRP server yet?) — keep polling");
  }
}

void loop() {
  delay(5000);
  Serial.printf("announceComplete=%d\r\n", OThreadDNSSD.isAnnounceComplete());
}
```

--------------------------------

### Basic Thread Network Setup

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/openthread/openthread_core.html

Initializes the OpenThread stack, configures a new dataset with a network name and key, and starts the network interface. The device waits until it is no longer in the detached state before printing network information.

```cpp
#include <OThread.h>

void setup() {
    Serial.begin(115200);

    // Initialize OpenThread stack
    OpenThread::begin();

    // Wait for OpenThread to be ready
    while (!OThread) {
        delay(100);
    }

    // Create and configure dataset
    DataSet dataset;
    dataset.initNew();
    dataset.setNetworkName("MyThreadNetwork");
    dataset.setChannel(15);

    // Set network key (16 bytes)
    uint8_t networkKey[16] = {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77,
                              0x88, 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff};
    dataset.setNetworkKey(networkKey);

    // Apply dataset and start network
    OThread.commitDataSet(dataset);
    OThread.networkInterfaceUp();
    OThread.start();

    // Wait for network to be ready
    while (OpenThread::otGetDeviceRole() == OT_ROLE_DETACHED) {
        delay(100);
    }

    // Print network information
    OpenThread::otPrintNetworkInformation(Serial);

    // Get and print addresses
    Serial.printf("Mesh Local EID: %s\r\n", OThread.getMeshLocalEid().toString().c_str());
    Serial.printf("RLOC: %s\r\n", OThread.getRloc().toString().c_str());
    Serial.printf("RLOC16: 0x%04x\r\n", OThread.getRloc16());
}
```

--------------------------------

### Matter Color Light Implementation

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/matter/ep_color_light.html

A complete example showing the setup of a Matter Color Light, including state persistence, LED control, and callback registration for attribute changes.

```cpp
// Copyright 2025 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at

//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Matter Manager
#include <Arduino.h>
#include <Matter.h>
#if !CONFIG_ENABLE_CHIPOBLE
// if the device can be commissioned using BLE, WiFi is not used - save flash space
#include <WiFi.h>
#endif
#include <Preferences.h>

// List of Matter Endpoints for this Node
// Color Light Endpoint
MatterColorLight ColorLight;

// CONFIG_ENABLE_CHIPOBLE is enabled when BLE is used to commission the Matter Network
#if !CONFIG_ENABLE_CHIPOBLE
// WiFi is manually set and started
const char *ssid = "your-ssid";          // Change this to your WiFi SSID
const char *password = "your-password";  // Change this to your WiFi password
#endif

// it will keep last OnOff & HSV Color state stored, using Preferences
Preferences matterPref;
const char *onOffPrefKey = "OnOff";
const char *hsvColorPrefKey = "HSV";

// set your board RGB LED pin here
#ifdef RGB_BUILTIN
const uint8_t ledPin = RGB_BUILTIN;
#else
const uint8_t ledPin = 2;  // Set your pin here if your board has not defined LED_BUILTIN
#warning "Do not forget to set the RGB LED pin"
#endif

// set your board USER BUTTON pin here
const uint8_t buttonPin = BOOT_PIN;  // Set your pin here. Using BOOT Button.

// Button control
uint32_t button_time_stamp = 0;                // debouncing control
bool button_state = false;                     // false = released | true = pressed
const uint32_t debouceTime = 250;              // button debouncing time (ms)
const uint32_t decommissioningTimeout = 5000;  // keep the button pressed for 5s, or longer, to decommission

// Set the RGB LED Light based on the current state of the Color Light
bool setLightState(bool state, espHsvColor_t colorHSV) {

  if (state) {
#ifdef RGB_BUILTIN
    espRgbColor_t rgbColor = espHsvColorToRgbColor(colorHSV);
    // set the RGB LED
    rgbLedWrite(ledPin, rgbColor.r, rgbColor.g, rgbColor.b);
#else
    // No Color RGB LED, just use the HSV value (brightness) to control the LED
    analogWrite(ledPin, colorHSV.v);
#endif
  } else {
#ifndef RGB_BUILTIN
    // after analogWrite(), it is necessary to set the GPIO to digital mode first
    pinMode(ledPin, OUTPUT);
#endif
    digitalWrite(ledPin, LOW);
  }
  // store last HSV Color and OnOff state for when the Light is restarted / power goes off
  matterPref.putBool(onOffPrefKey, state);
  matterPref.putUInt(hsvColorPrefKey, colorHSV.h << 16 | colorHSV.s << 8 | colorHSV.v);
  // This callback must return the success state to Matter core
  return true;
}

void setup() {
  // Initialize the USER BUTTON (Boot button) GPIO that will act as a toggle switch
  pinMode(buttonPin, INPUT_PULLUP);
  // Initialize the LED (light) GPIO and Matter End Point
  pinMode(ledPin, OUTPUT);

  Serial.begin(115200);

// CONFIG_ENABLE_CHIPOBLE is enabled when BLE is used to commission the Matter Network
#if !CONFIG_ENABLE_CHIPOBLE
  // We start by connecting to a WiFi network
  Serial.print("Connecting to ");
  Serial.println(ssid);
  // Manually connect to WiFi
  WiFi.begin(ssid, password);
  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\r\nWiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
  delay(500);
#endif

  // Initialize Matter EndPoint
  matterPref.begin("MatterPrefs", false);
  // default OnOff state is ON if not stored before
  bool lastOnOffState = matterPref.getBool(onOffPrefKey, true);
  // default HSV color is blue HSV(169, 254, 254)
  uint32_t prefHsvColor = matterPref.getUInt(hsvColorPrefKey, 169 << 16 | 254 << 8 | 254);
  espHsvColor_t lastHsvColor = {uint8_t(prefHsvColor >> 16), uint8_t(prefHsvColor >> 8), uint8_t(prefHsvColor)};
  ColorLight.begin(lastOnOffState, lastHsvColor);
  // set the callback function to handle the Light state change
  ColorLight.onChange(setLightState);

  // lambda functions are used to set the attribute change callbacks
  ColorLight.onChangeOnOff([](bool state) {
    Serial.printf("Light OnOff changed to %s\r\n", state ? "ON" : "OFF");
    return true;
  });
  ColorLight.onChangeColorHSV([](HsvColor_t hsvColor) {
    Serial.printf("Light HSV Color changed to (%u,%u,%u)\r\n", hsvColor.h, hsvColor.s, hsvColor.v);
    return true;
  });
```

--------------------------------

### Perform a blocking CoAP GET request

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/openthread/openthread_coap.html

Example of initializing an OThreadCoAPClient, setting a timeout and confirmable status, and executing a GET request.

```cpp
OThreadCoAPClient client;
client.setTimeout(5000);
client.setConfirmable(true);   // CON — CLI "con"
int code = client.GET(serverIp, "hello");
if (code >= 0) {
    Serial.println(client.getString());
}
```

--------------------------------

### Register and start OThreadCoAPServer

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/openthread/openthread_coap.html

Defines a handler function for a CoAP GET request and registers it with the global OThreadCoAPServer instance before starting the server.

```cpp
static void onHello(OThreadCoAPRequest &req, OThreadCoAPResponse &resp, void *ctx) {
    resp.setCode(OT_COAP_RESP_OK);
    resp.setPayload("Hello from CoAP!");
    resp.send();
}

OThreadCoAPServer.on("hello", OT_COAP_METHOD_GET, onHello);
OThreadCoAPServer.begin();
```

--------------------------------

### CoAPS Client and Server Usage

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/openthread/openthread_coap.html

Example showing how to configure and use the OThreadCoAPSecureClient for PUT requests and the OThreadCoAPSecureServer for registering GET handlers.

```cpp
OThreadCoAPSecureClient client;
client.setPSK(psk, pskLen, "client1");
client.connect(serverIp);
client.setConfirmable(true);
client.setContentFormat(OT_COAP_FORMAT_JSON);
int code = client.PUT("fan/speed", "{\"speed\":75}");
client.disconnect();

OThreadCoAPSecureServer.setPSK(psk, pskLen, "server1");
OThreadCoAPSecureServer.on("status", OT_COAP_METHOD_GET, onStatus);
OThreadCoAPSecureServer.begin();
```

--------------------------------

### Zigbee Thermostat Example

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/zigbee/ep_thermostat.html

This C++ code demonstrates a basic Zigbee thermostat implementation. It includes setup for receiving temperature data from a sensor, configuring thermostat parameters, and integrating with the Zigbee network as a coordinator. The code also shows how to handle optional features like time synchronization.

```cpp
// Copyright 2024 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/**
 * @brief This example demonstrates simple Zigbee thermostat.
 *
 * The example demonstrates how to use Zigbee library to get data from temperature
 * sensor end device and act as an thermostat.
 * The temperature sensor is a Zigbee end device, which is controlled by a Zigbee coordinator (thermostat).
 *
 * Proper Zigbee mode must be selected in Tools->Zigbee mode
 * and also the correct partition scheme must be selected in Tools->Partition Scheme.
 *
 * Please check the README.md for instructions and more detailed description.
 *
 * Created by Jan Procházka (https://github.com/P-R-O-C-H-Y/)
 */

#include <Arduino.h>
#ifndef ZIGBEE_MODE_ZCZR
#error "Zigbee coordinator mode is not selected in Tools->Zigbee mode"
#endif

#include "Zigbee.h"

/* Zigbee thermostat configuration */
#define THERMOSTAT_ENDPOINT_NUMBER   1
#define USE_RECEIVE_TEMP_WITH_SOURCE 1
uint8_t button = BOOT_PIN;

ZigbeeThermostat zbThermostat = ZigbeeThermostat(THERMOSTAT_ENDPOINT_NUMBER);

// Save temperature sensor data
float sensor_temp;
float sensor_max_temp;
float sensor_min_temp;
float sensor_tolerance;

struct tm timeinfo = {};  // Time structure for Time cluster  

/****************** Temperature sensor handling *******************/
#if USE_RECEIVE_TEMP_WITH_SOURCE == 0
void receiveSensorTemp(float temperature) {
  Serial.printf("Temperature sensor value: %.2f°C\n", temperature);
  sensor_temp = temperature;
}
#else
void receiveSensorTempWithSource(float temperature, uint8_t src_endpoint, esp_zb_zcl_addr_t src_address) {
  if (src_address.addr_type == ESP_ZB_ZCL_ADDR_TYPE_SHORT) {
    Serial.printf("Temperature sensor value: %.2f°C from endpoint %u, address 0x%04x\n", temperature, src_endpoint, src_address.u.short_addr);
  } else {
    Serial.printf(
      "Temperature sensor value: %.2f°C from endpoint %u, address %02x:%02x:%02x:%02x:%02x:%02x:%02x:%02x\n", temperature, src_endpoint,
      src_address.u.ieee_addr[7], src_address.u.ieee_addr[6], src_address.u.ieee_addr[5], src_address.u.ieee_addr[4], src_address.u.ieee_addr[3],
      src_address.u.ieee_addr[2], src_address.u.ieee_addr[1], src_address.u.ieee_addr[0]
    );
  }
  sensor_temp = temperature;
}
#endif

void receiveSensorConfig(float min_temp, float max_temp, float tolerance) {
  Serial.printf("Temperature sensor config: min %.2f°C, max %.2f°C, tolerance %.2f°C\n", min_temp, max_temp, tolerance);
  sensor_min_temp = min_temp;
  sensor_max_temp = max_temp;
  sensor_tolerance = tolerance;
}
/********************* Arduino functions **************************/
void setup() {
  Serial.begin(115200);

  // Init button switch
  pinMode(button, INPUT_PULLUP);

// Set callback function for receiving temperature from sensor - Use only one option
#if USE_RECEIVE_TEMP_WITH_SOURCE == 0
  zbThermostat.onTempReceive(receiveSensorTemp);  // If you bound only one sensor or you don't need to know the source of the temperature
#else
  zbThermostat.onTempReceiveWithSource(receiveSensorTempWithSource);
#endif

  // Set callback function for receiving sensor configuration
  zbThermostat.onTempConfigReceive(receiveSensorConfig);

  //Optional: set Zigbee device name and model
  zbThermostat.setManufacturerAndModel("Espressif", "ZigbeeThermostat");

  //Optional Time cluster configuration
  //example time January 13, 2025 13:30:30 CET
  timeinfo.tm_year = 2025 - 1900;  // = 2025
  timeinfo.tm_mon = 0;             // January
  timeinfo.tm_mday = 13;           // 13th
  timeinfo.tm_hour = 12;           // 12 hours - 1 hour (CET)
  timeinfo.tm_min = 30;            // 30 minutes
  timeinfo.tm_sec = 30;            // 30 seconds
  timeinfo.tm_isdst = -1;

  // Set time and gmt offset (timezone in seconds -> CET = +3600 seconds)
  zbThermostat.addTimeCluster(timeinfo, 3600);

  //Add endpoint to Zigbee Core
  Zigbee.addEndpoint(&zbThermostat);

  //Open network for 180 seconds after boot
  Zigbee.setRebootOpenNetwork(180);

  // When all EPs are registered, start Zigbee with ZIGBEE_COORDINATOR mode
  if (!Zigbee.begin(ZIGBEE_COORDINATOR)) {
    Serial.println("Zigbee failed to start!");
    Serial.println("Rebooting...");
    ESP.restart();
  }

  Serial.println("Waiting for Temperature sensor to bound to the thermostat");
  while (!zbThermostat.bound()) {
    Serial.printf(".");
    delay(500);
  }

  Serial.println();

```

--------------------------------

### usePsram Example

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/api/console.html

Example demonstrating how to enable PSRAM usage for the Console.

```cpp
Console.usePsram(true);  // before begin()
Console.begin();
Console.attachToSerial(true);
```

--------------------------------

### Install Requirements

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/guides/docs_contributing.html

Installs the necessary packages to build the documentation.

```bash
pip install -r requirements.txt

```

--------------------------------

### Example Usage

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/api/insights.html

Example code to get started with Insights, including WiFi connection and Insights initialization.

```c++
#include <Arduino.h>
#include "Insights.h"
#include "WiFi.h"

const char insights_auth_key[] = "<ENTER YOUR AUTH KEY>";

#define WIFI_SSID       "<ENTER YOUR SSID>"
#define WIFI_PASSPHRASE "<ENTER YOUR PASSWORD>"

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASSPHRASE);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  if (!Insights.begin(insights_auth_key)) {
    return;
  }
  Serial.println("=========================================");
  Serial.printf("ESP Insights enabled Node ID %s\n", Insights.nodeID());
  Serial.println("=========================================");
}

void loop() {
  delay(1000);
}


```

--------------------------------

### Serial available usage example

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/api/serial.html

Example demonstrating how to check for available data before reading.

```cpp
if (Serial.available() > 0) {
    char data = Serial.read();
}
```

--------------------------------

### Example - Get current temperature

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/matter/ep_temperature_sensor.html

Example of getting the current temperature.

```cpp
double temp = mySensor;  // Get current temperature

```

--------------------------------

### Implement setup function

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/matter/ep_window_covering.html

Initializes GPIO pins, serial communication, WiFi connection (if BLE is disabled), and Matter preferences.

```cpp
void setup() {
  // Initialize the USER BUTTON (Boot button) GPIO
  pinMode(buttonPin, INPUT_PULLUP);
  // Initialize the RGB LED GPIO
  pinMode(ledPin, OUTPUT);
  digitalWrite(ledPin, LOW);

  Serial.begin(115200);

// CONFIG_ENABLE_CHIPOBLE is enabled when BLE is used to commission the Matter Network
#if !CONFIG_ENABLE_CHIPOBLE
  // We start by connecting to a WiFi network
  Serial.print("Connecting to ");
  Serial.println(ssid);
  // Manually connect to WiFi
  WiFi.begin(ssid, password);
  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\r\nWiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
  delay(500);
#endif

  // Initialize Matter EndPoint
  matterPref.begin("MatterPrefs", false);
  // default lift percentage is 0% (fully open) if not stored before — Matter semantics
  uint8_t lastLiftPercent = matterPref.getUChar(liftPercentPrefKey, 0);
  // default tilt percentage is 0% if not stored before
  uint8_t lastTiltPercent = matterPref.getUChar(tiltPercentPrefKey, 0);
```

--------------------------------

### Install pre-commit dependencies

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/contributing.html

Install the necessary dependencies for running pre-commit hooks locally.

```bash
pip install -U -r tools/pre-commit/requirements.txt
```

--------------------------------

### begin Method

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/api/i2s.html

Initializes the I2S driver. Pins should be configured using setPins() or PDM pin-setup functions before calling this.

```cpp
bool begin(i2s_mode_t mode, uint32_t rate, i2s_data_bit_width_t bits_cfg, i2s_slot_mode_t ch, int8_t slot_mask=-1, i2s_role_t role=I2S_ROLE_MASTER)
```

--------------------------------

### Wi-Fi STA Example

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/api/wifi.html

This code example demonstrates connecting an ESP32 to a Wi-Fi network in Station mode, sending data to a ThingSpeak channel, and reading data from it. It includes setup for Wi-Fi connection, sending data via GET requests to the ThingSpeak API, and receiving data. The comments provide detailed instructions on setting up a ThingSpeak channel and obtaining API keys.

```c++
/*
    Go to thingspeak.com and create an account if you don't have one already.
    After logging in, click on the "New Channel" button to create a new channel for your data. This is where your data will be stored and displayed.
    Fill in the Name, Description, and other fields for your channel as desired, then click the "Save Channel" button.
    Take note of the "Write API Key" located in the "API keys" tab, this is the key you will use to send data to your channel.
    Replace the channelID from tab "Channel Settings" and privateKey with "Read API Keys" from "API Keys" tab.
    Replace the host variable with the thingspeak server hostname "api.thingspeak.com"
    Upload the sketch to your ESP32 board and make sure that the board is connected to the internet. The ESP32 should now send data to your Thingspeak channel at the intervals specified by the loop function.
    Go to the channel view page on thingspeak and check the "Field1" for the new incoming data.
    You can use the data visualization and analysis tools provided by Thingspeak to display and process your data in various ways.
    Please note, that Thingspeak accepts only integer values.

    You can later check the values at https://thingspeak.com/channels/2005329
    Please note that this public channel can be accessed by anyone and it is possible that more people will write their values.
 */

#include <Arduino.h>
#include <WiFi.h>

const char *ssid = "your-ssid";          // Change this to your WiFi SSID
const char *password = "your-password";  // Change this to your WiFi password

const char *host = "api.thingspeak.com";        // This should not be changed
const int httpPort = 80;                        // This should not be changed
const String channelID = "2005329";             // Change this to your channel ID
const String writeApiKey = "V6YOTILH9I7D51F9";  // Change this to your Write API key
const String readApiKey = "34W6LGLIFXD56MPM";   // Change this to your Read API key

// The default example accepts one data filed named "field1"
// For your own server you can ofcourse create more of them.
int field1 = 0;

int numberOfResults = 3;  // Number of results to be read
int fieldNumber = 1;      // Field number which will be read out

void setup() {
  Serial.begin(115200);

  // We start by connecting to a WiFi network

  Serial.println();
  Serial.println("******************************************************");
  Serial.print("Connecting to ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}

void readResponse(NetworkClient *client) {
  unsigned long timeout = millis();
  while (client->available() == 0) {
    if (millis() - timeout > 5000) {
      Serial.println(">>> Client Timeout !");
      client->stop();
      return;
    }
  }

  // Read all the lines of the reply from server and print them to Serial
  while (client->available()) {
    String line = client->readStringUntil('\r');
    Serial.print(line);
  }

  Serial.printf("\nClosing connection\n\n");
}

void loop() {
  NetworkClient client;
  String footer = String(" HTTP/1.1\r\n") + "Host: " + String(host) + "\r\n" + "Connection: close\r\n\r\n";

  // WRITE --------------------------------------------------------------------------------------------
  if (!client.connect(host, httpPort)) {
    return;
  }

  client.print("GET /update?api_key=" + writeApiKey + "&field1=" + field1 + footer);
  readResponse(&client);

  // READ --------------------------------------------------------------------------------------------

  String readRequest = "GET /channels/" + channelID + "/fields/" + fieldNumber + ".json?results=" + numberOfResults + " HTTP/1.1\r\n" + "Host: " + host + "\r\n"
                       + "Connection: close\r\n\r\n";

  if (!client.connect(host, httpPort)) {
    return;
  }

  client.print(readRequest);
  readResponse(&client);

  // -------------------------------------------------------------------------------------------------

  ++field1;
  delay(10000);
}

```

--------------------------------

### Start Interactive Console

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/openthread/openthread_cli.html

Starts an interactive console task for CLI access. The example demonstrates starting the console using the Serial object.

```cpp
void startConsole(Stream &otStream, bool echoback = true, const char *prompt = "ot> ");
```

```cpp
OThreadCLI.startConsole(Serial, true, "ot> ");
```

--------------------------------

### MatterGenericSwitch begin Examples

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/matter/ep_generic_switch.html

Examples showing initialization for a simple short-click button and full gesture support.

```cpp
// Simple short-click button (default)
mySwitch.begin();

// Full gesture support (long press + multi-press up to 5 clicks)
mySwitch.begin(MatterGenericSwitch::FEATURE_ALL, 5);
```

--------------------------------

### Serial begin usage examples

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/api/serial.html

Examples showing basic initialization, custom pin configuration, and baud rate detection.

```cpp
// Basic initialization with default pins
Serial.begin(115200);

// Initialize with custom pins
Serial1.begin(9600, SERIAL_8N1, 4, 5);

// Initialize with baud rate detection (ESP32, ESP32-S2 only)
Serial.begin(0, SERIAL_8N1, -1, -1, false, 20000);
```

--------------------------------

### Example: Get and store preference type

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/tutorials/preferences.html

Demonstrates how to get the `PreferenceType` for a key and store it in a variable.

```cpp
PreferenceType whatType = getType("myKey");
```

--------------------------------

### Commissioner Usage Example

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/openthread/openthread_core.html

Example of starting the commissioner and adding a joiner on an already attached Leader or Router node.

```cpp
// Already attached to the network at this point
// (networkInterfaceUp() + start() completed earlier).
otError err = OThread.startCommissioner();
if (err == OT_ERROR_NONE) {
    OThread.addJoiner("J01NME",      // PSKd
                      120);          // window: 120 s (accepts any joiner)
}
```

--------------------------------

### ESPVideoClass::begin()

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/api/esp_video.html

Initializes the video hardware using the provided configuration object (CSI or DVP).

```APIDOC
## bool ESPVideoClass::begin(config)

### Description
Initializes the video hardware interface based on the provided configuration. This method performs pin reservation and prepares the hardware for capture.

### Parameters
- **config** (ESPVideoCSIConfigClass or ESPVideoDVPConfigClass) - Required - The configuration object containing hardware settings.

### Returns
- **bool** - Returns true if initialization is successful, false otherwise.
```

--------------------------------

### timerBegin

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/api/timer.html

Configures and starts a timer. The timer will automatically start after successful setup.

```c
hw_timer_t * timerBegin(uint32_t frequency);
```

--------------------------------

### Arduino setup() and loop() implementation

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/esp-idf_component.html

Standard Arduino sketch structure using setup() and loop() functions. Requires including Arduino.h.

```cpp
//file: main.cpp
#include "Arduino.h"

void setup(){
  Serial.begin(115200);
  while(!Serial){
    ; // wait for serial port to connect
  }
}

void loop(){
    Serial.println("loop");
    delay(1000);
}
```

--------------------------------

### bool begin(const char *hostName)

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/openthread/openthread_dnssd.html

Configures the host, sets up auto-addresses, and initiates the SRP client. This must be called before any other advertisement or query APIs.

```APIDOC
## bool begin(const char *hostName)

### Description
Configures the host, auto addresses, and auto-start. Prefer a per-device unique label when several nodes share one OTBR. Discover-only sketches also register this host.

### Parameters
- **hostName** (const char *) - Required - The hostname to register for the device.
```

--------------------------------

### Example

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/matter/ep_humidity_sensor.html

Get current humidity

```cpp
double humidity = mySensor;  // Get current humidity

```

--------------------------------

### begin

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/api/i2s.html

Initializes the I2S driver.

```APIDOC
## bool begin(i2s_mode_t mode, uint32_t rate, i2s_data_bit_width_t bits_cfg, i2s_slot_mode_t ch, int8_t slot_mask=-1, i2s_role_t role=I2S_ROLE_MASTER)

### Description
Initializes the I2S driver with the specified mode, rate, bit width, and channel configuration. Returns true on success, false on failure.

### Parameters
- **mode** (i2s_mode_t) - Required - Operation mode (e.g., I2S_MODE_STD).
- **rate** (uint32_t) - Required - Sampling rate in Hz.
- **bits_cfg** (i2s_data_bit_width_t) - Required - Number of bits in a channel sample.
- **ch** (i2s_slot_mode_t) - Required - Slot mode (e.g., I2S_SLOT_MODE_STEREO).
- **slot_mask** (int8_t) - Optional - Selects which slot(s) to use (defaults to -1).
- **role** (i2s_role_t) - Optional - I2S role (defaults to I2S_ROLE_MASTER).
```

--------------------------------

### Example ci.yml configuration for wifi test suite

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/contributing.html

This example demonstrates how to configure hardware tags, target-specific FQBNs, platform support, and configuration requirements for a Wi-Fi test suite.

```yaml
tags:
  - wifi_router

fqbn:
  esp32:
    - espressif:esp32:esp32:PSRAM=enabled,PartitionScheme=huge_app,FlashMode=dio
    - espressif:esp32:esp32:PSRAM=disabled,PartitionScheme=huge_app,FlashMode=dio
  esp32s2:
    - espressif:esp32:esp32s2:PSRAM=enabled,PartitionScheme=huge_app,FlashMode=dio
    - espressif:esp32:esp32s2:PSRAM=disabled,PartitionScheme=huge_app,FlashMode=dio
  esp32s3:
    - espressif:esp32:esp32s3:PSRAM=opi,USBMode=default,PartitionScheme=huge_app,FlashMode=qio
    - espressif:esp32:esp32s3:PSRAM=disabled,USBMode=default,PartitionScheme=huge_app,FlashMode=qio
    - espressif:esp32:esp32s3:PSRAM=enabled,USBMode=default,PartitionScheme=huge_app,FlashMode=qio

platforms:
  qemu: false
  hardware:
    esp32p4: false # No wifi_router runners using ESP-Hosted
  wokwi:
    esp32p4: false # For some reason this test crashes on Wokwi

requires_any:
  - CONFIG_SOC_WIFI_SUPPORTED=y
  - CONFIG_ESP_HOSTED_ENABLED=y
```

--------------------------------

### Join multicast group for CoAP resources

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/openthread/openthread_coap.html

Configures a multicast group for a resource and joins it after starting the server to enable receiving multicast requests.

```cpp
const IPAddress LAMP_GROUP(IPv6, lampGroupBytes);  // ff03::abcd
OThreadCoAPServer.on("Lamp", OT_COAP_METHOD_GET | OT_COAP_METHOD_PUT, onLamp);
OThreadCoAPServer.begin();
OThreadCoAPServer.joinMulticastGroup(LAMP_GROUP);
```

--------------------------------

### Example - double operator

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/matter/ep_pressure_sensor.html

Get current pressure

```cpp
double pressure = mySensor;  // Get current pressure

```

--------------------------------

### Joiner Pre-configuration Example

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/openthread/openthread_core.html

Example of pre-configuring channel and PAN settings on the Joiner side before joining the network.

```cpp
OThread.begin(false);                       // stack up, no DataSet
OThread.setChannel(15);                     // pre-pick channel
OThread.setPanId(0xFFFF);                   // pre-pick PAN
uint8_t xp[8] = {0x11,0x11,0x11,0x11,0x22,0x22,0x22,0x22};
OThread.setExtendedPanId(xp);
OThread.networkInterfaceUp();

otError err = OThread.startJoiner("J01NME"); // run Joiner state machine
if (err == OT_ERROR_NONE) {
    OThread.start();                         // enable Thread with provisioned dataset
}
```

--------------------------------

### Watchdog Timer Example

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/api/timer.html

This example shows how to use a hardware timer as a watchdog to automatically reset the module if the main loop takes too long to execute or gets stuck.

```cpp
#include <Arduino.h>
#include "esp_system.h"
#include "rom/ets_sys.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(1000000);                     //timer 1Mhz resolution
  timerAttachInterrupt(timer, &resetModule);       //attach callback
  timerAlarm(timer, wdtTimeout * 1000, false, 0);  //set time in us
}

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
}

```

--------------------------------

### begin()

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/matter/ep_water_freeze_detector.html

Initializes the water freeze detector endpoint.

```APIDOC
## bool begin()

### Description
Initializes the Matter water freeze detector endpoint. The initial state is set to false (not detected).

### Returns
- `bool` - Returns true if successful, false otherwise.
```

--------------------------------

### Example Application: WiFiAccessPoint

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/guides/docs_contributing.html

Includes an example application from the WiFi library using a literal include directive.

```arduino
.. literalinclude:: ../../../libraries/WiFi/examples/WiFiAccessPoint/WiFiAccessPoint.ino
    :language: arduino
```

--------------------------------

### begin()

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/matter/ep_generic_switch.html

Initializes the Matter generic switch endpoint with specified features.

```APIDOC
## bool begin(uint32_t featureFlags, uint8_t multiPressMax)

### Description
Initializes the Matter generic switch endpoint.

### Parameters
- **featureFlags** (uint32_t) - Optional - Switch cluster features to enable. Defaults to FEATURE_SIMPLE.
- **multiPressMax** (uint8_t) - Optional - Maximum press count for multi-press (2–255). Used only when FEATURE_MULTI_PRESS is set.

### Returns
- **bool** - Returns true on success, false otherwise.
```

--------------------------------

### RMT Write RGB LED (WS2812) Example

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/api/rmt.html

An example demonstrating how to control a WS2812 RGB LED strip using the RMT peripheral in Arduino. It includes setup for the RMT channel, data preparation for WS2812 protocol, and a loop to animate the LEDs.

```cpp
// Copyright 2024 Espressif Systems (Shanghai) PTE LTD
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at

//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/**
 * @brief This example demonstrates usage of RGB LED driven by RMT
 *
 * The output is a visual WS2812 RGB LED color moving in a 8 x 4 LED matrix
 * Parameters can be changed by the user. In a single LED circuit, it will just blink.
 */

#include <Arduino.h>

// The effect seen in (Espressif devkits) ESP32C6, ESP32H2, ESP32C3, ESP32S2 and ESP32S3 is like a Blink of RGB LED
#ifdef PIN_LED_RGB
#define BUILTIN_RGBLED_PIN PIN_LED_RGB
#else
#define BUILTIN_RGBLED_PIN 21  // ESP32 has no builtin RGB LED (PIN_LED_RGB)
#endif

#define NR_OF_LEDS     8 * 4
#define NR_OF_ALL_BITS 24 * NR_OF_LEDS

//
// Note: This example uses a board with 32 WS2812b 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 |

rrmt_data_t led_data[NR_OF_ALL_BITS];

void setup() {
  Serial.begin(115200);
  if (!rmtInit(BUILTIN_RGBLED_PIN, RMT_TX_MODE, RMT_MEM_NUM_BLOCKS_1, 10000000)) {
    Serial.println("init sender failed\n");
  }
  Serial.println("real tick set to: 100ns");
}

int color[] = {0x55, 0x11, 0x77};  // Green Red Blue values
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 panel
  if ((++led_index) >= NR_OF_LEDS) {
    led_index = 0;
  }
  // Send the data and wait until it is done
  rmtWrite(BUILTIN_RGBLED_PIN, led_data, NR_OF_ALL_BITS, RMT_WAIT_FOR_EVER);
  delay(100);
}

```

--------------------------------

### begin

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/matter/ep_window_covering.html

Initializes the Matter window covering endpoint with configuration parameters.

```APIDOC
## bool begin(uint8_t liftPercent, uint8_t tiltPercent, WindowCoveringType_t coveringType, const PositionCalibration *liftCalibration, const PositionCalibration *tiltCalibration)

### Description
Initializes the endpoint with initial positions, covering type, and optional motor calibration.

### Parameters
- **liftPercent** (uint8_t) - Initial lift percentage (0-100, default: 0 = fully open)
- **tiltPercent** (uint8_t) - Initial tilt percentage (0-100, default: 0 = fully open)
- **coveringType** (WindowCoveringType_t) - Window covering type (default: ROLLERSHADE)
- **liftCalibration** (const PositionCalibration *) - Optional local motor range for lift
- **tiltCalibration** (const PositionCalibration *) - Optional local motor range for tilt

### Returns
- **bool** - true if successful, false otherwise.
```

--------------------------------

### Preferences begin method

Source: https://docs.espressif.com/projects/arduino-esp32/en/latest/api/preferences.html

Opens a non-volatile storage namespace. If the namespace does not exist, it is created.

```cpp
bool begin(const char * name, bool readOnly=false, const char* partition_label=NULL)
```
Tokens:
Raw