In our previous article, we explored the basics of ESP32 TWAI and its application methods in detail. However, as development requirements grow, using simple blocking or polling methods is no longer sufficient for efficient communication. In this article, we will dive into how to leverage the ESP32 TWAI driver combined with FreeRTOS tasks to achieve efficient CAN Bus data transmission and reception in a multitasking environment.

Introduction

ESP32 TWAI, or Two-Wire Automotive Interface, is essentially the same as the well-known CAN Bus (Controller Area Network). It is a multi-master, multi-point communication protocol widely used in automotive electronic systems to enable communication between different Electronic Control Units (ECUs). The advantages of CAN Bus lie in its high reliability and real-time capability, which allow it to operate stably even in harsh environments.

ESP32 TWAI and FreeRTOS Tasks

ESP32 includes a built-in TWAI controller, making it particularly adept at handling CAN Bus communication. When combined with FreeRTOS multitasking, it enables more efficient data transmission and reception while better managing system resources.

Key advantages of combining ESP32 TWAI with FreeRTOS tasks:

• Hardware-level support:
  ESP32’s TWAI offers native hardware support for CAN Bus, providing more stable and efficient data transmission compared to solutions relying on external modules. It also includes built-in error handling features.
• Multitasking management with FreeRTOS:
  Using FreeRTOS tasks allows data transmission and reception operations to be handled in separate tasks, enabling parallel processing and preventing blocking operations from impacting other system functions.
• Real-time capability:
  With FreeRTOS, task priorities can be set to ensure that critical data transmissions and receptions have higher real-time performance.
• Scalability:
  The task-based approach is easy to expand, allowing for the addition of features such as data logging, error analysis, or low-power modes.

Development Environment

Before you start programming, make sure to set up the following:

• Install ESP-IDF (version 4.4 or higher): ESP-IDF is the official development framework for programming the ESP32, and it supports multiple operating systems such as Windows, macOS, and Linux.
• ESP32 Development Board: You’ll need an ESP32 board, which has built-in capabilities for CAN communication.
• CAN Transceiver Module: A CAN transceiver like the MCP2551 or SN65HVD230 is required to connect the ESP32 to the CAN bus network.
• CAN Devices or Simulator (Optional): You may need additional CAN devices or a simulator to test your setup.

Creating a FreeRTOS Task for Sending Data

The send task is responsible for periodically sending data to the CAN Bus.

void send_task(void *arg) {
    while (1) {
        twai_message_t message = {
            .identifier = 0x123,  // Set message ID
            .data_length_code = 8,  // Set data length
            .data = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}  // Data to send
        };

        esp_err_t err = twai_transmit(&message, pdMS_TO_TICKS(1000));
        if (err == ESP_OK) {
            ESP_LOGI(TAG, "Message sent successfully");
        } else {
            ESP_LOGE(TAG, "Message transmission failed: %s", esp_err_to_name(err));
        }

        vTaskDelay(pdMS_TO_TICKS(1000));  // Send message every second
    }
}

Creating a FreeRTOS Task for Receiving Data

The receive task is responsible for retrieving and processing data from the CAN Bus.

void receive_task(void *arg) {
    while (1) {
        twai_message_t message;
        esp_err_t err = twai_receive(&message, pdMS_TO_TICKS(1000));
        if (err == ESP_OK) {
            ESP_LOGI(TAG, "Message received: ID=0x%X, Data=[%02X %02X %02X %02X %02X %02X %02X %02X]",
                     message.identifier,
                     message.data[0], message.data[1], message.data[2], message.data[3],
                     message.data[4], message.data[5], message.data[6], message.data[7]);
        } else if (err == ESP_ERR_TIMEOUT) {
            ESP_LOGW(TAG, "Reception timed out");
        } else {
            ESP_LOGE(TAG, "Message reception failed: %s", esp_err_to_name(err));
        }
    }
}

Initializing the ESP32 TWAI Driver & app_main

Configure and install the ESP32 TWAI driver.

#include "driver/twai.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"

#define TAG "TWAI"

void app_main() {
    // Configure TWAI driver
    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_1MBITS();  // Set to 1 Mbps
    twai_filter_config_t f_config = TWAI_FILTER_CONFIG_ACCEPT_ALL();  // Accept all messages

    // Install TWAI driver
    esp_err_t err = twai_driver_install(&g_config, &t_config, &f_config);
    if (err == ESP_OK) {
        ESP_LOGI(TAG, "TWAI driver installed successfully");
    } else {
        ESP_LOGE(TAG, "Failed to install TWAI driver: %s", esp_err_to_name(err));
        return;
    }

    // Start TWAI driver
    err = twai_start();
    if (err == ESP_OK) {
        ESP_LOGI(TAG, "TWAI driver started successfully");
    } else {
        ESP_LOGE(TAG, "Failed to start TWAI driver: %s", esp_err_to_name(err));
        return;
    }

    // Create tasks
    xTaskCreate(send_task, "send_task", 2048, NULL, 5, NULL);
    xTaskCreate(receive_task, "receive_task", 2048, NULL, 5, NULL);
}

Output Results

After running the code, the ESP32 will:

• Send data to the CAN Bus every second.
• Receive data from the CAN Bus and print it to the serial monitor.

Example output:

I (5000) TWAI: Message sent successfully
I (6010) TWAI: Message received: ID=0x123, Data=[01 02 03 04 05 06 07 08]

Performance and Optimization

• Real-time capability:
  FreeRTOS tasks enable parallel processing of data transmission and reception, ensuring real-time performance.
• Error handling:
  The TWAI driver includes built-in error handling mechanisms such as automatic retransmission and error recovery. You can also implement custom error handling by setting callback functions.
• Low-power mode:
  ESP32 supports low-power modes, allowing the system to conserve energy when idle.

Conclusion

Mastering the combination of ESP32 TWAI and FreeRTOS provides a powerful tool for implementing CAN Bus communication. Whether for data transmission or reception, this approach ensures efficient and stable operations. The example code and technical insights presented in this article will help you leverage ESP32 for your embedded development projects.