ESP-IDF

https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/
Admin
ESP-IDF is the official development framework for Espressif's ESP32, ESP32-S, ESP32-C, ESP32-H and...
Tokens:2,066,762
Snippets:14,835
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### Configure, install, and start TWAI driver with twai_driver_install() and twai_start()

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/api-reference/peripherals/twai.html

Configures and installs the TWAI driver using macro initializers, then starts it. Uses GPIO_NUM_21 and GPIO_NUM_22 for TX/RX and TWAI_MODE_NORMAL. Macro initializers are optional; configuration structures can be set manually.

```c
#include "driver/gpio.h"
#include "driver/twai.h"

void app_main()
{
    // Initialize configuration structures using macro initializers
    twai_general_config_t g_config = TWAI_GENERAL_CONFIG_DEFAULT(GPIO_NUM_21, GPIO_NUM_22, TWAI_MODE_NORMAL);
    twai_timing_config_t t_config = TWAI_TIMING_CONFIG_500KBITS();
    twai_filter_config_t f_config = TWAI_FILTER_CONFIG_ACCEPT_ALL();

    // Install TWAI driver
    if (twai_driver_install(&g_config, &t_config, &f_config) == ESP_OK) {
        printf("Driver installed\n");
    } else {
        printf("Failed to install driver\n");
        return;
    }

    // Start TWAI driver
    if (twai_start() == ESP_OK) {
        printf("Driver started\n");
    } else {
        printf("Failed to start driver\n");
        return;
    }

    ...

}

```

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

### Configure and start ULP LP core with ulp_lp_core_run

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/api-reference/system/ulp-lp-core.html

Configures the ULP LP core with a wake-up source and sleep duration, then starts it using ulp_lp_core_run(). The example uses ULP_LP_CORE_WAKEUP_SOURCE_LP_TIMER with a 10 ms sleep duration.

```c
ulp_lp_core_cfg_t cfg = {
    .wakeup_source = ULP_LP_CORE_WAKEUP_SOURCE_LP_TIMER, // LP core will be woken up periodically by LP timer
    .lp_timer_sleep_duration_us = 10000,
};

ESP_ERROR_CHECK( ulp_lp_core_run(&cfg) );

```

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

### Launch GDB with generated init files for ESP32-C6 debugging

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

This workflow starts with the prerequisite step to configure the ESP32-C6 target, then navigates to the project directory, shows the generated GDB init file paths in build/project_description.json, launches GDB with the init files, and finishes with a sample GDB session log that ends at the (gdb) prompt. The command example includes the '-q' option to minimize startup output and expects the GDB init file 'build/gdbinit/connect' to establish a connection.

```shell
cd ~/esp/blink
```

```json
"gdbinit_files": {
    "01_symbols": "application_path/build/gdbinit/symbols",
    "02_prefix_map": "application_path/build/gdbinit/prefix_map",
    "03_py_extensions": "application_path/build/gdbinit/py_extensions",
    "04_connect": "application_path/build/gdbinit/connect"
}
```

```bash
riscv32-esp-elf-gdb -q -x build/gdbinit/symbols -x build/gdbinit/prefix_map -x build/gdbinit/connect build/blink.elf
```

```text
riscv32-esp-elf-gdb -q -x build/gdbinit/symbols -x build/gdbinit/prefix_map -x build/gdbinit/connect build/blink.elf

user-name@computer-name:~/esp-idf/examples/get-started/blink$ riscv32-esp-elf-gdb -q -x build/gdbinit/symbols -x build/gdbinit/connect build/blink.elf
Reading symbols from build/blink.elf...
add symbol table from file "/home/user-name/esp-idf/examples/get-started/blink/build/bootloader/bootloader.elf"
[Switching to Thread 1070141764]
app_main () at /home/user-name/esp-idf/examples/get-started/blink/main/blink_example_main.c:95
95          configure_led();
add symbol table from file "/home/alex/.espressif/tools/esp-rom-elfs/20241011/esp32c6_rev0_rom.elf"
JTAG tap: esp32c6.tap0 tap/device found: 0x00005c25 (mfg: 0x612 (Espressif Systems), part: 0x0005, ver: 0x0)
[esp32c6] Reset cause (3) - (Software core reset)
Hardware assisted breakpoint 1 at 0x42009436: file /home/user-name/esp-idf/examples/get-started/blink/main/blink_example_main.c, line 92.
[Switching to Thread 1070139884]

Thread 2 "main" hit Temporary breakpoint 1, app_main () at /home/user-name/esp-idf/examples/get-started/blink/main/blink_example_main.c:92
92      {
(gdb)
```

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

### RMT Sync Manager Setup and Simultaneous Transmission

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/api-reference/peripherals/rmt.html

This example shows how to install multiple RMT TX channels, create a sync manager, and start simultaneous transmission. It includes channel configuration, enabling, sync manager creation, and calling rmt_transmit() on all channels. Note that transmission starts only after rmt_transmit() is called on all managed channels.

```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));
```

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

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

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

Installs esptool via pip on Linux or macOS and then starts the RFC2217 server for the serial device /dev/ttyUSB0.

```bash
pip install esptool

```

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

```

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

### Copy hello_world example to ~/esp

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

Copy the get-started/hello_world example project from the ESP-IDF examples directory to the ~/esp directory. The ESP-IDF build system does not support spaces in paths.

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

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

### xTimerCreateStatic example usage

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/api-reference/system/freertos_idf.html

Shows how to create a software timer with a static buffer, start it, and start the scheduler. The timer callback is defined and the timer is started before the scheduler starts.

```c
TimerHandle_t xTimerCreateStatic( TimerCallbackFunction_t pxCallbackFunction,
                                        const char * const pcTimerName,
                                        const TickType_t xTimerPeriodInTicks,
                                        const UBaseType_t uxAutoReload,
                                        void * const pvTimerID,
                                        StaticTimer_t * pxTimerBuffer );

```

```c
/* This function is called when the timer expires. */
void prvTimerCallback( TimerHandle_t xTimer )
{
    // Do something here.
}

void vAFunction( void )
{
    TimerHandle_t xTimer = NULL;
    StaticTimer_t xTimerBuffer;
    BaseType_t xReturned;

    // Create the timer, storing the timer structure in the xTimerBuffer variable.
    xTimer = xTimerCreateStatic(
                prvTimerCallback, // The function to execute when the timer expires.
                "Name",           // A text name for the timer.
                100,              // The timer period in ticks.
                pdTRUE,           // The timer will auto-reload.
                NULL,             // The timer ID.
                &xTimerBuffer );  // The buffer that will hold the software timer structure.

    // The scheduler has not started yet so a block time is not used.
    xReturned = xTimerStart( xTimer, 0 );

    // ...
    // 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( ;; );
}

```

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

### Copy hello_world project to ~/esp (Windows)

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/get-started/windows-setup.html

Copies the get-started/hello_world example from the ESP-IDF examples directory to the user's esp directory. The ESP-IDF build system does not support spaces in paths to ESP-IDF or projects.

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

```

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

### Basic HTTP Server with GET and POST Handlers

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/api-reference/protocols/esp_http_server.html

Registers URI handlers for GET and POST requests on /uri, starts the server, and handles incoming requests. Use as a starting point for an HTTP server.

```c
/* Our URI handler function to be called during GET /uri request */
esp_err_t get_handler(httpd_req_t *req)
{
    /* Send a simple response */
    const char resp[] = "URI GET Response";
    httpd_resp_send(req, resp, HTTPD_RESP_USE_STRLEN);
    return ESP_OK;
}

/* Our URI handler function to be called during POST /uri request */
esp_err_t post_handler(httpd_req_t *req)
{
    /* Destination buffer for content of HTTP POST request.
     * httpd_req_recv() accepts char* only, but content could
     * as well be any binary data (needs type casting).
     * In case of string data, null termination will be absent, and
     * content length would give length of string */
    char content[100];

    /* Truncate if content length larger than the buffer */
    size_t recv_size = MIN(req->content_len, sizeof(content));

    int ret = httpd_req_recv(req, content, recv_size);
    if (ret <= 0) {  /* 0 return value indicates connection closed */
        /* Check if timeout occurred */
        if (ret == HTTPD_SOCK_ERR_TIMEOUT) {
            /* In case of timeout one can choose to retry calling
             * httpd_req_recv(), but to keep it simple, here we
             * respond with an HTTP 408 (Request Timeout) error */
            httpd_resp_send_408(req);
        }
        /* In case of error, returning ESP_FAIL will
         * ensure that the underlying socket is closed */
        return ESP_FAIL;
    }

    /* Send a simple response */
    const char resp[] = "URI POST Response";
    httpd_resp_send(req, resp, HTTPD_RESP_USE_STRLEN);
    return ESP_OK;
}

/* URI handler structure for GET /uri */
httpd_uri_t uri_get = {
    .uri      = "/uri",
    .method   = HTTP_GET,
    .handler  = get_handler,
    .user_ctx = NULL
};

/* URI handler structure for POST /uri */
httpd_uri_t uri_post = {
    .uri      = "/uri",
    .method   = HTTP_POST,
    .handler  = post_handler,
    .user_ctx = NULL
};

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

    /* Empty handle to esp_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;
}

/* Function for stopping the webserver */
void stop_webserver(httpd_handle_t server)
{
    if (server) {
        /* Stop the httpd server */
        httpd_stop(server);
    }
}

```

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

### PowerShell script to wait for unattended installation

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

Starts the silent installer and then waits for the installer process to complete. The installer detaches from the command line, so this script ensures the command line is not blocked.

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

```

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

### Navigate to NimBLE_Connection example directory

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

Command to change into the example directory. Replace <ESP-IDF Path> with your local ESP-IDF folder path.

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

```

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

### Start Web Server with httpd_start

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/api-reference/protocols/esp_http_server.html

Creates an HTTP server instance with default configuration and registers URI handlers. Returns NULL if the server fails to start.

```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;
}

```

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

### Start Ethernet Driver

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/api-reference/network/esp_eth.html

Starts the Ethernet driver state machine. Must be called after driver installation.

```c
esp_eth_start(eth_handle); // start Ethernet driver state machine

```

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

### xTimerCreate example: create and start multiple timers

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/api-reference/system/freertos_idf.html

Example usage of xTimerCreate. It creates five timers with different periods, assigns each a unique ID, and starts them before the scheduler starts. The callback counts expirations and stops the timer after 10 expirations. Note the warning about not using a block time in a timer callback to avoid deadlock.

```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( ;; );
* }
*
```

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

### Set target and run menuconfig (Windows)

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/get-started/windows-setup.html

Navigates to the hello_world directory, sets ESP32-C6 as the target, and opens the project configuration utility. Existing builds and configurations are cleared when setting the target. The target can be saved in an environment variable to skip this step.

```batch
cd %userprofile%\esp\hello_world
idf.py set-target esp32c6
idf.py menuconfig

```

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

### Navigate to NimBLE_GATT_Server example directory

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

Use this command to change to the example directory. Replace <ESP-IDF Path> with your local ESP-IDF folder path.

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

```

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

### esp_mesh_get_root_healing_delay

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

Gets the delay time before network starts root healing.

```APIDOC
## esp_mesh_get_root_healing_delay

### Description
Get delay time before network starts root healing.

### Function Signature
`int esp_mesh_get_root_healing_delay(void)`

### Returns
- delay time in milliseconds
```

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

### Set target and run menuconfig

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

Navigate to the hello_world directory, set ESP32-C6 as the target, and run the project configuration utility menuconfig. Existing builds and configurations are cleared when setting the target.

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

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

### esp_console_start_repl

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/api-reference/system/console.html

Start REPL environment. Once the REPL gets started, it won't be stopped until the user calls repl->del(repl) to destroy the REPL environment.

```APIDOC
## esp_console_start_repl

### Description
Start REPL environment. Once the REPL gets started, it won't be stopped until the user calls repl->del(repl) to destroy the REPL environment.

### Function Signature
esp_err_t esp_console_start_repl(esp_console_repl_t *repl)

### Parameters
- **repl** (esp_console_repl_t *) - [in] REPL handle returned from esp_console_new_repl_xxx.

### Returns
- ESP_OK on success
- ESP_ERR_INVALID_STATE, if repl has started already
```

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

### httpd_start()

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/api-reference/protocols/esp_http_server.html

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

```APIDOC
## httpd_start()

### Description
Creates an instance of HTTP server, allocate memory/resources for it depending upon the specified configuration and outputs a handle to the server instance. The server has both, a listening socket (TCP) for HTTP traffic, and a control socket (UDP) for control signals, which are selected in a round robin fashion in the server task loop. The task priority and stack size are configurable during server instance creation by passing `httpd_config_t` structure to `httpd_start()`.

### Parameters
- **config** (`httpd_config_t`) - Required - Configuration structure for the server instance, including task priority and stack size.
- **handle** (output) - Required - Handle to the server instance.

### Returns
- Handle to the server instance (output parameter).

```

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

### Install Async Memcpy Driver

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/api-reference/system/async_memcpy.html

Example showing how to initialize the driver configuration with default settings, adjust the backlog, and install the driver using the generic esp_async_memcpy_install function.

```c
async_memcpy_config_t config = ASYNC_MEMCPY_DEFAULT_CONFIG();
// update the maximum data stream supported by underlying DMA engine
config.backlog = 8;
async_memcpy_handle_t driver = NULL;
ESP_ERROR_CHECK(esp_async_memcpy_install(&config, &driver)); // install driver with default DMA engine
```

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

### Open project in VSCode

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

After navigating to the example directory, use this command to open the project in VSCode.

```bash
$ code .

```

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

### xTimerStopFromISR example usage

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/api-reference/system/freertos_idf.html

Example usage of xTimerStopFromISR() in an interrupt service routine. The example assumes the timer has already been created and started. It checks the return value for failure and demonstrates the need to perform a context switch if xHigherPriorityTaskWoken is set to pdTRUE.

```c
// This scenario assumes xTimer has already been created and started.  When
// an interrupt occurs, the timer should be simply stopped.

// The interrupt service routine that stops the timer.
void vAnExampleInterruptServiceRoutine( void )
{
BaseType_t xHigherPriorityTaskWoken = pdFALSE;

    // The interrupt has occurred - simply stop the timer.
    // xHigherPriorityTaskWoken was set to pdFALSE where it was defined
    // (within this function).  As this is an interrupt service routine, only
    // FreeRTOS API functions that end in "FromISR" can be used.
    if( xTimerStopFromISR( xTimer, &xHigherPriorityTaskWoken ) != pdPASS )
    {
        // The stop command was not executed successfully.  Take appropriate
        // action here.
    }

    // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch
    // should be performed.  The syntax required to perform a context switch
    // from inside an ISR varies from port to port, and from compiler to
    // compiler.  Inspect the demos for the port you are using to find the
    // actual syntax required.
    if( xHigherPriorityTaskWoken != pdFALSE )
    {
        // Call the interrupt safe yield function here (actual function
        // depends on the FreeRTOS port being used).
    }
}
```

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

### esp_mqtt_client_start

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/api-reference/protocols/mqtt.html

Starts the MQTT client with an already created client handle.

```APIDOC
## esp_mqtt_client_start

### Description
Starts MQTT client with already created client handle.

### Function Signature
`esp_err_t esp_mqtt_client_start(esp_mqtt_client_handle_t client)`

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

### Returns
- ESP_OK on success
- ESP_ERR_INVALID_ARG on wrong initialization
- ESP_FAIL on other error

```

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

### macOS SSL certificate error

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

Example error message shown on macOS when SSL certificate verification fails during installation. Run 'Install Certificates.command' in the Python folder to fix.

```text
<urlopen error [SSL: CERTIFICATE_VERIFY_FAILED] certificate verify failed: unable to get local issuer certificate (_ssl.c:xxx)

```

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

### Build Documentation with build-docs build

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/contribute/documenting-code.html

Run this command from the docs folder to build the documentation after installing dependencies.

```bash
build-docs build
```

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

### esp_wifi_get_max_tx_power

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/api-reference/network/esp_wifi.html

Gets the maximum transmitting power after WiFi start. The power value is returned in units of 0.25dBm.

```APIDOC
## esp_wifi_get_max_tx_power

### Description
Gets the maximum transmitting power after WiFi start. The power value is returned in units of 0.25dBm.

### Function Signature
`esp_err_t esp_wifi_get_max_tx_power(int8_t *power)`

### Parameters
- **power** (int8_t*) - Required - Maximum WiFi transmitting power, unit is 0.25dBm.

### Returns
- `ESP_OK`: succeed
- `ESP_ERR_WIFI_NOT_INIT`: WiFi is not initialized by esp_wifi_init
- `ESP_ERR_WIFI_NOT_STARTED`: WiFi is not started by esp_wifi_start
- `ESP_ERR_INVALID_ARG`: invalid argument
```

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

### Start the graphical configuration tool: idf.py menuconfig

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/api-guides/tools/idf-py.html

Launches the interactive menuconfig tool for configuring the project.

```bash
idf.py menuconfig

```

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

### my_post_attach_start() callback

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/api-reference/network/esp_netif_driver.html

Example post-attach callback that sets the driver configuration and starts the driver. It is called when esp_netif_attach() is invoked.

```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;
}
```

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

### Build, flash, and monitor with idf.py flash monitor

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

Connect the development board and run this command to build the firmware, flash it, and monitor serial output.

```bash
$ idf.py flash monitor

```

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

### xTaskCheckForTimeOut example: UART receive with timeout

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/api-reference/system/freertos_idf.html

Example usage of xTaskCheckForTimeOut in a UART receive function. It uses vTaskSetTimeOutState to capture the start time and xTaskCheckForTimeOut to recalculate the remaining wait time, ensuring the total blocked time does not exceed MAX_TIME_TO_WAIT.

```c
// Driver library function used to receive uxWantedBytes from an Rx buffer
// that is filled by a UART interrupt. If there are not enough bytes in the
// Rx buffer then the task enters the Blocked state until it is notified that
// more data has been placed into the buffer. If there is still not enough
// data then the task re-enters the Blocked state, and xTaskCheckForTimeOut()
// is used to re-calculate the Block time to ensure the total amount of time
// spent in the Blocked state does not exceed MAX_TIME_TO_WAIT. This
// continues until either the buffer contains at least uxWantedBytes bytes,
// or the total amount of time spent in the Blocked state reaches
// MAX_TIME_TO_WAIT - at which point the task reads however many bytes are
// available up to a maximum of uxWantedBytes.

size_t xUART_Receive( uint8_t *pucBuffer, size_t uxWantedBytes )
{
size_t uxReceived = 0;
TickType_t xTicksToWait = MAX_TIME_TO_WAIT;
TimeOut_t xTimeOut;

    // Initialize xTimeOut.  This records the time at which this function
    // was entered.
    vTaskSetTimeOutState( &xTimeOut );

    // Loop until the buffer contains the wanted number of bytes, or a
    // timeout occurs.
    while( UART_bytes_in_rx_buffer( pxUARTInstance ) < uxWantedBytes )
    {
        // The buffer didn't contain enough data so this task is going to
        // enter the Blocked state. Adjusting xTicksToWait to account for
        // any time that has been spent in the Blocked state within this
        // function so far to ensure the total amount of time spent in the
        // Blocked state does not exceed MAX_TIME_TO_WAIT.
        if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) != pdFALSE )
        {
            //Timed out before the wanted number of bytes were available,
            // exit the loop.
            break;
        }

        // Wait for a maximum of xTicksToWait ticks to be notified that the
        // receive interrupt has placed more data into the buffer.
        ulTaskNotifyTake( pdTRUE, xTicksToWait );
    }

    // Attempt to read uxWantedBytes from the receive buffer into pucBuffer.
    // The actual number of bytes read (which might be less than
    // uxWantedBytes) is returned.
    uxReceived = UART_read_from_receive_buffer( pxUARTInstance,
                                                pucBuffer,
                                                uxWantedBytes );

    return uxReceived;
}

```

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

### Install ESP-IDF Tools with install.bat

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

Run from the Windows Command Prompt in the ESP-IDF installation directory. Downloads and installs required tools; skips if already installed. Default installation directory is C:\Users\username\.espressif.

```batch
install.bat
```

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

### Example component directory structure

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

Shows the file layout of a component named my_component with source files and a linker fragment file.

```text
components
└── my_component
    ├── CMakeLists.txt
    ├── Kconfig
    ├── src/
    │   ├── my_src1.c
    │   ├── my_src2.c
    │   └── my_src3.c
    └── my_linker_fragment_file.lf
```

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

### Start GPTimer as Wall Clock with gptimer_get_raw_count

Source: https://docs.espressif.com/projects/esp-idf/en/v5.4.3/esp32c6/api-reference/peripherals/gptimer.html

Starts the GPTimer as a free-running wall clock after enabling it. Use gptimer_get_raw_count() to read the current counter value at any time. This example omits alarm configuration because a free-running timer is sufficient for simple timestamping.

```c
ESP_ERROR_CHECK(gptimer_enable(gptimer));
ESP_ERROR_CHECK(gptimer_start(gptimer));
// Retrieve the timestamp at any time
uint64_t count;
ESP_ERROR_CHECK(gptimer_get_raw_count(gptimer, &count));
```
Tokens:
Raw