Getting Started with ESP32 using ESP-IDF

Getting started with the ESP32 microcontroller using ESP-IDF (Espressif IoT Development Framework) is essential for developing robust IoT applications. This tutorial provides a step-by-step guide to setting up ESP-IDF, basic programming concepts, and practical examples such as logging, generating delays, taking keyboard input, and blinking an LED using ESP32.

Setting Up ESP-IDF

Installation

Before diving into programming, ensure that ESP-IDF is installed on your Windows or Linux machine. Follow the detailed guides on the ESP32 Tutorials website for installation.

Setting Up VS Code

Using VS Code with the ESP-IDF extension simplifies the development process. Create a new project in VS Code, configure your environment, and start writing your first ESP32 program.

Logging in ESP-IDF

Introduction to ESP-IDF Logging

ESP-IDF provides a robust logging library, esp_log.h, which supports five log levels: Error (ESP_LOGE), Warning (ESP_LOGW), Information (ESP_LOGI), Debug (ESP_LOGD), and Verbose (ESP_LOGV). These log levels help monitor and debug your application efficiently.

Example Code for Logging

#include "esp_log.h"

void app_main(void)
{
    ESP_LOGE("LOG", "This is an error");
    ESP_LOGW("LOG", "This is a warning");
    ESP_LOGI("LOG", "This is an info");
    ESP_LOGD("LOG", "This is a debug");
    ESP_LOGV("LOG", "This is a verbose");
}

Compile and flash your code using the idf.py flash monitor command to see the output logs.

Enabling Debug and Verbose Logging

To enable debug and verbose logging, use idf.py menuconfig to access the Espressif IoT Development Framework Configuration. Navigate to Component config > Log output and set the default log verbosity to Verbose.

Generating Delays with FreeRTOS

Using FreeRTOS for Delays

FreeRTOS provides task management and delay functions, which are crucial for timing operations. Include the FreeRTOS library in your code to utilize these features

#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

void app_main(void)
{
    while (1)
    {
        vTaskDelay(1000 / portTICK_PERIOD_MS);
        ESP_LOGI("DELAY", "One second delay");
    }
}

This code creates a one-second delay in the main loop, demonstrating the use of FreeRTOS for time management.

LED Blinking Example

Blinking an Onboard LED

A common beginner project is blinking the onboard LED of the ESP32. This project involves setting up a GPIO pin as an output and toggling its state to blink the LED.

#include "driver/gpio.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

#define LED_PIN 2

void app_main(void)
{
    gpio_pad_select_gpio(LED_PIN);
    gpio_set_direction(LED_PIN, GPIO_MODE_OUTPUT);
    int state = 0;
    while (1)
    {
        state = !state;
        gpio_set_level(LED_PIN, state);
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
}

This script configures GPIO2 as an output and toggles its state every second, causing the LED to blink.

Taking Keyboard Input

Capturing User Input

Capturing keyboard input is useful for interactive applications. The following code demonstrates how to read input from the user and display it.

#include <stdio.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"

void app_main(void)
{
    char character = 0;
    char str[100];
    memset(str, 0, sizeof(str));

    while (character != '\n')
    {
        character = getchar();
        if (character != 0xff)
        {
            str[strlen(str)] = character;
            printf("%c", character);
        }
        vTaskDelay(1000 / portTICK_PERIOD_MS);
    }
    printf("User Entered: %s\n", str);
}

This code reads characters from the keyboard until the Enter key is pressed, then displays the entered string.

This guide covers the basics of getting started with ESP32 using ESP-IDF, including setting up the development environment, logging, generating delays, blinking an LED, and capturing keyboard input. With these foundational skills, you can develop more complex IoT applications using ESP32 and ESP-IDF.