Mastering C++ Lambda with ESP32 | Create Powerful xTask Setup

643 
C++ Lambda expressions are anonymous functions that help make the code more concise and maintainable. They can capture external variables, making callback function management more flexible. In embedded systems, especially event-driven designs, Lambda expressions reduce redundant code and simplify task handling.
C++ Lambda

Introduction

In modern embedded development, the ESP32, a powerful Wi-Fi and Bluetooth dual-mode chip, has become a popular choice among developers due to its low cost and flexibility. C++'s Lambda expressions (anonymous functions) can significantly simplify code, especially when it comes to event-driven programming and task management. This article will explore how to utilize anonymous functions with FreeRTOS's xTask management on the ESP32 to improve development efficiency and code readability.

Development Environment Setup

1. Install Visual Studio Code from the official website.
2. Install the ESP-IDF plugin.

Setting Up the ESP32 Project

1. In VS Code, press Ctrl (Cmd) + Shift + P, and enter ESP-IDF: New Project.

2. Choose a template project (e.g., blink example), set the project name (e.g., my_project), and choose a storage path.

3. The system will generate a new ESP-IDF project with a basic CMake file and example code.

File Structure

my_project/
├── CMakeLists.txt     # Build configuration
├── main/
│   ├── CMakeLists.txt # Main component's CMake configuration
│   └── main.cpp       # application logic
└── sdkconfig          # Project configuration

Advantages of C++ Lambda Expressions

Anonymous functions (Lambda expressions) simplify callback functions and are particularly useful for managing event-driven and asynchronous logic. Their main advantages include:

Conciseness: Simplifies the code and reduces the complexity of defining callback functions.

Flexibility: Allows capturing external variables for better code management.

Efficiency: Reduces function duplication and improves task handling performance.

Configuring the C++ Standard

To support modern C++ features like Lambda expressions, you need to configure the C++ standard in the ESP32's CMake settings. You can set the C++14 standard by adding the following line in the CMakeLists.txt file:

set(CMAKE_CXX_STANDARD 14)

This ensures that you can use modern C++ features.

ESP32 and FreeRTOS xTask

The ESP32 is equipped with the FreeRTOS real-time operating system (RTOS), which provides the xTask API for easily creating and managing tasks. We will use anonymous functions to define the behavior of ESP32 tasks, simplifying the code structure and increasing flexibility.

Basic Syntax

[Capture List](Parameter List) -> Return Type {
    // Function body
}

1. Capture List: Specifies which external variables can be captured.

2. Parameter List: Defines the function's parameters.

3. Return Type: Tells the compiler the function's return type.
void app_main() {
    int x = 10;
    
    auto add = [x](int y) -> int {
        return x + y;  // Use the captured variable x
    };

    ESP_LOGI(TAG, "x + 5 = %d", add(5));  // Output: x + 5 = 15
}

Using C++ Lambda to Create ESP32 Tasks

Here’s an example of how to use anonymous functions to create two periodic tasks on the ESP32:
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"

static const char *TAG = "Example";  // Tag for logging

// Wrapper function for Task 1
void task1Wrapper(void* param) {
    auto task1Code = [](void* param) -> int {  // Lambda that returns an int type
        while (true) {
            ESP_LOGI(TAG, "Task 1 is running...");  // Task 1 activity log
            vTaskDelay(1000 / portTICK_PERIOD_MS);  // Task 1 runs every 1 second
        }
        return 0;  // Return value not used here
    };
    task1Code(param);  // Call the Lambda function
}

// Wrapper function for Task 2
void task2Wrapper(void* param) {
    auto task2Code = [](void* param) {  // Lambda with no return value
        while (true) {
            ESP_LOGI(TAG, "Task 2 is running...");  // Task 2 activity log
            vTaskDelay(1500 / portTICK_PERIOD_MS);  // Task 2 runs every 1.5 seconds
        }
    };
    task2Code(param);  // Call the Lambda function
}

extern "C" void app_main() {
    // Create Task 1 using task1Wrapper
    xTaskCreate(
        task1Wrapper,   // Pass task1Wrapper
        "Task1",        // Task name
        2048,           // Stack size
        nullptr,        // No parameters passed
        1,              // Task priority
        nullptr         // No task handle needed
    );

    // Create Task 2 using task2Wrapper
    xTaskCreate(
        task2Wrapper,   // Pass task2Wrapper
        "Task2",        // Task name
        2048,           // Stack size
        nullptr,        // No parameters passed
        1,              // Task priority
        nullptr         // No task handle needed
    );
}

Code Explanation

1. task1Wrapper and task2Wrapper: These functions wrap the inline anonymous functions. This avoids directly passing anonymous functions to xTaskCreate, which makes the code structure cleaner and clearer.

2. Lambda Expressions: Each task uses an anonymous function to define its behavior. For example, task1Code runs every second and logs "Task 1 is running...", while task2Code runs every 1.5 seconds, logging "Task 2 is running...".

3. -> int: The -> int in task1Code indicates the Lambda returns an int. The function returns 0, but the return value is unused. If the Lambda doesn't return anything, you can omit -> or specify void, as in task2Code.

4. vTaskDelay: This FreeRTOS function controls the frequency of task execution. It sets each task's execution period.

Compilation and Flashing

Use the "ESP32-IDF: Build, Flash and Monitor" icon at the bottom of the VSCode window to build and flash the program to your ESP32 device.

Program Execution

After running the program, the terminal will display the following output:
I (1000) Example: Task 1 is running...
I (1500) Example: Task 2 is running...
I (2000) Example: Task 1 is running...
I (3000) Example: Task 1 is running...
I (3000) Example: Task 2 is running...
I (4000) Example: Task 1 is running...
I (4500) Example: Task 2 is running...

Conclusion

In this article, we learned how to use C++ Lambda expressions to create concise and efficient task management on the ESP32. This approach not only improves code readability but also allows us to leverage the powerful features of Lambda expressions to capture external variables and create custom task behaviors. We hope this guide helps you make the most of C++'s advantages in ESP32 development.
Tags

Related Posts