ESP-IDF

https://docs.espressif.com/projects/esp-idf/en/release-v6.0/
Admin
ESP-IDF is the official development framework for Espressif's ESP32 and related SoCs, providing...
Tokens:2,341,204
Snippets:18,971
Trust Score:10
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### Start Web Server Example

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/api-reference/protocols/esp_http_server.html

Shows how to start the HTTP server with default configuration and register URI handlers. If the server fails to start, the handle is NULL.

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

```

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

### Example component directory structure

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

Shows the directory layout of a component named my_component that will be used in the quick start guide. It includes the CMakeLists.txt, Kconfig, source files, and the 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

```

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

### SoftAP + HTTP Transport Example with Security 1

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/api-reference/provisioning/protocomm.html

Complete example from network_provisioning/src/scheme_softap.c showing how to start a protocomm instance over HTTP with Security 1. It registers an echo endpoint, sets security with protocomm_security1, and stops the instance by removing endpoints and stopping the HTTP server.

```c
/* The endpoint handler to be registered with protocomm. This simply echoes back the received data. */
esp_err_t echo_req_handler (uint32_t session_id,
                            const uint8_t *inbuf, ssize_t inlen,
                            uint8_t **outbuf, ssize_t *outlen,
                            void *priv_data)
{
    /* Session ID may be used for persistence. */
    printf("Session ID : %d", session_id);

    /* Echo back the received data. */
    *outlen = inlen;            /* Output the data length updated. */
    *outbuf = malloc(inlen);    /* This is to be deallocated outside. */
    memcpy(*outbuf, inbuf, inlen);

    /* Private data that was passed at the time of endpoint creation. */
    uint32_t *priv = (uint32_t *) priv_data;
    if (priv) {
        printf("Private data : %d", *priv);
    }

    return ESP_OK;
}

/* The example function for launching a protocomm instance over HTTP. */
protocomm_t *start_pc(const char *pop_string)
{
    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);

    /* Create security1 params object from pop_string. It must be valid throughout the scope of protocomm endpoint. This need not be static, i.e., could be dynamically allocated and freed at the time of endpoint removal. */
    const static protocomm_security1_params_t sec1_params = {
        .data = (const uint8_t *) strdup(pop_string),
        .len = strlen(pop_string)
    };

    /* Set security for communication at the application level. Just like for request handlers, setting security creates an endpoint and registers the handler provided by protocomm_security1. One can similarly use protocomm_security0. Only one type of security can be set for a protocomm instance at a time. */
    protocomm_set_security(pc, "security_endpoint", &protocomm_security1, &sec1_params);

    /* Private data passed to the endpoint must be valid throughout the scope of protocomm endpoint. This need not be static, i.e., could be dynamically allocated and freed at the time of endpoint removal. */
    static uint32_t priv_data = 1234;

    /* Add a new endpoint for the protocomm instance identified by a unique name, and register a handler function along with the private data to be passed at the time of handler execution. Multiple endpoints can be added as long as they are identified by unique names. */
    protocomm_add_endpoint(pc, "echo_req_endpoint",
                           echo_req_handler, (void *) &priv_data);
    return pc;
}

/* The example function for stopping a protocomm instance. */
void stop_pc(protocomm_t *pc)
{
    /* Remove the endpoint identified by its unique name. */
    protocomm_remove_endpoint(pc, "echo_req_endpoint");

    /* Remove the security endpoint identified by its name. */
    protocomm_unset_security(pc, "security_endpoint");

    /* Stop the HTTP server. */
    protocomm_httpd_stop(pc);

    /* Delete, namely deallocate the protocomm instance. */
    protocomm_delete(pc);
}

```

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

### gdbinit file for loading RAM app (ESP32)

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/api-reference/kconfig-reference.html

Example gdbinit file for connecting to OpenOCD, resetting, running to a ROM address, loading the application into RAM, and running to app_main. Required when APP_BUILD_TYPE_RAM is selected and loaded with JTAG.

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

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

### Configure and run ULP LP core with ulp_lp_core_run()

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

Configures the ULP LP core with a wake-up source and sleep duration, then starts it with ulp_lp_core_run(). The example uses ULP_LP_CORE_WAKEUP_SOURCE_LP_TIMER with a 10000 microsecond 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) );

```

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

### Start MCP server with eim run

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/api-guides/tools/idf-py.html

Starts the ESP-IDF MCP server using the ESP-IDF Installation Manager (EIM). Requires EIM 0.8.1 or later and an ESP-IDF installation via the EIM installer; no prior shell activation is needed.

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

```

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

### Build and flash NimBLE_Connection example

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

Commands to navigate to the NimBLE_Connection example, open it in VSCode, set the target chip, and build/flash/monitor the firmware. Replace <ESP-IDF Path> and <chip-name> with your local values.

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

```

```bash
$ code .

```

```bash
$ idf.py set-target <chip-name>

```

```bash
$ idf.py flash monitor

```

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

### Start Ethernet Driver

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/api-reference/network/esp_eth.html

Starts the Ethernet driver state machine after driver installation.

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

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

### Build and flash NimBLE_GATT_Server example

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

Commands to navigate to the NimBLE_GATT_Server example, open it in VSCode, set the target chip, and build/flash/monitor the firmware. Replace <ESP-IDF Path> and <chip-name> with your local values.

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

```

```bash
$ code .

```

```bash
$ idf.py set-target <chip-name>

```

```bash
$ idf.py flash monitor

```

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

### Configure project: set target and run menuconfig

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/get-started/windows-start-project.html

Navigates to the hello_world directory, sets the target chip to ESP32-C6, and opens the project configuration utility. Setting the target clears any existing builds and configurations. The menu can be customized with the --style option.

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

```

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

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

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/get-started/macos-setup.html

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

```bash
eim install -i v5.4.2

```

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

### Build all documentation

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/contribute/documenting-code.html

Builds the complete documentation set. Run from the docs folder after installing dependencies.

```bash
build-docs build

```

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

### Copy hello_world example project

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/get-started/linux-macos-start-project.html

Copy the 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.

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

```

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

### Install esptool on Linux/macOS

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

Installs esptool on Linux or macOS, which includes the esp_rfc2217_server utility. This is required before starting the remote serial port server.

```bash
pip install esptool

```

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

### Navigate to NimBLE_Beacon example and set target

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/api-guides/ble/get-started/ble-device-discovery.html

Navigate to the NimBLE_Beacon example directory)Skip open it in VSCode, set the chip target, and observe the successful configuration output.

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

```

```bash
$ code .

```

```bash
$ idf.py set-target <chip-name>

```

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

```

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

### Post-attach callback example

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/api-reference/network/esp_netif_driver.html

Example post-attach callback that registers the transmit and free-rx-buffer callbacks with ESP-NETIF and starts the driver. It is executed when esp_netif_attach() is called.

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

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

### Get Ethernet duplex mode with esp_eth_ioctl()

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/migration-guides/release-5.x/5.0/networking.html

Usage example to get Ethernet configuration. The third parameter must be a pointer to the data type.

```c
eth_duplex_t duplex_mode;
esp_eth_ioctl(eth_handle, ETH_CMD_G_DUPLEX_MODE, &duplex_mode);

```

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

### Launch GDB with generated .gdbinit files

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

Launches GDB with the generated .gdbinit files to load symbols and connect to the target. The -q option minimizes startup output.

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

```

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

### Copy hello_world example project to ~/esp

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/get-started/windows-start-project.html

Changes to the esp directory and copies the hello_world example project to the current directory. The ESP-IDF build system does not support spaces in paths, so avoid paths containing spaces.

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

```

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

### macOS SSL certificate error

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/get-started/linux-macos-setup-legacy.html

Example error message shown on macOS during installation steps. Run 'Install Certificates.command' in the Python folder to resolve.

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

```

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

### esp_mesh_get_root_healing_delay

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

### Returns
delay time in milliseconds
```

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

### Build output and flash commands

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/get-started/linux-macos-start-project.html

Example output of a successful build, showing the generated binaries and the commands to flash the project.

```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 v5.0.2

Project build complete. To flash, run:
  idf.py flash
or
  idf.py -p PORT flash
or
  esptool -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

```

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

### Start esp_rfc2217_server on Linux/macOS

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

Starts the RFC2217 server on Linux or macOS to expose the serial port /dev/ttyUSB0 over Telnet on port 4000. Run this after installing esptool.

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

```

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

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

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/api-guides/tools/idf-py.html

Launches the graphical configuration tool for the project.

```bash
idf.py menuconfig

```

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

### esp_eth_ioctl()

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/api-reference/network/esp_eth.html

Performs miscellaneous get/set operations on Ethernet driver attributes. Examples include getting the MAC address, getting the PHY address, and enabling flow control.

```APIDOC
## esp_eth_ioctl()

### Description
Performs miscellaneous get/set operations on Ethernet driver attributes. This function should only be invoked after the Ethernet driver has been installed.

### Method
Function call

### Endpoint
`esp_eth_ioctl(eth_handle, cmd, data)`

### Parameters
- `eth_handle` (esp_eth_handle_t) - Required - Handle of the Ethernet driver.
- `cmd` (esp_eth_ioctl_cmd_t) - Required - Command to perform. Supported commands include `ETH_CMD_G_MAC_ADDR`, `ETH_CMD_G_PHY_ADDR`, and `ETH_CMD_S_FLOW_CTRL`.
- `data` (void *) - Required - Pointer to data buffer for the command.

### Command Details
#### ETH_CMD_G_MAC_ADDR
- **Description**: Get the MAC address of the Ethernet device.
- **Data**: Pointer to a `uint8_t` array of length 6 to receive the MAC address.

#### ETH_CMD_G_PHY_ADDR
- **Description**: Get the PHY address of the Ethernet PHY.
- **Data**: Pointer to an `int` variable to receive the PHY address.

#### ETH_CMD_S_FLOW_CTRL
- **Description**: Enable or disable flow control.
- **Data**: Pointer to a `bool` variable. Set to `true` to enable flow control, `false` to disable.

### Request Example
```c
/* get MAC address */
uint8_t mac_addr[6];
memset(mac_addr, 0, sizeof(mac_addr));
esp_eth_ioctl(eth_handle, ETH_CMD_G_MAC_ADDR, mac_addr);
ESP_LOGI(TAG, "Ethernet MAC Address: %02x:%02x:%02x:%02x:%02x:%02x",
         mac_addr[0], mac_addr[1], mac_addr[2], mac_addr[3], mac_addr[4], mac_addr[5]);

/* get PHY address */
int phy_addr = -1;
esp_eth_ioctl(eth_handle, ETH_CMD_G_PHY_ADDR, &phy_addr);
ESP_LOGI(TAG, "Ethernet PHY Address: %d", phy_addr);
```

### Flow Control Example
```c
bool flow_ctrl_enable = true;
esp_eth_ioctl(eth_handle, ETH_CMD_S_FLOW_CTRL, &flow_ctrl_enable);
```

### Return Value
None documented.
```

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

### httpd_start

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/api-reference/protocols/esp_http_server.html

Starts the HTTP server by creating an instance and allocating resources based on the provided 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
`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
```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;
}
```
```

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

### esp_eth_start

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/api-reference/network/esp_eth.html

Starts the Ethernet driver. This function must be called after installing the driver and before any data transmission or reception.

```APIDOC
## esp_eth_start

### Description
Starts the Ethernet driver. This function must be called after installing the driver and before any data transmission or reception.

### Function Signature
`esp_err_t esp_eth_start(esp_eth_handle_t hdl)`

### Parameters
- **hdl** (esp_eth_handle_t) - [in] handle of Ethernet driver

### Returns
- ESP_OK: start esp_eth driver successfully
- ESP_ERR_INVALID_ARG: start esp_eth driver failed because of some invalid argument
- ESP_ERR_INVALID_STATE: start esp_eth driver failed because driver has started already
- ESP_FAIL: start esp_eth driver failed because some other error occurred
```

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

### Verify OpenOCD installation with openocd --version

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/api-guides/jtag-debugging/index.html

Check that OpenOCD is installed and available in your terminal after setting up the ESP-IDF environment. The expected output shows the version string, for example 'Open On-Chip Debugger v0.12.0-esp32-20240318 (2024-03-18-18:25)'.

```bash
openocd --version

```

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

### esp_console_start_repl

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/api-reference/system/console.html

Starts 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 esp_console_stop_repl to destroy the REPL environment.

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

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

### SoftAP + HTTP Transport Example with Security 2 (echo handler, sec2 salt/verifier, start_pc)

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/api-reference/provisioning/protocomm.html

Example from network_provisioning/src/scheme_softap.c showing a protocomm endpoint handler that echoes received data, the static sec2 salt and verifier arrays used for Security 2, and a function that creates a protocomm instance and starts it over HTTP using protocomm_httpd_start(). The handler allocates the output buffer with malloc() and expects the caller to deallocate it.

```c
esp_err_t echo_req_handler (uint32_t session_id,
                            const uint8_t *inbuf, ssize_t inlen,
                            uint8_t **outbuf, ssize_t *outlen,
                            void *priv_data)
{
    /* Session ID may be used for persistence. */
    printf("Session ID : %d", session_id);

    /* Echo back the received data. */
    *outlen = inlen;            /* Output the data length updated. */
    *outbuf = malloc(inlen);    /* This is to be deallocated outside. */
    memcpy(*outbuf, inbuf, inlen);

    /* Private data that was passed at the time of endpoint creation. */
    uint32_t *priv = (uint32_t *) priv_data;
    if (priv) {
        printf("Private data : %d", *priv);
    }

    return ESP_OK;
}
```

```c
static const char sec2_salt[] = {0xf7, 0x5f, 0xe2, 0xbe, 0xba, 0x7c, 0x81, 0xcd};
static const char sec2_verifier[] = {0xbf, 0x86, 0xce, 0x63, 0x8a, 0xbb, 0x7e, 0x2f, 0x38, 0xa8, 0x19, 0x1b, 0x35,
    0xc9, 0xe3, 0xbe, 0xc3, 0x2b, 0x45, 0xee, 0x10, 0x74, 0x22, 0x1a, 0x95, 0xbe, 0x62, 0xf7, 0x0c, 0x65, 0x83, 0x50,
    0x08, 0xef, 0xaf, 0xa5, 0x94, 0x4b, 0xcb, 0xe1, 0xce, 0x59, 0x2a, 0xe8, 0x7b, 0x27, 0xc8, 0x72, 0x26, 0x71, 0xde,
    0xb2, 0xf2, 0x80, 0x02, 0xdd, 0x11, 0xf0, 0x38, 0x0e, 0x95, 0x25, 0x00, 0xcf, 0xb3, 0x3f, 0xf0, 0x73, 0x2a, 0x25,
    0x03, 0xe8, 0x51, 0x72, 0xef, 0x6d, 0x3e, 0x14, 0xb9, 0x2e, 0x9f, 0x2a, 0x90, 0x9e, 0x26, 0xb6, 0x3e, 0xc7, 0xe4,
    0x9f, 0xe3, 0x20, 0xce, 0x28, 0x7c, 0xbf, 0x89, 0x50, 0xc9, 0xb6, 0xec, 0xdd, 0x81, 0x18, 0xf1, 0x1a, 0xd9, 0x7a,
    0x21, 0x99, 0xf1, 0xee, 0x71, 0x2f, 0xcc, 0x93, 0x16, 0x34, 0x0c, 0x79, 0x46, 0x23, 0xe4, 0x32, 0xec, 0x2d, 0x9e,
    0x18, 0xa6, 0xb9, 0xbb, 0x0a, 0xcf, 0xc4, 0xa8, 0x32, 0xc0, 0x1c, 0x32, 0xa3, 0x97, 0x66, 0xf8, 0x30, 0xb2, 0xda,
    0xf9, 0x8d, 0xc3, 0x72, 0x72, 0x5f, 0xe5, 0xee, 0xc3, 0x5c, 0x24, 0xc8, 0xdd, 0x54, 0x49, 0xfc, 0x12, 0x91, 0x81,
    0x9c, 0xc3, 0xac, 0x64, 0x5e, 0xd6, 0x41, 0x88, 0x2f, 0x23, 0x66, 0xc8, 0xac, 0xb0, 0x35, 0x0b, 0xf6, 0x9c, 0x88,
    0x6f, 0xac, 0xe1, 0xf4, 0xca, 0xc9, 0x07, 0x04, 0x11, 0xda, 0x90, 0x42, 0xa9, 0xf1, 0x97, 0x3d, 0x94, 0x65, 0xe4,
    0xfb, 0x52, 0x22, 0x3b, 0x7a, 0x7b, 0x9e, 0xe9, 0xee, 0x1c, 0x44, 0xd0, 0x73, 0x72, 0x2a, 0xca, 0x85, 0x19, 0x4a,
    0x60, 0xce, 0x0a, 0xc8, 0x7d, 0x57, 0xa4, 0xf8, 0x77, 0x22, 0xc1, 0xa5, 0xfa, 0xfb, 0x7b, 0x91, 0x3b, 0xfe, 0x87,
    0x5f, 0xfe, 0x05, 0xd2, 0xd6, 0xd3, 0x74, 0xe5, 0x2e, 0x68, 0x79, 0x34, 0x70, 0x40, 0x12, 0xa8, 0xe1, 0xb4, 0x6c,
    0xaa, 0x46, 0x73, 0xcd, 0x8d, 0x17, 0x72, 0x67, 0x32, 0x42, 0xdc, 0x10, 0xd3, 0x71, 0x7e, 0x8b, 0x00, 0x46, 0x9b,
    0x0a, 0xe9, 0xb4, 0x0f, 0xeb, 0x70, 0x52, 0xdd, 0x0a, 0x1c, 0x7e, 0x2e, 0xb0, 0x61, 0xa6, 0xe1, 0xa3, 0x34, 0x4b,
    0x2a, 0x3c, 0xc4, 0x5d, 0x42, 0x05, 0x58, 0x25, 0xd3, 0xca, 0x96, 0x5c, 0xb9, 0x52, 0xf9, 0xe9, 0x80, 0x75, 0x3d,
    0xc8, 0x9f, 0xc7, 0xb2, 0xaa, 0x95, 0x2e, 0x76, 0xb3, 0xe1, 0x48, 0xc1, 0x0a, 0xa1, 0x0a, 0xe8, 0xaf, 0x41, 0x28,
    0xd2, 0x16, 0xe1, 0xa6, 0xd0, 0x73, 0x51, 0x73, 0x79, 0x98, 0xd9, 0xb9, 0x00, 0x50, 0xa2, 0x4d, 0x99, 0x18, 0x90,
    0x70, 0x27, 0xe7, 0x8d, 0x56, 0x45, 0x34, 0x1f, 0xb9, 0x30, 0xda, 0xec, 0x4a, 0x08, 0x27, 0x9f, 0xfa, 0x59, 0x2e,
    0x36, 0x77, 0x00, 0xe2, 0xb6, 0xeb, 0xd1, 0x56, 0x50, 0x8e};
```

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

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

### gptimer_get_raw_count

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/api-reference/peripherals/gptimer.html

Gets the current raw count value of the GPTimer. The count is the accumulated count since the timer started (assuming it started from 0). The returned value is a pure count and must be converted to time using the timer's resolution.

```APIDOC
## gptimer_get_raw_count

### Description
Gets the current raw count value of the GPTimer. The count is the accumulated count since the timer started (assuming it started from 0). The returned value is a pure count and must be converted to time using the timer's resolution.

### Method
Function

### Signature
`esp_err_t gptimer_get_raw_count(gptimer_handle_t timer, uint64_t *out_count)`

### Parameters
- **timer** (gptimer_handle_t) - Required - Handle of the GPTimer.
- **out_count** (uint64_t *) - Required - Pointer to store the current raw count value.

### Return
- **esp_err_t** - ESP_OK on success, or an error code on failure.

### Example
c
uint64_t count;
ESP_ERROR_CHECK(gptimer_get_raw_count(gptimer, &count));

```

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

### Install EIM GUI and CLI via APT

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/get-started/linux-setup.html

Installs the EIM with both GUI and CLI via APT.

```bash
sudo apt install eim

```

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

### xTimerChangePeriod() example usage

Source: https://docs.espressif.com/projects/esp-idf/en/release-v6.0/esp32c6/api-reference/system/freertos_idf.html

Example usage of xTimerChangePeriod() from the FreeRTOS timer API. Requires configUSE_TIMERS set to 1. The function deletes an active timer or changes the period of an inactive timer to 500ms and starts it, blocking up to 100 ticks to send the command.

```c
* // This function assumes xTimer has already been created.  If the timer
* // referenced by xTimer is already active when it is called, then the timer
* // is deleted.  If the timer referenced by xTimer is not active when it is
* // called, then the period of the timer is set to 500ms and the timer is
* // started.
* void vAFunction( TimerHandle_t xTimer )
* {
*     if( xTimerIsTimerActive( xTimer ) != pdFALSE ) // or more simply and equivalently "if( xTimerIsTimerActive( xTimer ) )"
*     {
*         // xTimer is already active - delete it.
*         xTimerDelete( xTimer );
*     }
*     else
*     {
*         // xTimer is not active, change its period to 500ms.  This will also
*         // cause the timer to start.  Block for a maximum of 100 ticks if the
*         // change period command cannot immediately be sent to the timer
*         // command queue.
*         if( xTimerChangePeriod( xTimer, 500 / portTICK_PERIOD_MS, 100 ) == pdPASS )
*         {
*             // The command was successfully sent.
*         }
*         else
*         {
*             // The command could not be sent, even after waiting for 100 ticks
*             // to pass.  Take appropriate action here.
*         }
*     }
* }
*
```
Tokens:
Raw