ESP32 Multicore Programming Techniques: Dual-Core Task Allocation

The dual-core architecture of the ESP32 (two Xtensa LX6 cores) combined with the FreeRTOS real-time operating system enables efficient task parallelization. Below are the key technical points, practical recommendations, and code examples for ESP32 Dual-Core Task Allocation:

1. Core Strategies for Dual-Core Task Allocation

Core Responsibility Division:

Core 0 is typically used to run the Wi-Fi/BLE protocol stack (managed by ESP-IDF by default), suitable for handling network communication and low-power tasks.
Core 1 serves as the user main task core, suitable for executing high-priority tasks (such as sensor data collection, algorithm computation, and real-time control).

Task Binding Rules:

Use xTaskCreatePinnedToCore() to explicitly bind tasks to a specified core (parameter xCoreID can be 0 or 1).
Avoid binding high-latency tasks (such as Wi-Fi/BLE interrupt handling) to Core 1 to prevent interference with user logic.

2. Key Functions and Code Examples

1. Creating Tasks Bound to a Specified Core

// Core 0 Task: Network Monitoring
void taskCore0(void *pvParam) {
    while (1) {
        Serial.printf("[Core0] WiFi Signal Strength: %d dBm\n", WiFi.RSSI());
        vTaskDelay(2000 / portTICK_PERIOD_MS); // Delay 2 seconds
    }
}

// Core 1 Task: Sensor Collection
void taskCore1(void *pvParam) {
    while (1) {
        float temp = random(200, 300) / 10.0; // Simulate temperature sensor
        Serial.printf("[Core1] Current Temperature: %.1f°C\n", temp);
        vTaskDelay(1000 / portTICK_PERIOD_MS); // Delay 1 second
    }
}

void setup() {
    Serial.begin(115200);

    // Create task bound to Core 0
    xTaskCreatePinnedToCore(taskCore0, "Core0_Task", 4096, NULL, 1, NULL, 0);

    // Create task bound to Core 1
    xTaskCreatePinnedToCore(taskCore1, "Core1_Task", 4096, NULL, 1, NULL, 1);
}

void loop() {
    // Main loop can remain empty, tasks are scheduled by FreeRTOS
}

2. Getting the Current Task’s Running Core ID

void setup() {
    Serial.begin(115200);
    Serial.print("Current Running Core: ");
    Serial.println(xPortGetCoreID()); // Output 0 or 1
}

3. Considerations for Dual-Core Task Allocation

Resource Contention and Synchronization:

Shared Resources (such as global variables and peripherals) need to be protected by mutexes or semaphores.
Example: Use xSemaphoreCreateBinary() to create a mutex, and control access using xSemaphoreTake()/xSemaphoreGive().

Stack Size and Priority:

Stack Size should be adjusted based on task complexity (recommended 2048~8192 bytes). Monitor stack usage with uxTaskGetStackHighWaterMark().
Priority to avoid priority inversion, it is recommended to set 3-4 priority levels (0 being the lowest, configMAX_PRIORITIES-1 being the highest).

Interrupt Handling:

GPIO Interrupts use gpio_install_isr_service() to register interrupt service routines (ISRs), and use xTaskNotifyFromISR() to wake tasks.
Avoid executing blocking operations in ISRs (such as vTaskDelay()).

Debugging and Monitoring:

Use vTaskList() to view task status (name, priority, stack usage):
```
char buffer[512];
vTaskList(buffer);
Serial.println(buffer);
```
Enable Segger SystemView or ESP-IDF Debugger for visual scheduling analysis.

4. Typical Application Scenarios

Parallel Processing of Sensors and Network:

Core 0 handles Wi-Fi connection and MQTT communication.
Core 1 collects sensor data and performs local computations.

Dual-Screen Display Optimization:

Core 0 drives the OLED screen (low refresh rate).
Core 1 drives the LCD screen (high refresh rate).

Real-Time Audio Processing:

Core 0 handles I2S audio input/output.
Core 1 runs audio filtering algorithms.

5. Advanced Optimization Techniques

Dynamic Core Switching:

Use tskNO_AFFINITY to create tasks without core binding, allowing FreeRTOS to schedule automatically.

Example:

xTaskCreate(taskFunction, "NoAffinityTask", 4096, NULL, 1, NULL);

Low Power Mode:

When running the Wi-Fi/BLE protocol stack on Core 0, dynamically adjust CPU frequency using esp_pm_configure().

PSRAM Usage:

Enable CONFIG_SPIRAM_USE_MALLOC to extend memory, but be aware of DMA limitations (e.g., SPI operations need 32-byte alignment).

Watchdog Configuration:

Add watchdog protection for long tasks:

esp_task_wdt_add(NULL); // Add watchdog for current task
esp_task_wdt_reset();   // Regularly feed the watchdog

6. Common Issues and Solutions

Issue	Cause	Solution
Task hangs on a core	Stack overflow or priority inversion	Increase stack size, use mutexes, check priority gradient
Core 0 response slows down	User tasks occupying Core 0 resources	Migrate user tasks to Core 1
Interrupt response delay	Time-consuming operations executed in ISR	Use `<span>xTaskNotifyFromISR()</span>` to wake task for processing
Memory leak	Dynamic allocated task stack not released	Use `<span>vTaskDelete(NULL)</span>` to delete task and manually free resources

7. Conclusion

The dual-core architecture of the ESP32 can significantly enhance system performance and real-time capabilities through proper task allocation. The key points are:

Clearly define core responsibilities (Core 0 retains the protocol stack, Core 1 handles user logic).
Use FreeRTOS API to precisely bind tasks (xTaskCreatePinnedToCore()).
Avoid resource contention and blocking operations, coordinating tasks through synchronization mechanisms (mutexes, queues).
Monitor and debug (vTaskList(), uxTaskGetStackHighWaterMark()) to ensure system stability.

By following these strategies, efficient and stable dual-core parallel processing can be achieved on the ESP32, suitable for complex scenarios such as IoT devices and smart homes.

ESP32 Development Board Three Days to Master Microcontrollers Arduino Development Board

STM32 Development Board