Tasks in ESP32: guidelines rather than blink example

Question

I'm using an ESP8266 for IOT devices.

I wish to work with an ESP32 and harvest its benefits - for my uses managing WiFi and MQTT connectivity.

Most tasks examples are very basic and quite the same (blinking LEDs). But for a real time application, more data is needed for which I can't find a guide.

For example:

1. when to use core0 or core1?
2. How to evaluate stack size needed for a task?
3. Are there any limitation for a task? Is a mqtt.loop() for example, ligit, memory wise?

I'd be happy to read about real life-implementations for tasks (especially "dos" and "don'ts")

Example usage from ESP32 DOCS

 // Dimensions the buffer that the task being created will use as its stack.
 // NOTE:  This is the number of bytes the stack will hold, not the number of
 // words as found in vanilla FreeRTOS.
#define STACK_SIZE 200
// Structure that will hold the TCB of the task being created.
 StaticTask_t xTaskBuffer;
// Buffer that the task being created will use as its stack.  Note this is
 // an array of StackType_t variables.  The size of StackType_t is dependent on
 // the RTOS port.
 StackType_t xStack[ STACK_SIZE ];
// Function that implements the task being created.
 void vTaskCode( void * pvParameters )
 {
     // The parameter value is expected to be 1 as 1 is passed in the
     // pvParameters value in the call to xTaskCreateStatic().
     configASSERT( ( uint32_t ) pvParameters == 1UL );
 for( ;; )
 {
     // Task code goes here.
 }

}
// Function that creates a task.
 void vOtherFunction( void )
 {
     TaskHandle_t xHandle = NULL;
 // Create the task without using any dynamic memory allocation.
 xHandle = xTaskCreateStatic(
               vTaskCode,       // Function that implements the task.
               "NAME",          // Text name for the task.
               STACK_SIZE,      // Stack size in bytes, not words.
               ( void * ) 1,    // Parameter passed into the task.
               tskIDLE_PRIORITY,// Priority at which the task is created.
               xStack,          // Array to use as the task's stack.
               &xTaskBuffer );  // Variable to hold the task's data structure.

 // puxStackBuffer and pxTaskBuffer were not NULL, so the task will have
 // been created, and xHandle will be the task's handle.  Use the handle
 // to suspend the task.
 vTaskSuspend( xHandle );

}

Answer 1

in a real time application, more data is needed which I can't find a guide for it

That is because there isn't one. The amount of memory needed is completely defined by the application and the task you want to run, so no "guide" can tell you what that will be.

You will have to analyze the actual software you want to run to see what it does and how it works to estimate the likely size of stack needed (note: stack is used for local (non-static) variables as well as storage for registers when calling functions). It's entirely up to you to work it out. The basic assumption (since the SDK is aimed at professional users not hobbyists like typical Arduino users) is that you know what your software is doing since it's you writing that software.

when to use core0 or core1?

When you need to balance your processing load. Again that's entirely down to your software and how you need it to work. Maybe you have one task that has to have almost exclusive use of a core - in which case you bind everything except that task to the same core, and place that task on its own core. Or maybe you just want to spread the tasks out evenly. It's your choice.

Are there any limitation for task?

Yes. The chip only has finite memory. You can't give a task more memory than there is. Also be aware that there may be a watchdog monitoring your tasks so you have to be sure to "kick" it regularly and not block too long.