ESP-IDF

https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/
Admin
ESP-IDF is the official development framework for Espressif's ESP32, ESP32-S, ESP32-C, ESP32-H, and...
Tokens:2,392,323
Snippets:16,464
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### Start Web Server Example

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-reference/protocols/esp_http_server.html

Starts the HTTP server 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;
}
```

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

### Launch EIM interactive installation wizard

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/get-started/macos-setup.html

Use this command to start the interactive installation wizard, which allows customizing the installation path, selecting ESP-IDF versions, and modifying other options.

```bash
eim wizard

```

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

### Post-attach callback example

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-reference/network/esp_netif_driver.html

Example of a post-attach callback that registers data path callbacks and starts the driver. It sets the driver configuration and calls my_driver_start.

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

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

### SoftAP + HTTP Transport Example with Security 2 - Start Protocomm Instance

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-reference/provisioning/protocomm.html

Creates a new protocomm instance and starts it over HTTP using protocomm_httpd_start() with default HTTPD configuration. This is the main function to launch the server.

```c
/* The example function for launching a protocomm instance over HTTP. */
protocomm_t *start_pc()
{
    protocomm_t *pc = protocomm_new();


    /* Config for protocomm_httpd_start(). */
    protocomm_httpd_config_t pc_config = {
        .data = {
        .config = PROTOCOMM_HTTPD_DEFAULT_CONFIG()
        }
    };

    /* Start the protocomm server on top of HTTP. */
    protocomm_httpd_start(pc, &pc_config);

```

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

### Launch GDB with generated .gdbinit files

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

Command to start GDB, load symbols, and connect to the target. The -q option minimizes startup output. This example uses the symbols, prefix_map, and connect files.

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

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

### Start MCP server with eim run

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-guides/tools/idf-py.html

Recommended way to start the MCP server using the ESP-IDF Installation Manager (EIM). Requires EIM 0.8.1 or later and ESP-IDF installed via the EIM installer. Does not require activating ESP-IDF in the shell first.

```bash
eim run "idf.py mcp-server"

```

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

### RMT sync manager: simultaneous transmission setup

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-reference/peripherals/rmt.html

This example shows how to install two RMT TX channels, enable them, create a sync manager, and start simultaneous transmission. The channels wait until rmt_transmit() is called on all managed channels. Use rmt_sync_reset() before restarting to re-synchronize.

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

```

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

### Copy hello_world project to ~/esp

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/get-started/linux-macos-start-project.html

Copy the get-started/hello_world example from the ESP-IDF examples directory to your ~/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 .

```

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

### xTimerCreate example: creating and starting multiple timers

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-reference/system/freertos_idf.html

This example creates five timers with different periods, each using the same callback that counts expirations and stops the timer after 10 expirations. It demonstrates creating timers before the scheduler starts and starting them so they run immediately when the scheduler starts. The example includes a callback function and a main function that creates and starts the timers.

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

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

### Copy hello_world project to ~/esp directory

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/get-started/windows-start-project.html

Use these commands to 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 to either ESP-IDF or to projects.

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

```

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

### xTimerCreate example: create and start a software timer

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-reference/system/freertos_idf.html

Shows how to create a software timer with xTimerCreate, using a static buffer, and start it before the scheduler starts. The timer callback is defined separately. The example includes creating tasks and starting the scheduler.

```c
TimerHandle_t xTimer = xTimerCreate(
                     "Timer",                 // Just a text name, not used by the kernel.
                     ( 100 / portTICK_PERIOD_MS ), // The timer period in ticks.
                     pdTRUE,                   // The timer will auto-reload itself when it expires.
                     ( void * ) 0,             // The ID is not used.
                     prvTimerCallback,         // The function to execute when the timer expires.
                     &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( ;; );
```

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

### Install QEMU pre-built binaries

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-guides/tools/qemu.html

Install the pre-built QEMU binaries for ESP32-C3 using idf_tools.py.

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

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

### Set target and run menuconfig

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/get-started/linux-macos-start-project.html

Navigate to the hello_world project, set ESP32-C3 as the target, and open the project configuration utility. Existing builds and configurations are cleared when setting the target.

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

```

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

### Install specific ESP-IDF version with EIM CLI

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/get-started/macos-setup.html

Use this command to install a specific ESP-IDF version when it is not available in the interactive wizard. Example installs v5.4.2.

```bash
eim install -i v5.4.2

```

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

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

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-guides/tools/idf-docker-image.html

Installs esptool via pip on Linux or macOS, then starts the RFC2217 server with the host serial device /dev/ttyUSB0. The server listens on port 4000 with verbose output.

```bash
pip install esptool

```

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

```

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

### Navigate to NimBLE_Connection example directory

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-guides/ble/get-started/ble-connection.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_Connection

```

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

### Scan SBOM file for hello_world example

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-guides/tools/idf-sbom.html

Example command to scan the SBOM file generated for the hello_world example. The file is build/hello_world.spdx.

```bash
$ idf.py sbom-check --file build/hello_world.spdx

```

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

### Open the project in VSCode

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/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 .

```

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

### Start Ethernet Driver State Machine

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-reference/network/esp_eth.html

Starts the Ethernet driver state machine after installation. This is the first step to begin Ethernet operation.

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

```

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

### start_pc()

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-reference/provisioning/protocomm.html

Creates and starts a protocomm instance over Bluetooth LE with security 0, adding a security endpoint and an echo request endpoint.

```APIDOC
## start_pc()

### Description
Creates a new protocomm instance, configures Bluetooth LE transport with endpoint UUIDs, starts the service, sets security to protocomm_security0, and adds an echo request endpoint.

### Method
Function call

### Endpoint
N/A (SDK function)

### Parameters
None

### Request Example
```c
protocomm_t *pc = start_pc();
```

### Response
#### Success Response
- **protocomm_t\*** - Pointer to the started protocomm instance.

#### Response Example
```c
protocomm_t *pc = start_pc();
```
```

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

### esp_mesh_get_root_healing_delay

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/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
```c
int esp_mesh_get_root_healing_delay(void)
```

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

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

### Navigate to the NimBLE_GATT_Server example directory

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

Use this command to change to the example directory for the NimBLE_GATT_Server project. 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

```

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

### Default event handler example

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-reference/network/esp_netif_driver.html

Example of a default handler that sets event handlers for start and stop events, mapping driver events to ESP-NETIF actions.

```c
esp_err_t my_driver_netif_set_default_handlers(my_netif_driver_t *driver, esp_netif_t * esp_netif)
{
    driver_set_event_handler(driver->driver_impl, esp_netif_action_start, MY_DRV_EVENT_START, esp_netif);
    driver_set_event_handler(driver->driver_impl, esp_netif_action_stop, MY_DRV_EVENT_STOP, esp_netif);
    return ESP_OK;
}
```

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

### FreeRTOS one-shot timer example: backlight timer callback, key handler, and main

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-reference/system/freertos_idf.html

Complete example showing how to create a one-shot timer with xTimerCreate, start it with xTimerStart, and reset it with xTimerReset. The timer callback vBacklightTimerCallback turns off the backlight after 5 seconds of inactivity. The key press handler vKeyPressEventHandler turns the backlight on and resets the timer. The main function creates the timer with a period of 5000 ms, starts it, and then starts the scheduler.

```c
void vBacklightTimerCallback( TimerHandle_t pxTimer )
{
    // The timer expired, therefore 5 seconds must have passed since a key
    // was pressed.  Switch off the LCD back-light.
    vSetBacklightState( BACKLIGHT_OFF );
}

// The key press event handler.
void vKeyPressEventHandler( char cKey )
{
    // Ensure the LCD back-light is on, then reset the timer that is
    // responsible for turning the back-light off after 5 seconds of
    // key inactivity.  Wait 10 ticks for the command to be successfully sent
    // if it cannot be sent immediately.
    vSetBacklightState( BACKLIGHT_ON );
    if( xTimerReset( xBacklightTimer, 100 ) != pdPASS )
    {
        // The reset command was not executed successfully.  Take appropriate
        // action here.
    }

    // Perform the rest of the key processing here.
}

void main( void )
{
int32_t x;

    // Create then start the one-shot timer that is responsible for turning
    // the back-light off if no keys are pressed within a 5 second period.
    xBacklightTimer = xTimerCreate( "BacklightTimer",           // Just a text name, not used by the kernel.
                                    ( 5000 / portTICK_PERIOD_MS), // The timer period in ticks.
                                    pdFALSE,                    // The timer is a one-shot timer.
                                    0,                          // The id is not used by the callback so can take any value.
                                    vBacklightTimerCallback     // The callback function that switches the LCD back-light off.
                                  );

    if( xBacklightTimer == 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( xBacklightTimer, 0 ) != pdPASS )
        {
            // The timer could not be set into the Active state.
        }
    }

    // ...
    // Create tasks here.
    // ...

    // Starting the scheduler will start the timer running as it has already
    // been set into the active state.
    vTaskStartScheduler();

    // Should not reach here.
    for( ;; );
}
```

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

### esp_wifi_sta_get_negotiated_phymode

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-reference/network/esp_wifi.html

Gets the negotiated PHY mode after connection. Returns an error if WiFi is not started or no connection exists.

```APIDOC
## esp_wifi_sta_get_negotiated_phymode

### Description
Gets the negotiated PHY mode after connection. This function should be called after the station is connected to an AP.

### Function Signature
```c
esp_err_t esp_wifi_sta_get_negotiated_phymode(wifi_phy_mode_t *phymode)
```

### Parameters
- **phymode** (wifi_phy_mode_t*) - Required - [out] Store the negotiated PHY mode.

### Returns
- ESP_OK: succeed
- ESP_ERR_WIFI_NOT_STARTED: WiFi is not started by esp_wifi_start
- ESP_ERR_WIFI_NOT_CONNECT: No connection between STA and AP

```

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

### Build documentation with build-docs build

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/contribute/documenting-code.html

Run this command from the docs folder to build the documentation.

```bash
build-docs build

```

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

### Create unit-test-app project with idf.py create-project-from-example

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/migration-guides/release-6.x/6.0/tools.html

Use this command to create a test app from the espressif/unit-test-app example in the ESP Component Registry. This replaces the legacy unit-test-app that was previously part of the ESP-IDF repository.

```bash
idf.py create-project-from-example espressif/unit-test-app:unit-test-app

```

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

### Create a new ping session with callbacks (C)

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-reference/protocols/icmp_echo.html

Shows how to initialize a ping session by filling esp_ping_config_t and esp_ping_callbacks_t, and calling esp_ping_new_session. Includes callback functions for success, timeout, and end events that retrieve runtime statistics via esp_ping_get_profile. The example resolves 'www.espressif.com' to an IP address and uses ESP_PING_COUNT_INFINITE.

```c
static void test_on_ping_success(esp_ping_handle_t hdl, void *args)
{
    // optionally, get callback arguments
    // const char* str = (const char*) args;
    // printf("%s\r\n", str); // "foo"
    uint8_t ttl;
    uint16_t seqno;
    uint32_t elapsed_time, recv_len;
    ip_addr_t target_addr;
    esp_ping_get_profile(hdl, ESP_PING_PROF_SEQNO, &seqno, sizeof(seqno));
    esp_ping_get_profile(hdl, ESP_PING_PROF_TTL, &ttl, sizeof(ttl));
    esp_ping_get_profile(hdl, ESP_PING_PROF_IPADDR, &target_addr, sizeof(target_addr));
    esp_ping_get_profile(hdl, ESP_PING_PROF_SIZE, &recv_len, sizeof(recv_len));
    esp_ping_get_profile(hdl, ESP_PING_PROF_TIMEGAP, &elapsed_time, sizeof(elapsed_time));
    printf("%d bytes from %s icmp_seq=%d ttl=%d time=%d ms\n",
           recv_len, inet_ntoa(target_addr.u_addr.ip4), seqno, ttl, elapsed_time);
}

static void test_on_ping_timeout(esp_ping_handle_t hdl, void *args)
{
    uint16_t seqno;
    ip_addr_t target_addr;
    esp_ping_get_profile(hdl, ESP_PING_PROF_SEQNO, &seqno, sizeof(seqno));
    esp_ping_get_profile(hdl, ESP_PING_PROF_IPADDR, &target_addr, sizeof(target_addr));
    printf("From %s icmp_seq=%d timeout\n", inet_ntoa(target_addr.u_addr.ip4), seqno);
}

static void test_on_ping_end(esp_ping_handle_t hdl, void *args)
{
    uint32_t transmitted;
    uint32_t received;
    uint32_t total_time_ms;

    esp_ping_get_profile(hdl, ESP_PING_PROF_REQUEST, &transmitted, sizeof(transmitted));
    esp_ping_get_profile(hdl, ESP_PING_PROF_REPLY, &received, sizeof(received));
    esp_ping_get_profile(hdl, ESP_PING_PROF_DURATION, &total_time_ms, sizeof(total_time_ms));
    printf("%d packets transmitted, %d received, time %dms\n", transmitted, received, total_time_ms);
}

void initialize_ping()
{
    /* convert URL to IP address */
    ip_addr_t target_addr;
    struct addrinfo hint;
    struct addrinfo *res = NULL;
    memset(&hint, 0, sizeof(hint));
    memset(&target_addr, 0, sizeof(target_addr));
    getaddrinfo("www.espressif.com", NULL, &hint, &res);
    struct in_addr addr4 = ((struct sockaddr_in *) (res->ai_addr))->sin_addr;
    inet_addr_to_ip4addr(ip_2_ip4(&target_addr), &addr4);
    freeaddrinfo(res);

    esp_ping_config_t ping_config = ESP_PING_DEFAULT_CONFIG();
    ping_config.target_addr = target_addr;          // target IP address
    ping_config.count = ESP_PING_COUNT_INFINITE;    // ping in infinite mode, esp_ping_stop can stop it

    /* set callback functions */
    esp_ping_callbacks_t cbs;
    cbs.on_ping_success = test_on_ping_success;
    cbs.on_ping_timeout = test_on_ping_timeout;
    cbs.on_ping_end = test_on_ping_end;
    cbs.cb_args = "foo";  // arguments that feeds to all callback functions, can be NULL
    cbs.cb_args = eth_event_group;

    esp_ping_handle_t ping;
    esp_ping_new_session(&ping_config, &cbs, &ping);
}
```

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

### C++ simple example: spaceship.h and spaceship.cpp

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/contribute/style-guide.html

Complete example showing a header file (spaceship.h) and source file (spaceship.cpp) following the style guide: namespace indentation, class member order, and constructor initialization.

```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_

```

```cpp
// 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

```

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

### pyproject.toml entry point for idf_extension

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-guides/tools/idf-py.html

Example pyproject.toml configuration that exposes the action_extensions function via the idf_extension entry-point group. Install the package into the same Python environment as idf.py (e.g., with pip install -e .) to load the extension.

```toml
[project]
name = "my_comp"
version = "0.1.0"

[project.entry-points.idf_extension]
my_pkg_ext = "my_component.my_ext:action_extensions"

```

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

### Example of using nvs_get_str and nvs_get_blob

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-reference/storage/nvs_flash.html

Shows how to retrieve a string into a dynamically allocated buffer using a length query, and how to retrieve a blob into a static array. The string example uses nvs_get_str with NULL out_value to get the required size, then allocates memory and retrieves the string. The blob example retrieves a MAC address into a fixed-size array.

```c
// Example (without error checking) of using nvs_get_str to get a string into dynamic array:
size_t required_size;
nvs_get_str(my_handle, "server_name", NULL, &required_size);
char* server_name = malloc(required_size);
nvs_get_str(my_handle, "server_name", server_name, &required_size);

// Example (without error checking) of using nvs_get_blob to get a binary data
into a static array:
uint8_t mac_addr[6];
size_t size = sizeof(mac_addr);
nvs_get_blob(my_handle, "dst_mac_addr", mac_addr, &size);

```

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

### httpd_start

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-reference/protocols/esp_http_server.html

Starts the web server by creating an instance of the HTTP server and allocating memory/resources for it based on the specified configuration.

```APIDOC
## httpd_start

### Description
Starts the web server. Creates an instance of HTTP server and allocates memory/resources for it depending upon the specified configuration.

### Function Signature
```c
esp_err_t httpd_start(httpd_handle_t *handle, const httpd_config_t *config)
```

### Parameters
- **config** (const httpd_config_t*) - [in] Configuration for new instance of the server
- **handle** (httpd_handle_t*) - [out] Handle to newly created instance of the server. NULL on error

### Returns
- ESP_OK : Instance created successfully
- ESP_ERR_INVALID_ARG : Null argument(s)
- ESP_ERR_HTTPD_ALLOC_MEM : Failed to allocate memory for instance
- ESP_ERR_HTTPD_TASK : Failed to launch server task

### Example Usage
```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;
}
```
```

```APIDOC
## httpd_stop

### Description
Stops the web server. Deallocates memory/resources used by an HTTP server instance and deletes it. Once deleted the handle can no longer be used for accessing the instance.

### Parameters
- **handle** (httpd_handle_t) - [in] Handle to server returned by httpd_start

### Returns
- ESP_OK : Server stopped successfully
- ESP_ERR_INVALID_ARG : Handle argument is Null
```

```APIDOC
## httpd_sess_set_recv_override

### Description
Override web server's receive function (by session FD). This function overrides the web server's receive function. This same function is used to read HTTP request packets.

### Parameters
- **hd** (httpd_handle_t) - [in] HTTPD instance handle
- **sockfd** (int) - [in] Session socket file descriptor
- **recv_func** (httpd_recv_func_t) - [in] The receive function to be overridden

### Notes
- This API is supposed to be called either from the context of an http session APIs where sockfd is a valid parameter, or a URI handler where sockfd is obtained using httpd_req_to_sockfd().
```

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

### Debug an application in QEMU

Source: https://docs.espressif.com/projects/esp-idf/en/stable/esp32c3/api-guides/tools/qemu.html

Build and start QEMU with GDB server and open an interactive GDB session.

```bash
idf.py qemu gdb
```
Tokens:
Raw