ESP-IDF

https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/
Admin
ESP-IDF is the official development framework for Espressif's ESP32, ESP32-S, ESP32-C, ESP32-H, and...
Tokens:852,394
Snippets:10,111
Trust Score:10
Update:2 months ago
Show doc for...
Tokens:
Raw
### Initialize and Start MQTT Client

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/protocols/mqtt.html

Basic setup for an MQTT client using a URI, registering an event handler, and starting the client.

```c
const esp_mqtt_client_config_t mqtt_cfg = {
    .broker.address.uri = "mqtt://mqtt.eclipseprojects.io",
};
esp_mqtt_client_handle_t client = esp_mqtt_client_init(&mqtt_cfg);
esp_mqtt_client_register_event(client, ESP_EVENT_ANY_ID, mqtt_event_handler, client);
esp_mqtt_client_start(client);
```

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

### Install and Start RFC2217 Server on Linux/macOS

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/tools/idf-docker-image.html

Install esptool and start the server to expose the serial port.

```bash
pip install esptool
```

```bash
esp_rfc2217_server.py -v -p 4000 /dev/ttyUSB0
```

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

### Implement Post-Attach Callback

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/network/esp_netif_driver.html

Example of a post-attach callback function that configures the driver and starts the network interface.

```c
static esp_err_t my_post_attach_start(esp_netif_t * esp_netif, void * args)
{
    my_netif_driver_t *driver = args;
    const esp_netif_driver_ifconfig_t driver_ifconfig = {
            .driver_free_rx_buffer = my_free_rx_buf,
            .transmit = my_transmit,
            .handle = driver->driver_impl
    };
    driver->base.netif = esp_netif;
    ESP_ERROR_CHECK(esp_netif_set_driver_config(esp_netif, &driver_ifconfig));
    my_driver_start(driver->driver_impl);
    return ESP_OK;
}
```

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

### Navigate to the BLE example directory

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/ble/get-started/ble-introduction.html

Use this command to change the current directory to the NimBLE_GATT_Server example path.

```bash
$ cd <ESP-IDF Path>/examples/bluetooth/ble_get_started/nimble/NimBLE_GATT_Server
```

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

### Install QEMU binaries

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/tools/qemu.html

Command to install the pre-built QEMU binaries using the ESP-IDF tools script.

```bash
python $IDF_PATH/tools/idf_tools.py install qemu-xtensa qemu-riscv32
```

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

### Install esptool

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/security/security-features-enablement-workflows.html

Install the esptool utility required for device communication.

```bash
pip install esptool
```

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

### Install esp-idf-sbom

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/tools/idf-sbom.html

Install the tool from PyPI using pip.

```bash
$ pip install esp-idf-sbom
```

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

### Navigate to BLE Example Directory

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/ble/get-started/ble-connection.html

Command to change the current directory to the NimBLE connection example path.

```bash
$ cd <ESP-IDF Path>/examples/bluetooth/ble_get_started/nimble/NimBLE_Connection
```

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

### Install ESP-IDF Tools

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/get-started/windows-setup-update.html

Run the installation script from the ESP-IDF directory to download and set up required tools.

```batch
install.bat
```

```powershell
install.ps1
```

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

### Build System Output Example

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/get-started/linux-macos-setup.html

Example of the console output generated during a successful project build.

```text
$ idf.py build
Running cmake in directory /path/to/hello_world/build
Executing "cmake -G Ninja --warn-uninitialized /path/to/hello_world"...
Warn about uninitialized values.
-- Found Git: /usr/bin/git (found version "2.17.0")
-- Building empty aws_iot component due to configuration
-- Component names: ...
-- Component paths: ...

... (more lines of build system output)

[527/527] Generating hello_world.bin
esptool.py v2.3.1

Project build complete. To flash, run this command:
../../../components/esptool_py/esptool/esptool.py -p (PORT) -b 921600 write_flash --flash_mode dio --flash_size detect --flash_freq 40m 0x10000 build/hello_world.bin  build 0x1000 build/bootloader/bootloader.bin 0x8000 build/partition_table/partition-table.bin
or run 'idf.py -p PORT flash'
```

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

### Navigate to NimBLE_Beacon Example

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/ble/get-started/ble-device-discovery.html

Command to change the working directory to the NimBLE_Beacon example project.

```bash
$ cd <ESP-IDF Path>/examples/bluetooth/ble_get_started/nimble/NimBLE_Beacon
```

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

### STO Instruction Examples

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/system/ulp_instruction_set.html

Examples demonstrating how to set the offset register using immediate values and labels.

```assembly
1:        STO  0x12               // Offset = 0x12 / 4

2:        .data                   // Data section definition
  Addr1:  .word     123           // Define label Addr1 16 bit
          .set      offs, 0x00    // Define constant offs
          .text                   // Text section definition
          STO       offs          // Offset = 0x00
```

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

### Install Texinfo for Build Errors

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/jtag-debugging/building-openocd-macos.html

Install and configure texinfo if the build fails with 'Unknown command' errors.

```bash
brew install texinfo
export PATH=/usr/local/opt/texinfo/bin:$PATH
```

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

### esp_mqtt_client_start

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/protocols/mqtt.html

Starts the MQTT client task.

```APIDOC
## esp_mqtt_client_start

### Description
Starts the MQTT client, initiating the connection process to the broker based on the provided configuration.

### Parameters
- **client** (esp_mqtt_client_handle_t) - Required - The MQTT client handle.
```

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

### Install QEMU system dependencies

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/tools/qemu.html

Commands to install required system libraries for QEMU on various Linux distributions and macOS.

```bash
sudo apt-get install -y libgcrypt20 libglib2.0-0 libpixman-1-0 libsdl2-2.0-0 libslirp0
```

```bash
sudo yum install -y --enablerepo=powertools libgcrypt glib2 pixman SDL2 libslirp
```

```bash
sudo pacman -S --needed libgcrypt glib2 pixman sdl2 libslirp
```

```bash
brew install libgcrypt glib pixman sdl2 libslirp
```

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

### Starting the Web Server

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/protocols/esp_http_server.html

Initializes the server with default configuration and registers URI handlers.

```C
//Function for starting the webserver
httpd_handle_t start_webserver(void)
{
// Generate default configuration
httpd_config_t config = HTTPD_DEFAULT_CONFIG();

// Empty handle to http_server
     httpd_handle_t server = NULL;

// Start the httpd server
if (httpd_start(&server, &config) == ESP_OK) {
// Register URI handlers
         httpd_register_uri_handler(server, &uri_get);
         httpd_register_uri_handler(server, &uri_post);
     }
// If server failed to start, handle will be NULL
return server;
}
```

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

### Copy the hello_world project

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/get-started/windows-start-project.html

Copies the hello_world example project from the ESP-IDF directory to the user's local esp folder.

```batch
cd %userprofile%\esp
xcopy /e /i %IDF_PATH%\examples\get-started\hello_world hello_world
```

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

### Implementing a Basic USB Host Client

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/peripherals/usb_host.html

Demonstrates registering a client, handling device events via callbacks, and managing a transfer lifecycle within a task loop.

```c
#include <string.h>
#include "usb/usb_host.h"

#define CLASS_DRIVER_ACTION_OPEN_DEV    0x01
#define CLASS_DRIVER_ACTION_TRANSFER    0x02
#define CLASS_DRIVER_ACTION_CLOSE_DEV   0x03

struct class_driver_control {
    uint32_t actions;
    uint8_t dev_addr;
    usb_host_client_handle_t client_hdl;
    usb_device_handle_t dev_hdl;
};

static void client_event_cb(const usb_host_client_event_msg_t *event_msg, void *arg)
{
    // This function is called from within usb_host_client_handle_events(). Do not block and try to keep it short
    struct class_driver_control *class_driver_obj = (struct class_driver_control *)arg;
    switch (event_msg->event) {
        case USB_HOST_CLIENT_EVENT_NEW_DEV:
            class_driver_obj->actions |= CLASS_DRIVER_ACTION_OPEN_DEV;
            class_driver_obj->dev_addr = event_msg->new_dev.address; //Store the address of the new device
            break;
        case USB_HOST_CLIENT_EVENT_DEV_GONE:
            class_driver_obj->actions |= CLASS_DRIVER_ACTION_CLOSE_DEV;
            break;
        default:
            break;
    }
}

static void transfer_cb(usb_transfer_t *transfer)
{
    // This function is called from within usb_host_client_handle_events(). Do not block and try to keep it short
    struct class_driver_control *class_driver_obj = (struct class_driver_control *)transfer->context;
    printf("Transfer status %d, actual number of bytes transferred %d\n", transfer->status, transfer->actual_num_bytes);
    class_driver_obj->actions |= CLASS_DRIVER_ACTION_CLOSE_DEV;
}

void client_task(void *arg)
{
    ... // Wait until Host Library is installed
    // Initialize class driver objects
    struct class_driver_control class_driver_obj = {0};
    // Register the client
    usb_host_client_config_t client_config = {
        .is_synchronous = false,
        .max_num_event_msg = 5,
        .async = {
            .client_event_callback = client_event_cb,
            .callback_arg = &class_driver_obj,
        }
    };
    usb_host_client_register(&client_config, &class_driver_obj.client_hdl);
    //Allocate a USB transfer
    usb_transfer_t *transfer;
    usb_host_transfer_alloc(1024, 0, &transfer);

    //Event handling loop
    bool exit = false;
    while (!exit) {
        // Call the client event handler function
        usb_host_client_handle_events(class_driver_obj.client_hdl, portMAX_DELAY);
        // Execute pending class driver actions
        if (class_driver_obj.actions & CLASS_DRIVER_ACTION_OPEN_DEV) {
            // Open the device and claim interface 1
            usb_host_device_open(class_driver_obj.client_hdl, class_driver_obj.dev_addr, &class_driver_obj.dev_hdl);
            usb_host_interface_claim(class_driver_obj.client_hdl, class_driver_obj.dev_hdl, 1, 0);
        }
        if (class_driver_obj.actions & CLASS_DRIVER_ACTION_TRANSFER) {
            // Send an OUT transfer to EP1
            memset(transfer->data_buffer, 0xAA, 1024);
            transfer->num_bytes = 1024;
            transfer->device_handle = class_driver_obj.dev_hdl;
            transfer->bEndpointAddress = 0x01;
            transfer->callback = transfer_cb;
            transfer->context = (void *)&class_driver_obj;
            usb_host_transfer_submit(transfer);
        }
        if (class_driver_obj.actions & CLASS_DRIVER_ACTION_CLOSE_DEV) {
            // Release the interface and close the device
            usb_host_interface_release(class_driver_obj.client_hdl, class_driver_obj.dev_hdl, 1);
            usb_host_device_close(class_driver_obj.client_hdl, class_driver_obj.dev_hdl);
            exit = true;
        }
        ... // Handle any other actions required by the class driver
    }

    // Cleanup class driver
    usb_host_transfer_free(transfer);
    usb_host_client_deregister(class_driver_obj.client_hdl);
    ... // Delete the client task. Signal the Daemon Task if necessary.
}
```

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

### Get task stack start address

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/system/freertos_additions.html

Returns the lowest memory address of the stack associated with the specified task.

```c
uint8_t *pxTaskGetStackStart(TaskHandle_t xTask)
```

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

### Receive Queue Example

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/system/freertos_idf.html

Shows the setup for receiving items from a queue, where items are removed upon successful receipt.

```c
struct AMessage
{
 char ucMessageID;
 char ucData[ 20 ];
} xMessage;

QueueHandle_t xQueue;

// Task to create a queue and post a value.
void vATask( void *pvParameters )
{
struct AMessage *pxMessage;
```

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

### Copy the hello_world project

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/get-started/linux-macos-start-project.html

Copies the hello_world example project from the ESP-IDF directory to the local ~/esp directory.

```bash
cd ~/esp
cp -r $IDF_PATH/examples/get-started/hello_world .
```

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

### uart_detect_bitrate_start

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/peripherals/uart.html

Starts the bitrate detection process for an incoming data signal. This function can be used as a standalone API without installing the UART driver.

```APIDOC
## esp_err_t uart_detect_bitrate_start(uart_port_t uart_num, const uart_bitrate_detect_config_t *config)

### Description
Starts bitrate detection for an incoming data signal. It is recommended to use an alternating bit sequence like 0x55 or 0xAA for measurement.

### Parameters
- **uart_num** (uart_port_t) - Required - The ID of the UART port to be used. Only HP UART ports are supported.
- **config** (const uart_bitrate_detect_config_t*) - Required - Pointer to the configuration structure. Ignored if the port is already acquired.

### Returns
- **ESP_OK** - Success
- **ESP_ERR_INVALID_ARG** - Parameter error
- **ESP_FAIL** - No free UART port or invalid source clock
```

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

### Collect Tracing Data with OpenOCD

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/app_trace.html

Examples of using the 'esp apptrace start' command with various configurations for polling, size limits, and timeouts.

```text
esp apptrace start file://trace.log 1 2048 5 0 0
```

```text
esp apptrace start file://trace.log 1 -1 -1 0 0
```

```text
esp apptrace start file://trace.log 0 -1 -1 0 0
```

```text
esp apptrace start file://trace.log 0 2048 -1 1 0
```

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

### Build and flash the firmware

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/ble/get-started/ble-introduction.html

Compiles the project, flashes the binary to the connected board, and opens the serial monitor.

```bash
$ idf.py flash monitor
```

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

### Start the graphical configuration tool

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/tools/idf-py.html

Launches the menuconfig interface for project configuration.

```bash
idf.py menuconfig
```

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

### Build the Project

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/get-started/windows-setup.html

Compiles the application and components, generating the necessary bootloader and partition table binaries.

```bash
idf.py build
```

```bash
$ idf.py build
Running cmake in directory /path/to/hello_world/build
Executing "cmake -G Ninja --warn-uninitialized /path/to/hello_world"...
Warn about uninitialized values.
-- Found Git: /usr/bin/git (found version "2.17.0")
-- Building empty aws_iot component due to configuration
-- Component names: ...
-- Component paths: ...

... (more lines of build system output)

[527/527] Generating hello_world.bin
esptool.py v2.3.1

Project build complete. To flash, run this command:
../../../components/esptool_py/esptool/esptool.py -p (PORT) -b 921600 write_flash --flash_mode dio --flash_size detect --flash_freq 40m 0x10000 build/hello_world.bin  build 0x1000 build/bootloader/bootloader.bin 0x8000 build/partition_table/partition-table.bin
or run 'idf.py -p PORT flash'
```

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

### GDB initialization script for RAM loading

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/kconfig-reference.html

Example GDB script to initialize the target and load an application into RAM for debugging.

```gdb
# Connect to a running instance of OpenOCD target remote :3333 # Reset and halt the target mon reset halt # Run to a specific point in ROM code, # where most of initialization is complete. thb *0x40007d54 c # Load the application into RAM load # Run till app_main tb app_main c
```

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

### Install pre-commit package

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/contribute/install-pre-commit-hook.html

Install the pre-commit tool using pip.

```bash
pip install pre-commit
```

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

### Install GDBGUI support

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/jtag-debugging/using-debugger.html

Command to enable GDBGUI functionality during the installation process.

```bash
install.sh --enable-gdbgui
```

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

### Initialize and Configure Touch Element

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/peripherals/touch_element.html

Demonstrates the standard initialization sequence including global configuration, element installation, event subscription, and callback registration.

```c
static touch_xxx_handle_t element_handle; //Declare a touch element handle

//Define the subscribed event handler
void event_handler(touch_xxx_handle_t out_handle, touch_xxx_message_t out_message, void *arg)
{
    //Event handler logic
}

void app_main()
{
    //Using the default initializer to config Touch Element library
    touch_elem_global_config_t global_config = TOUCH_ELEM_GLOBAL_DEFAULT_CONFIG();
    touch_element_install(&global_config);

    //Using the default initializer to config Touch elements
    touch_xxx_global_config_t elem_global_config = TOUCH_XXXX_GLOBAL_DEFAULT_CONFIG();
    touch_xxx_install(&elem_global_config);

    //Create a new instance
    touch_xxx_config_t element_config = {
        ...
        ...
    };
    touch_xxx_create(&element_config, &element_handle);

    //Subscribe the specified events by using the event mask
    touch_xxx_subscribe_event(element_handle, TOUCH_ELEM_EVENT_ON_PRESS | TOUCH_ELEM_EVENT_ON_RELEASE, NULL);

    //Choose CALLBACK as the dispatch method
    touch_xxx_set_dispatch_method(element_handle, TOUCH_ELEM_DISP_CALLBACK);

    //Register the callback routine
    touch_xxx_set_callback(element_handle, event_handler);

    //Start Touch Element library processing
    touch_element_start();
}
```

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

### Install and Use RMT Sync Manager

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/peripherals/rmt.html

Demonstrates initializing multiple RMT TX channels, configuring a sync manager, and triggering simultaneous transmissions.

```c
rmt_channel_handle_t tx_channels[2] = {NULL}; // declare two channels
int tx_gpio_number[2] = {0, 2};
// install channels one by one
for (int i = 0; i < 2; i++) {
    rmt_tx_channel_config_t tx_chan_config = {
        .clk_src = RMT_CLK_SRC_DEFAULT,       // select source clock
        .gpio_num = tx_gpio_number[i],    // GPIO number
        .mem_block_symbols = 64,          // memory block size, 64 * 4 = 256 Bytes
        .resolution_hz = 1 * 1000 * 1000, // 1 MHz resolution
        .trans_queue_depth = 1,           // set the number of transactions that can pend in the background
    };
    ESP_ERROR_CHECK(rmt_new_tx_channel(&tx_chan_config, &tx_channels[i]));
}
// enable the channels
for (int i = 0; i < 2; i++) {
    ESP_ERROR_CHECK(rmt_enable(tx_channels[i]));
}
// install sync manager
rmt_sync_manager_handle_t synchro = NULL;
rmt_sync_manager_config_t synchro_config = {
    .tx_channel_array = tx_channels,
    .array_size = sizeof(tx_channels) / sizeof(tx_channels[0]),
};
ESP_ERROR_CHECK(rmt_new_sync_manager(&synchro_config, &synchro));

ESP_ERROR_CHECK(rmt_transmit(tx_channels[0], led_strip_encoders[0], led_data, led_num * 3, &transmit_config));
// tx_channels[0] does not start transmission until call of `rmt_transmit()` for tx_channels[1] returns
ESP_ERROR_CHECK(rmt_transmit(tx_channels[1], led_strip_encoders[1], led_data, led_num * 3, &transmit_config));
```

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

### REG_WR Instruction Example

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/system/ulp_instruction_set.html

Example of writing 8 bits to a peripheral register.

```assembly
1:        REG_WR      0x120, 7, 0, 0x10   // set 8 bits: REG[0x120][7:0] = 0x10
```

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

### Perform Unattended Installation

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/tools/idf-windows-installer.html

Executes the installer in silent mode without user interaction.

```bash
esp-idf-tools-setup-x.x.exe /VERYSILENT /SUPPRESSMSGBOXES /SP- /NOCANCEL
```

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

### Install Clang-Tidy Binaries

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/tools/idf-clang-tidy.html

Install the necessary binaries for clang-tidy using the idf_tools script.

```bash
idf_tools.py install esp-clang
```

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

### Build Configuration Output

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/ble/get-started/ble-connection.html

Example output indicating successful project configuration.

```text
...
-- Configuring done
-- Generating done
-- Build files have been written to ...
```

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

### Install Build Dependencies

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/jtag-debugging/building-openocd-macos.html

Install required packages for compiling OpenOCD using Homebrew.

```bash
brew install automake libtool libusb wget gcc@4.9 pkg-config
```

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

### httpd_start

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/protocols/esp_http_server.html

Creates an instance of the HTTP server, allocates resources based on the provided configuration, and returns a handle to the server instance.

```APIDOC
## httpd_start

### Description
Creates an instance of the HTTP server, allocates memory/resources for it based on the specified configuration, and outputs a handle to the server instance.

### Parameters
- **config** (httpd_config_t) - Required - Configuration structure containing task priority, stack size, and other server settings.
```

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

### REG_RD Instruction Example

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/system/ulp_instruction_set.html

Example of reading 4 bits from a peripheral register into R0.

```assembly
1:        REG_RD      0x120, 7, 4     // load 4 bits: R0 = {12'b0, REG[0x120][7:4]}
```

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

### Example Build Directory Structure

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/contribute/esp-idf-tests-with-pytest.html

Visual representation of the build directory structure for various targets and configurations.

```text
.
├── build_esp32_history/
│   └── ...
├── build_esp32_nohistory/
│   └── ...
├── build_esp32s2_history/
│   └── ...
├── ...
├── main/
├── CMakeLists.txt
├── sdkconfig.ci.history
├── sdkconfig.ci.nohistory
└── ...
```

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

### Example Mapping for libfreertos.a

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/linker-script-generation.html

A practical example of mapping all objects in libfreertos.a to the noflash scheme.

```text
[mapping:map]
archive: libfreertos.a
entries:
    * (noflash)
```

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

### Configure the project target and settings

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/get-started/linux-macos-start-project.html

Navigates to the project directory, sets the target chip to esp32s3, and opens the menuconfig utility.

```bash
cd ~/esp/hello_world
idf.py set-target esp32s3
idf.py menuconfig
```

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

### esp_console_start_repl

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/system/console.html

Starts the REPL environment. Once started, the REPL remains active until esp_console_stop_repl is called.

```APIDOC
## esp_console_start_repl

### Description
Starts the REPL environment. The REPL will continue to run until explicitly stopped by the user.

### Parameters
- **repl** (esp_console_repl_t*) - Required - REPL handle returned from initialization functions.

### Returns
- **ESP_OK** on success
- **ESP_ERR_INVALID_STATE** if the REPL has already started
```

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

### esp_ble_cs_security_enable

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/bluetooth/esp_gap_ble.html

Starts or restarts the Channel Sounding Security Start procedure in the local Controller.

```APIDOC
## esp_ble_cs_security_enable

### Description
This function is used to start or restart the Channel Sounding Security Start procedure in the local Controller.

### Parameters
- **conn_handle** (uint16_t) - Required - The ACL connection identified.

### Returns
- **esp_err_t** - ESP_OK on success, other values on failure.
```

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

### Initialize LwIP and Wi-Fi Prerequisites

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/network/esp-wifi-mesh.html

Perform these steps to initialize the network stack and Wi-Fi driver before starting the mesh.

```c
ESP_ERROR_CHECK(esp_netif_init());

/*  event initialization */
ESP_ERROR_CHECK(esp_event_loop_create_default());

/*  Wi-Fi initialization */
wifi_init_config_t config = WIFI_INIT_CONFIG_DEFAULT();
ESP_ERROR_CHECK(esp_wifi_init(&config));
/*  register IP events handler */
ESP_ERROR_CHECK(esp_event_handler_register(IP_EVENT, IP_EVENT_STA_GOT_IP, &ip_event_handler, NULL));
ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_FLASH));
ESP_ERROR_CHECK(esp_wifi_start());
```

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

### Enable CS Security

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/bluetooth/esp_gap_ble.html

Starts or restarts the Channel Sounding Security Start procedure.

```c
esp_err_t esp_ble_cs_security_enable(uint16_t conn_handle)
```

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

### Install pytest dependencies

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/contribute/esp-idf-tests-with-pytest.html

Commands to install base pytest dependencies and additional test-specific dependencies.

```bash
$ install.sh --enable-pytest
```

```bash
$ install.sh --enable-test-specific
```

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

### touch_element_install

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/peripherals/touch_element.html

Initializes the touch element processing system.

```APIDOC
## esp_err_t touch_element_install(const touch_elem_global_config_t *global_config)

### Description
Initializes the touch element processing system. Call touch_element_uninstall() before reinitializing.

### Parameters
- **global_config** (const touch_elem_global_config_t*) - Required - Global initialization configuration structure.

### Returns
- ESP_OK: Successfully initialized
- ESP_ERR_INVALID_ARG: Invalid argument
- ESP_ERR_NO_MEM: Insufficient memory
- ESP_ERR_INVALID_STATE: Touch element is already initialized
```

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

### touch_matrix_install

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/peripherals/touch_element.html

Initializes the touch matrix button system. This must be called before creating any matrix instances.

```APIDOC
## esp_err_t touch_matrix_install(const touch_matrix_global_config_t *global_config)

### Description
Initializes the touch matrix button object and acts on all touch matrix button instances.

### Parameters
- **global_config** (const touch_matrix_global_config_t*) - [in] - Touch matrix global initialization configuration

### Returns
- **ESP_OK**: Successfully initialized touch matrix button
- **ESP_ERR_INVALID_STATE**: Touch element library was not initialized
- **ESP_ERR_INVALID_ARG**: matrix_init is NULL
- **ESP_ERR_NO_MEM**: Insufficient memory
```

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

### Customize Tools Installation Path

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/get-started/linux-macos-setup.html

Commands to set a custom installation directory for ESP-IDF tools.

```bash
export IDF_TOOLS_PATH="$HOME/required_idf_tools_path"
./install.sh

. ./export.sh
```

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

### Install ESP-IDF Tools

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/get-started/linux-macos-setup.html

Scripts to install tools for specific chip targets or all supported targets.

```bash
cd ~/esp/esp-idf
./install.sh esp32s3
```

```fish
cd ~/esp/esp-idf
./install.fish esp32s3
```

```bash
cd ~/esp/esp-idf
./install.sh esp32,esp32s2
```

```fish
cd ~/esp/esp-idf
./install.fish esp32,esp32s2
```

```bash
cd ~/esp/esp-idf
./install.sh all
```

```fish
cd ~/esp/esp-idf
./install.fish all
```

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

### Create and use software timers

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/system/freertos_idf.html

Demonstrates initializing multiple timers with a shared callback function and starting them before the scheduler begins.

```c
* #define NUM_TIMERS 5
*
* // An array to hold handles to the created timers.
* TimerHandle_t xTimers[ NUM_TIMERS ];
*
* // An array to hold a count of the number of times each timer expires.
* int32_t lExpireCounters[ NUM_TIMERS ] = { 0 };
*
* // Define a callback function that will be used by multiple timer instances.
* // The callback function does nothing but count the number of times the
* // associated timer expires, and stop the timer once the timer has expired
* // 10 times.
* void vTimerCallback( TimerHandle_t pxTimer )
* {
* int32_t lArrayIndex;
* const int32_t xMaxExpiryCountBeforeStopping = 10;
*
*     // Optionally do something if the pxTimer parameter is NULL.
*     configASSERT( pxTimer );
*
*     // Which timer expired?
*     lArrayIndex = ( int32_t ) pvTimerGetTimerID( pxTimer );
*
*     // Increment the number of times that pxTimer has expired.
*     lExpireCounters[ lArrayIndex ] += 1;
*
*     // If the timer has expired 10 times then stop it from running.
*     if( lExpireCounters[ lArrayIndex ] == xMaxExpiryCountBeforeStopping )
*     {
*         // Do not use a block time if calling a timer API function from a
*         // timer callback function, as doing so could cause a deadlock!
*         xTimerStop( pxTimer, 0 );
*     }
* }
*
* void main( void )
* {
* int32_t x;
*
*     // Create then start some timers.  Starting the timers before the scheduler
*     // has been started means the timers will start running immediately that
*     // the scheduler starts.
*     for( x = 0; x < NUM_TIMERS; x++ )
*     {
*         xTimers[ x ] = xTimerCreate(    "Timer",             // Just a text name, not used by the kernel.
*                                         ( 100 * ( x + 1 ) ), // The timer period in ticks.
*                                         pdTRUE,              // The timers will auto-reload themselves when they expire.
*                                         ( void * ) x,        // Assign each timer a unique id equal to its array index.
*                                         vTimerCallback       // Each timer calls the same callback when it expires.
*                                     );
*
*         if( xTimers[ x ] == NULL )
*         {
*             // The timer was not created.
*         }
*         else
*         {
*             // Start the timer.  No block time is specified, and even if one was
*             // it would be ignored because the scheduler has not yet been
*             // started.
*             if( xTimerStart( xTimers[ x ], 0 ) != pdPASS )
*             {
*                 // The timer could not be set into the Active state.
*             }
*         }
*     }
*
*     // ...
*     // Create tasks here.
*     // ...
*
*     // Starting the scheduler will start the timers running as they have already
*     // been set into the active state.
*     vTaskStartScheduler();
*
*     // Should not reach here.
*     for( ;; );
* }
```

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

### Install Python 3 on macOS

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/get-started/linux-macos-setup.html

Commands to install Python 3 using HomeBrew or MacPorts.

```bash
brew install python3
```

```bash
sudo port install python38
```

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

### Install Prerequisites on Linux

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/get-started/linux-macos-setup.html

Commands to install required build packages for various Linux distributions.

```bash
sudo apt-get install git wget flex bison gperf python3 python3-pip python3-venv cmake ninja-build ccache libffi-dev libssl-dev dfu-util libusb-1.0-0
```

```bash
sudo yum -y update && sudo yum install git wget flex bison gperf python3 cmake ninja-build ccache dfu-util libusbx
```

```bash
sudo pacman -S --needed gcc git make flex bison gperf python cmake ninja ccache dfu-util libusb python-pip
```

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

### Example Bootloader Image Info Output

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/system/bootloader_image_format.html

Sample output generated by the esptool.py image_info command.

```text
File size: 26576 (bytes)

ESP32 image header
==================
Image version: 1
Entry point: 0x40080658
Segments: 4
Flash size: 2MB
Flash freq: 40m
Flash mode: DIO

ESP32 extended image header
===========================
WP pin: 0xee
Flash pins drive settings: clk_drv: 0x0, q_drv: 0x0, d_drv: 0x0, cs0_drv: 0x0, hd_drv: 0x0, wp_drv: 0x0
Chip ID: 0
Minimal chip revision: v0.0, (legacy min_rev = 0)
Maximal chip revision: v3.99

Segments information
====================
Segment   Length   Load addr   File offs  Memory types
-------  -------  ----------  ----------  ------------
    1  0x01bb0  0x3fff0030  0x00000018  BYTE_ACCESSIBLE, DRAM, DIRAM_DRAM
    2  0x03c90  0x40078000  0x00001bd0  CACHE_APP
    3  0x00004  0x40080400  0x00005868  IRAM
    4  0x00f2c  0x40080404  0x00005874  IRAM

ESP32 image footer
==================
Checksum: 0x65 (valid)
Validation hash: 6f31a7f8512f26f6bce7c3b270f93bf6cf1ee4602c322998ca8ce27433527e92 (valid)

Bootloader information
======================
Bootloader version: 1
ESP-IDF: v5.1-dev-4304-gcb51a3b-dirty
Compile time: Mar 30 2023 19:14:17
```

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

### Verify OpenOCD Installation

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/jtag-debugging/index.html

Check the installed version of OpenOCD to ensure the environment is correctly set up.

```bash
openocd --version
```

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

### Create a static software timer

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/system/freertos_idf.html

Example demonstrating the definition of a timer callback and the static creation of a timer instance.

```c
*
* // The buffer used to hold the software timer's data structure.
* static StaticTimer_t xTimerBuffer;
*
* // A variable that will be incremented by the software timer's callback
* // function.
* UBaseType_t uxVariableToIncrement = 0;
*
* // A software timer callback function that increments a variable passed to
* // it when the software timer was created.  After the 5th increment the
* // callback function stops the software timer.
* static void prvTimerCallback( TimerHandle_t xExpiredTimer )
* {
* UBaseType_t *puxVariableToIncrement;
* BaseType_t xReturned;
*
*     // Obtain the address of the variable to increment from the timer ID.
*     puxVariableToIncrement = ( UBaseType_t * ) pvTimerGetTimerID( xExpiredTimer );
*
*     // Increment the variable to show the timer callback has executed.
*     ( *puxVariableToIncrement )++;
*
*     // If this callback has executed the required number of times, stop the
*     // timer.
*     if( *puxVariableToIncrement == 5 )
*     {
*         // This is called from a timer callback so must not block.
*         xTimerStop( xExpiredTimer, staticDONT_BLOCK );
*     }
* }
*
*
* void main( void )
* {
*     // Create the software time.  xTimerCreateStatic() has an extra parameter
*     // than the normal xTimerCreate() API function.  The parameter is a pointer
*     // to the StaticTimer_t structure that will hold the software timer
*     // structure.  If the parameter is passed as NULL then the structure will be
*     // allocated dynamically, just as if xTimerCreate() had been called.
*     xTimer = xTimerCreateStatic( "T1",             // Text name for the task.  Helps debugging only.  Not used by FreeRTOS.
*                                  xTimerPeriod,     // The period of the timer in ticks.
*                                  pdTRUE,           // This is an auto-reload timer.
*                                  ( void * ) &uxVariableToIncrement,    // A variable incremented by the software timer's callback function
```

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

### STI Instruction Examples

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/system/ulp_instruction_set.html

Examples showing the use of STI to store data with auto-incrementing offsets.

```assembly
1:        STO  4                  // Set offset to 4
          STI  R1, R2             // MEM[R2 + 4 / 4][15:0] = R1
          STI  R1, R2             // MEM[R2 + 4 / 4][31:16] = R1
                                  // offset += (1 * 4) //offset is incremented by 1 word
          STI  R1, R2             // MEM[R2 + 8 / 4][15:0] = R1
          STI  R1, R2             // MEM[R2 + 8 / 4][31:16] = R1
```

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

### touch_button_install

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/peripherals/touch_element.html

Initializes the touch button global configuration for all touch button instances.

```APIDOC
## esp_err_t touch_button_install(const touch_button_global_config_t *global_config)

### Description
Initializes touch button global settings and acts on all touch button instances.

### Parameters
- **global_config** (const touch_button_global_config_t *) - Required - Button object initialization configuration

### Returns
- **ESP_OK**: Successfully initialized touch button
- **ESP_ERR_INVALID_STATE**: Touch element library was not initialized
- **ESP_ERR_INVALID_ARG**: button_init is NULL
- **ESP_ERR_NO_MEM**: Insufficient memory
```

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

### Run Application in QEMU

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/tools/qemu.html

Starts the application in QEMU and connects the IDF monitor to the emulated UART port.

```bash
idf.py qemu monitor
```

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

### ST Instruction Examples

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/system/ulp_instruction_set.html

Examples of storing 16-bit values to memory using the ST instruction.

```assembly
1:        ST  R1, R2, 0x12        // MEM[R2 + 0x12 / 4] = R1

2:        .data                   // Data section definition
  Addr1:  .word     123           // Define label Addr1 16 bit
          .set      offs, 0x00    // Define constant offs
          .text                   // Text section definition
          MOVE      R1, 1         // R1 = 1
          MOVE      R2, Addr1     // R2 = Addr1
          ST        R1, R2, offs  // MEM[R2 +  0 / 4] = R1
                                  // MEM[Addr1 + 0] will be 32'h600001
```

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

### Start Provisioning Service

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/provisioning/wifi_provisioning.html

Initializes the provisioning service with a specified security scheme and proof of possession.

```C
const char *service_name = "my_device";
const char *service_key  = "password";

wifi_prov_security_t security = WIFI_PROV_SECURITY_1;
const char *pop = "abcd1234";

ESP_ERROR_CHECK( wifi_prov_mgr_start_provisioning(security, pop, service_name, service_key) );
```

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

### ROM Code Decoding Example

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/tools/idf-monitor.html

Example output when a crash involves code located in ROM.

```text
abort() was called at PC 0x40007c69 on core 0
0x40007c69: ets_write_char in ROM

Backtrace: 0x40081656:0x3ffb4ac0 0x40085729:0x3ffb4ae0 0x4008a7ce:0x3ffb4b00 0x40007c69:0x3ffb4b70 0x40008148:0x3ffb4b90 0x400d51d7:0x3ffb4c20 0x400e31bc:0x3ffb4c50 0x40087bc5:0x3ffb4c80
0x40081656: panic_abort at /Users/espressif/esp-idf/components/esp_system/panic.c:452
0x40085729: esp_system_abort at /Users/espressif/esp-idf/components/esp_system/port/esp_system_chip.c:90
0x4008a7ce: abort at /Users/espressif/esp-idf/components/newlib/abort.c:38
0x40007c69: ets_write_char in ROM
0x40008148: ets_printf in ROM
0x400d51d7: app_main at /Users/espressif/esp-idf/examples/get-started/hello_world/main/hello_world_main.c:49
0x400e31bc: main_task at /Users/espressif/esp-idf/components/freertos/app_startup.c:208 (discriminator 13)
0x40087bc5: vPortTaskWrapper at /Users/espressif/esp-idf/components/freertos/FreeRTOS-Kernel/portable/xtensa/port.c:162
.....
```

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

### Enable documentation dependencies

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/contribute/documenting-code.html

Run this command to install the esp-docs Python package required for building documentation.

```bash
./install.sh --enable-docs
```

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

### ESP_ERROR_CHECK failure output example

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/error-handling.html

Example of the console output generated when an ESP_ERROR_CHECK macro fails.

```text
ESP_ERROR_CHECK failed: esp_err_t 0x107 (ESP_ERR_TIMEOUT) at 0x400d1fdf

file: "/Users/user/esp/example/main/main.c" line 20
func: app_main
expression: sdmmc_card_init(host, &card)

Backtrace: 0x40086e7c:0x3ffb4ff0 0x40087328:0x3ffb5010 0x400d1fdf:0x3ffb5030 0x400d0816:0x3ffb5050
```

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

### temperature_sensor_install

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/peripherals/temp_sensor.html

Instantiates the temperature sensor and returns a handle based on the provided configuration.

```APIDOC
## temperature_sensor_install

### Description
Installs the temperature sensor instance and returns a handle for further operations.

### Parameters
- **config** (temperature_sensor_config_t*) - Required - Pointer to the configuration structure containing range_min, range_max, and allow_pd.
- **ret_handle** (temperature_sensor_handle_t*) - Required - Pointer to store the returned sensor handle.
```

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

### Install Build Tools on macOS

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/get-started/linux-macos-setup.html

Commands to install CMake, Ninja, and dfu-util using package managers.

```bash
brew install cmake ninja dfu-util
```

```bash
sudo port install cmake ninja dfu-util
```

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

### esp_mqtt_client_start

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/protocols/mqtt.html

Starts the MQTT client with a previously created handle.

```APIDOC
## esp_err_t esp_mqtt_client_start(esp_mqtt_client_handle_t client)

### Description
Starts the MQTT client using an already created client handle.

### Parameters
- **client** (esp_mqtt_client_handle_t) - Required - MQTT client handle

### Returns
- **esp_err_t** - ESP_OK on success, ESP_ERR_INVALID_ARG on wrong initialization, ESP_FAIL on other error
```

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

### SDKCONFIG_DEFAULTS Application Order Example

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/migration-guides/release-5.x/5.0/build-system.html

Illustrates the order in which configuration files are applied when SDKCONFIG_DEFAULTS contains multiple entries and target-specific files exist.

```text
If ``SDKCONFIG_DEFAULTS="sdkconfig.defaults;sdkconfig_devkit1"``, and there is a file ``sdkconfig.defaults.esp32`` in the same folder, then the files will be applied in the following order: (1) sdkconfig.defaults (2) sdkconfig.defaults.esp32 (3) sdkconfig_devkit1.
```

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

### Launch QEMU with Graphics Support

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/tools/qemu.html

Enables the virtual framebuffer device for testing graphics applications.

```bash
idf.py qemu --graphics monitor
```

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

### Wait for Unattended Installation in PowerShell

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/tools/idf-windows-installer.html

Runs the installer and waits for the background process to complete using PowerShell.

```powershell
esp-idf-tools-setup-x.x.exe /VERYSILENT /SUPPRESSMSGBOXES /SP- /NOCANCEL
$InstallerProcess = Get-Process esp-idf-tools-setup
Wait-Process -Id $InstallerProcess.id
```

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

### Implement C++ Classes and Namespaces

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/contribute/style-guide.html

Example demonstrating namespace usage, class inheritance, and template definitions.

```cpp
// file spaceship.h
#ifndef SPACESHIP_H_
#define SPACESHIP_H_
#include <cstdlib>

namespace spaceships {

class SpaceShip {
public:
    SpaceShip(size_t crew);
    size_t get_crew_size() const;

private:
    const size_t crew;
};

class SpaceShuttle : public SpaceShip {
public:
    SpaceShuttle();
};

class Sojuz : public SpaceShip {
public:
    Sojuz();
};

template <typename T>
class CargoShip {
public:
    CargoShip(const T &cargo);

private:
    T cargo;
};

} // namespace spaceships

#endif // SPACESHIP_H_

// file spaceship.cpp
#include "spaceship.h"

namespace spaceships {

// Putting the curly braces in the same line for constructors is OK if it only initializes
// values in the initializer list
SpaceShip::SpaceShip(size_t crew) : crew(crew) { }

size_t SpaceShip::get_crew_size() const
{
    return crew;
}

SpaceShuttle::SpaceShuttle() : SpaceShip(7)
{
    // doing further initialization
}

Sojuz::Sojuz() : SpaceShip(3)
{
    // doing further initialization
}

template <typename T>
CargoShip<T>::CargoShip(const T &cargo) : cargo(cargo) { }

} // namespace spaceships
```

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

### Install Build Dependencies

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/jtag-debugging/building-openocd-linux.html

Installs the required system packages for compiling OpenOCD on Debian-based Linux distributions.

```bash
sudo apt-get install make
sudo apt-get install libtool
sudo apt-get install pkg-config
sudo apt-get install autoconf
sudo apt-get install automake
sudo apt-get install texinfo
sudo apt-get install libusb-1.0
```

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

### STL Instruction Examples

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/system/ulp_instruction_set.html

Examples of storing 16-bit values to the lower half-word of memory using STL.

```assembly
1:        STL  R1, R2, 0x12           // MEM[R2 + 0x12 / 4] = R1

2:        .data                       // Data section definition
  Addr1:  .word     123               // Define label Addr1 16 bit
          .set      offs, 0x00        // Define constant offs
          .text                       // Text section definition
          MOVE      R1, 1             // R1 = 1
          MOVE      R2, Addr1         // R2 = Addr1
          STL       R1, R2, offs      // MEM[R2 +  0 / 4] = R1
                                      // MEM[Addr1 + 0] will be 32'hxxxx0001
3:
          MOVE      R1, 1             // R1 = 1
          STL       R1, R2, 0x12, 1   // MEM[R2 + 0x12 / 4] = 0xxxxx4001
```

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

### Build and Test Multiple SDKConfigs via CI Script

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/contribute/esp-idf-tests-with-pytest.html

Use the CI helper script to build and test multiple configurations simultaneously.

```bash
$ cd $IDF_PATH/examples/system/console/basic
$ python $IDF_PATH/tools/ci/ci_build_apps.py . --target esp32 -v --pytest-apps
$ pytest --target esp32
```

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

### Complete Mapping Fragment Example

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/linker-script-generation.html

A full mapping fragment example demonstrating the use of multiple flags.

```text
[mapping:name]
archive: lib1.a
entries:
    obj1 (noflash);
        rodata -> dram0_data KEEP() SORT() ALIGN(8) SURROUND(my_sym)
```

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

### Initialize Temperature Sensor

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-reference/peripherals/temp_sensor.html

Configure the sensor with a specific temperature range and install the driver to obtain a handle.

```c
temperature_sensor_handle_t temp_handle = NULL;
temperature_sensor_config_t temp_sensor_config = TEMPERATURE_SENSOR_CONFIG_DEFAULT(20, 50);
ESP_ERROR_CHECK(temperature_sensor_install(&temp_sensor_config, &temp_handle));
```

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

### Define sdkconfig defaults files

Source: https://docs.espressif.com/projects/esp-idf/en/release-v5.5/esp32s3/api-guides/build-system.html

List of files present in the project directory for the provided examples.

```text
sdkconfig.defaults
sdkconfig.defaults.esp32
sdkconfig_devkit1
```
Tokens:
Raw