- \r\n
- Semaphores<\/a>\r\n
- \r\n
- Binary Semaphores<\/a><\/li>\r\n
- Binary Semaphores – Interrupt-Controlled<\/a><\/li>\r\n
- Counting Semaphores – Counting Semaphores<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n
- Mutex Objects<\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n
- Passing Parameters to a task<\/a>\r\n
- \r\n
- One-time Passing as *pvParameters<\/a><\/li>\r\n
- Passing Parameters with Queues <\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n<\/ul>\r\n\n
What is FreeRTOS?<\/h2>\n\n
FreeRTOS is an open-source real-time operating system (RTOS) that has been specially developed for embedded systems. It offers a preemptive multitasking environment to fulfill real-time requirements in various applications. What? OK, this explanation probably needs a few explanations itself:<\/p>\r\n
- \r\n
- RTOS stands for Real-Time Operating System. In a real-time system, the focus is on the time frame for the execution of tasks.<\/li>\r\n
- Embedded systems are – among other things – microprocessors that are installed in certain devices or just microcontrollers. In contrast to conventional computers, which are suitable for a wide range of applications, embedded systems are designed for specific tasks or functions.<\/li>\r\n
- Preemptive means that a task can be interrupted to allow another task to be carried out.<\/li>\r\n<\/ul>\r\n
FreeRTOS was developed by Richard Barry in the early 2000s. It may be freely used, modified and redistributed. FreeRTOS supports various architectures and processors, including AVR, ARM, ESP, x86 and more. So there is not just one<\/em> FreeRTOS, but various customizations.<\/p>\r\n\n
FreeRTOS Documentation<\/h2>\n\n
For more in-depth information, I recommend that you take a look at the FreeRTOS documentation in parallel to this article, in particular the API reference(A<\/strong>pplication P<\/strong>rogramming I<\/strong>nterface), which you can find here<\/a>. It is clearly organized and should be easy to understand in conjunction with this article.<\/p>\r\n\n
Is Real Multitasking Possible with FreeRTOS?<\/h3>\n\n
Yes and no. Most microcontrollers only have one core. In these cases, so-called time slicing is used, which means that a certain processor time is allocated to each task. After the allocated time has elapsed, the task is interrupted, and it is the next task’s turn. These changes happen in quick succession, giving the impression of multitasking. One exception is the ESP32 because it has two cores. Tasks can actually be processed in parallel here. <\/p>\r\n\n
Which FreeRTOS implementations do we look at in this article?<\/h3>\n\n
In this article, I will look at the ESP32 and the AVR-based Arduino boards (e.g. the UNO R3, the classic Nano or the Pro Mini). The ESP32 already uses FreeRTOS in the Arduino environment. It is integrated via the esp32 board package<\/a>, so you don’t have to worry about the inclusion of FreeRTOS libraries. For the AVR Arduinos, there is the Arduino_FreeRTOS_Library<\/a>, which you can find and install under the name “FreeRTOS” in the Arduino library manager.<\/p>\r\n
Since there are a few minor differences in the use of FreeRTOS on the ESP32 and the AVR-based Arduinos, I have written and tested all sketches in two versions.<\/p>\r\n
There are many other FreeRTOS libraries, for example for SAMD21, SAMD51 and STM32 boards. I couldn’t try them all out, and certainly couldn’t cover them in detail here. But once you have familiarized yourself with FreeRTOS, further variants should not cause you any major problems. <\/p>\r\n\n
Creating and Using Tasks with FreeRTOS<\/h2>\n\n
We start quite simply with a blink sketch. Three LEDs should each flash at different frequencies. Without FreeRTOS you could achieve this with a
delay()<\/code> construction, but that would be the worst option. A solution \u00e0 laif((millis() - lastToggle) > blinkPeriod){...}<\/code> would be even better, as it would not be blocking. However, this can also cause problems if other processes delay themillis()<\/code> query. Alternatively, timer interrupts would be an option – provided there are enough timers available.<\/p>\r\nWith FreeRTOS we simply avoid these problems by giving each LED its own task. In principle, there are three blink sketches running in parallel.<\/p>\r\n
First, let us take a look at the code:<\/p>\r\n\n
\r\n#define LED1 25\r\n#define LED2 26\r\n#define LED3 17\r\n\r\nvoid setup() {\r\n pinMode(LED3, OUTPUT);\r\n \r\n xTaskCreate(\r\n blink1, \/\/ Function name of the task\r\n \"Blink 1\", \/\/ Name of the task (e.g. for debugging)\r\n 2048, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n\r\n xTaskCreate(\r\n blink2, \/\/ Function name of the task\r\n \"Blink 2\", \/\/ Name of the task (e.g. for debugging)\r\n 2048, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n}\r\n\r\nvoid blink1(void *parameter) {\r\n pinMode(LED1, OUTPUT);\r\n while(1){\r\n digitalWrite(LED1, HIGH);\r\n delay(500); \/\/ Delay for Tasks \r\n digitalWrite(LED1, LOW);\r\n delay(500);\r\n }\r\n}\r\n\r\nvoid blink2(void *parameter) {\r\n pinMode(LED2, OUTPUT);\r\n while(1) {\r\n digitalWrite(LED2, HIGH);\r\n delay(333);\r\n digitalWrite(LED2, LOW);\r\n delay(333);\r\n }\r\n}\r\n\r\nvoid loop(){\r\n digitalWrite(LED3, HIGH);\r\n delay(1111);\r\n digitalWrite(LED3, LOW);\r\n delay(1111);\r\n}<\/pre>\r\n#include<Arduino_FreeRTOS.h>\r\n#define LED1 7\r\n#define LED2 8\r\n#define LED3 9\r\n\r\nvoid setup() {\r\n xTaskCreate(\r\n blink1, \/\/ Function name of the task\r\n \"Blink 1\", \/\/ Name of the task (e.g. for debugging)\r\n 128, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n\r\n xTaskCreate(\r\n blink2, \/\/ Function name of the task\r\n \"Blink 2\", \/\/ Name of the task (e.g. for debugging)\r\n 128, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n\r\n xTaskCreate(\r\n blink3, \/\/ Function name of the task\r\n \"Blink 3\", \/\/ Name of the task (e.g. for debugging)\r\n 128, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n}\r\n\r\nvoid blink1(void *pvParameters){\r\n pinMode(LED1, OUTPUT);\r\n while(1){\r\n digitalWrite(LED1, HIGH);\r\n delay(500); \r\n digitalWrite(LED1, LOW);\r\n delay(500);\r\n }\r\n}\r\n\r\nvoid blink2(void *pvParameters){\r\n pinMode(LED2, OUTPUT);\r\n while(1){\r\n digitalWrite(LED2, HIGH);\r\n delay(333);\r\n digitalWrite(LED2, LOW);\r\n delay(333);\r\n }\r\n}\r\n\r\nvoid blink3(void *pvParameters){\r\n pinMode(LED3, OUTPUT);\r\n while(1){\r\n digitalWrite(LED3, HIGH);\r\n delay(1111); \r\n digitalWrite(LED3, LOW);\r\n delay(1111);\r\n }\r\n}\r\n\r\nvoid loop(){}<\/pre>\r\n<\/p>\r\n<\/div>\r\n\n
Explanation of the code <\/h3>\n\n
Creating the Task <\/h4>\n\n
If you want to execute an operation in a separate task, you must first create the task with
xTaskCreate()<\/code>. However, what you are creating is just a kind of empty shell that you will only fill with life in a second step. Here is the general form ofxTaskCreate()<\/code>:<\/p>\r\n\nBaseType_t xTaskCreate( TaskFunction_t pvTaskCode,\r\n const char * const pcName,\r\n configSTACK_DEPTH_TYPE usStackDepth,\r\n void *pvParameters,\r\n UBaseType_t uxPriority,\r\n TaskHandle_t *pxCreatedTask\r\n );<\/pre>\r\n\n
xTaskCreate Parameters<\/h4>\n\n
The six parameters to be passed are:<\/p>\r\n
- \r\n
- pvTaskCode<\/strong>: This is the name of the function that contains the code to be executed in the task. The procedure is similar to assigning an interrupt service routine in
attachInterrupt()<\/code>.<\/li>\r\n- pcName<\/strong>: This parameter allows you to give the task an easily understandable name, for example, “My favorite task”. pcName is passed as a pointer.<\/li>\r\n
- usStackdepth<\/strong>: The creation of your tasks also includes the definition of its size in the stack, which is a part of the SRAM. I have written an article about SRAM, stack and heap here<\/a>. We will come back to how you determine the size of the task.<\/li>\r\n
- pvParameters<\/strong>: You can pass parameters to the task as pointer. The variable type “void” may be unusual for many people. It makes the function very flexible. In this example, we pass nothing, i.e. NULL (a pointer to nowhere).<\/li>\r\n
- uxPriority<\/strong>: You can use this parameter to set the priority of the task.<\/li>\r\n
- pxCreatedTask<\/strong>: A task handle is an optional variable that you can use, for example, to query the properties of the task. You could say it is an identifier for the task. <\/li>\r\n<\/ul>\r\n\n
The naming of the prefixes of the variables and functions results from the variable type or the variable type of the return value. A “c” stands for “char”, an “s” for “short”, “v” for “void”, a “u” for “unsigned” and “x” for all non-standard types. If a variable is a pointer, a “p” is placed in front of it. You can find out more about the naming conventions here<\/a>.<\/p>\r\n
The
xTaskCreate()<\/code> function returnspdPASS<\/code> when the task has been successfully created. You could therefore check this withif(xTaskCreate(......)==pdPASS)){....}<\/code>. If the task could not be created, the function returnserrCOULD_NOT_ALLOCATE_REQUIRED_MEMORY<\/code>.<\/p>\r\n\nFilling the Task with Content – the Task Function<\/h4>\n\n
To fill the previously created task with life, use the task function that you have defined in
xTaskCreate()<\/code> (pvTaskCode). It is necessary to putvoid *pvParameters<\/code> again in the receiving function, even if you passNULL<\/code>. For example:void blink1(void *pvParameters){....}<\/code>.<\/p>\r\nThe following applies to the task function:<\/p>\r\n
- \r\n
- It has no return value.<\/li>\r\n
- Like a normal sketch, the task function consists of a kind of setup, i.e. code that is only executed once and a continuous loop that you realize with
while(1){....}<\/code> orfor(;;){....}<\/code>.<\/li>\r\n- A task can delete itself with
vTaskDelete( NULL );<\/code>. You can delete the task “from outside” using the task handle, i.e.vTaskDelete(pxCreatedTask)<\/code>.<\/li>\r\n<\/ul>\r\n\nThe behavior of
delay()<\/code> is interesting. Within the task,delay()<\/code> is blocking as usual. When switching tasks, however, thedelay()<\/code> is interrupted.<\/p>\r\n\nUsing loop()<\/h4>\n\n
As you can see, I have placed the code for LED3 in the ESP32 sketch in
loop()<\/code>. It’s not the best style, but I wanted to show that it works. If you do the same with an AVR-based Arduino, the program will hang. This is why the code for LED3 is outsourced to a third task.<\/p>\r\n\nTicks and vTaskDelay()<\/h2>\n\n
The tasks must share the processor core(s). To organize this, FreeRTOS divides the time into ticks. The task can use the processor undisturbed for the duration of one tick. After the tick has expired, the system checks whether another task is due.<\/p>\r\n
A tick is preset to 1 millisecond on the ESP32, which you check using
Serial.println(portTICK_PERIOD_MS)<\/code>. In other words, the tick frequency is 1 kHz. You can query the tick frequency withSerial.println(configTICK_RATE_HZ)<\/code>. The FreeRTOS version for the AVR-based Arduinos specifies a default tick frequency of 62 Hz, i.e. a tick has a length of approx. 16 milliseconds.<\/p>\r\nIf you search the net for FreeRTOS code examples, you will often come across the function
vTaskDelay()<\/code>. In principle, it does the same asdelay()<\/code>, with the difference that you passvTaskDelay()<\/code> ticks instead of milliseconds. This makes no difference with the ESP32, but it does with the AVR Arduinos. To achieve a waiting time of 500 milliseconds, you would have to write:vTaskDelay(500\/portTICK_PERIOD_MS)<\/code>.<\/p>\r\nI stick to the good old
delay()<\/code> in all examples.<\/p>\r\n\nDetermining the Memory Space Requirements of a FreeRTOS Task<\/h2>\n\n
Calculating the memory space required by the task is not trivial. Instead, we first reserve sufficient memory space and then use the function
uxTaskGetStackHighWaterMark()<\/code> to query the remaining free memory in the reserved area. To tell the functionuxTaskGetStackHighWaterMark()<\/code> which task we want to determine the free memory from, we pass it the task handle. You first create the handle withTaskHandle_t name<\/code> and assign it to the task inxTaskCreate()<\/code>.<\/p>\r\nI have reduced the following sketch to two blink tasks. To make it more obvious that
uxTaskGetStackHighWaterMark()<\/code> actually displays the free memory, I have varied the reserved memory for the tasks.<\/p>\r\nIf we were to implement the memory requirement query in the task to be examined, this would falsify the result. The memory query therefore has its own task.<\/p>\r\n\n
\r\n#define LED1 25\r\n#define LED2 26\r\n\r\nTaskHandle_t taskBlink1Handle; \/\/ create task handle\r\nTaskHandle_t taskBlink2Handle;\r\n\r\nvoid setup() {\r\n Serial.begin(115200);\r\n pinMode(LED1, OUTPUT);\r\n pinMode(LED2, OUTPUT);\r\n \r\n xTaskCreate(\r\n blink1, \/\/ Function name of the task\r\n \"Blink 1\", \/\/ Name of the task (e.g. for debugging)\r\n 2048, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n &taskBlink1Handle \/\/ Assign task handle\r\n );\r\n\r\n xTaskCreate(\r\n blink2, \/\/ Function name of the task\r\n \"Blink 2\", \/\/ Name of the task (e.g. for debugging)\r\n 1048, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n &taskBlink2Handle \/\/ Assign task handle\r\n );\r\n\r\n xTaskCreate(\r\n printWatermark, \/\/ Function name of the task\r\n \"Print Watermark\", \/\/ Name of the task (e.g. for debugging)\r\n 2048, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n}\r\n\r\nvoid blink1(void *pvParameters){\r\n while(1){\r\n digitalWrite(LED1, HIGH);\r\n delay(500); \r\n digitalWrite(LED1, LOW);\r\n delay(500);\r\n }\r\n}\r\n\r\nvoid blink2(void *pvParameters){\r\n while(1){\r\n digitalWrite(LED2, HIGH);\r\n delay(333);\r\n digitalWrite(LED2, LOW);\r\n delay(333);\r\n }\r\n}\r\n\r\nvoid printWatermark(void *pvParameters){\r\n while(1){\r\n delay(2000);\r\n Serial.print(\"TASK: \");\r\n Serial.print(pcTaskGetName(taskBlink1Handle)); \/\/ Get task name with handler\r\n Serial.print(\", High Watermark: \");\r\n Serial.print(uxTaskGetStackHighWaterMark(taskBlink1Handle));\r\n Serial.println();\r\n Serial.print(\"TASK: \");\r\n Serial.print(pcTaskGetName(taskBlink2Handle)); \/\/ Get task name with handler\r\n Serial.print(\", High Watermark: \");\r\n Serial.print(uxTaskGetStackHighWaterMark(taskBlink2Handle));\r\n Serial.println();\r\n }\r\n}\r\n\r\nvoid loop(){}<\/pre>\r\n#include<Arduino_FreeRTOS.h>\r\n#define LED1 7\r\n#define LED2 8\r\n\r\nTaskHandle_t taskBlink1Handle; \/\/ create task handle\r\nTaskHandle_t taskBlink2Handle;\r\n\r\nvoid setup() {\r\n Serial.begin(9600);\r\n pinMode(LED1, OUTPUT);\r\n pinMode(LED2, OUTPUT);\r\n \r\n xTaskCreate(\r\n blink1, \/\/ Function name of the task\r\n \"Blink 1\", \/\/ Name of the task (e.g. for debugging)\r\n 128, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n &taskBlink1Handle \/\/ Assign task handle\r\n );\r\n\r\n xTaskCreate(\r\n blink2, \/\/ Function name of the task\r\n \"Blink 2\", \/\/ Name of the task (e.g. for debugging)\r\n 98, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n &taskBlink2Handle \/\/ Assign task handle\r\n );\r\n\r\n xTaskCreate(\r\n printWatermark, \/\/ Function name of the task\r\n \"Print Watermark\", \/\/ Name of the task (e.g. for debugging)\r\n 128, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n}\r\n\r\nvoid blink1(void *pvParameters){\r\n while(1){\r\n digitalWrite(LED1, HIGH);\r\n delay(500); \r\n digitalWrite(LED1, LOW);\r\n delay(500);\r\n }\r\n}\r\n\r\nvoid blink2(void *pvParameters){\r\n while(1){\r\n digitalWrite(LED2, HIGH);\r\n delay(333);\r\n digitalWrite(LED2, LOW);\r\n delay(333);\r\n }\r\n}\r\n\r\nvoid printWatermark(void *pvParameters){\r\n while(1){\r\n delay(2000);\r\n Serial.print(\"TASK: \");\r\n Serial.print(pcTaskGetName(taskBlink1Handle)); \/\/ Get task name with handler\r\n Serial.print(\", High Watermark: \");\r\n Serial.print(uxTaskGetStackHighWaterMark(taskBlink1Handle));\r\n Serial.println();\r\n Serial.print(\"TASK: \");\r\n Serial.print(pcTaskGetName(taskBlink2Handle)); \/\/ Get task name with handler\r\n Serial.print(\", High Watermark: \");\r\n Serial.print(uxTaskGetStackHighWaterMark(taskBlink2Handle));\r\n Serial.println();\r\n }\r\n}\r\n\r\nvoid loop(){}<\/pre>\r\n<\/p>\r\n<\/div>\r\n\n
And here is the output:<\/p>\r\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/12\/Output_freertos_watermark_esp32_avr.webp\")
Output of the FreeRTOS high watermark sketches, left: ESP32, right: AVR Arduino (Nano)<\/figcaption><\/figure>\n\n We can deduce from this:<\/p>\r\n
- \r\n
- The tasks require the following memory space on the ESP32: 1048 – 500 or 2048 – 1500 = 548 byte.<\/li>\r\n
- On the AVR Arduino it is: 128 – 78 or 98 – 48 = 50 byte.<\/li>\r\n<\/ul>\r\n
The AVR Arduino therefore uses the memory more sparingly, which it has to, as its SRAM is only a fraction of the ESP32 SRAM. <\/p>\r\n
If you apply the exact values just determined, the sketch will probably crash. Reserve a few more bytes for the tasks. <\/p>\r\n
What you can also learn from the example sketch is how to get the name of the task using
pcTaskGetName()<\/code>.<\/p>\r\n\nSuspending and Resuming tasks <\/h2>\n\n
Tasks can be suspended easily with
vTaskSuspend(taskHandle);<\/code> and resumed withvTaskResume(taskHandle);<\/code>. In the following sketch, we use one task to make an LED flash and another task to stop it flashing regularly.<\/p>\r\n\n#define LED1 25\r\nTaskHandle_t blink1Handle;\r\n\r\nvoid setup() {\r\n xTaskCreate(\r\n blink1, \/\/ Function name of the task\r\n \"Blink 1\", \/\/ Name of the task (e.g. for debugging)\r\n 2048, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n &blink1Handle \/\/ Task handle\r\n );\r\n xTaskCreate(\r\n suspend_resume, \/\/ Function name of the task\r\n \"Suspend Resume\", \/\/ Name of the task (e.g. for debugging)\r\n 2048, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n}\r\n\r\nvoid blink1(void *pvParameters){\r\n pinMode(LED1, OUTPUT);\r\n while(1){\r\n digitalWrite(LED1, HIGH);\r\n delay(100); \r\n digitalWrite(LED1, LOW);\r\n delay(100);\r\n }\r\n}\r\n\r\nvoid suspend_resume(void *pvParameters){\r\n pinMode(LED1, OUTPUT);\r\n while(1){\r\n delay(1999);\r\n vTaskSuspend(blink1Handle);\r\n delay(999);\r\n vTaskResume(blink1Handle);\r\n }\r\n}\r\n\r\nvoid loop(){}<\/pre>\r\n#include<Arduino_FreeRTOS.h>\r\n#define LED1 7\r\nTaskHandle_t blink1Handle;\r\n\r\nvoid setup() {\r\n xTaskCreate(\r\n blink1, \/\/ Function name of the task\r\n \"Blink 1\", \/\/ Name of the task (e.g. for debugging)\r\n 128, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n &blink1Handle \/\/ Task handle\r\n );\r\n\r\n xTaskCreate(\r\n suspend_resume, \/\/ Function name of the task\r\n \"Suspend Resume\", \/\/ Name of the task (e.g. for debugging)\r\n 128, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n}\r\n\r\nvoid blink1(void *pvParameters){\r\n pinMode(LED1, OUTPUT);\r\n while(1){\r\n digitalWrite(LED1, HIGH);\r\n delay(100); \r\n digitalWrite(LED1, LOW);\r\n delay(100);\r\n }\r\n}\r\n\r\nvoid suspend_resume(void *pvParameters){\r\n while(1){\r\n delay(1900);\r\n vTaskSuspend(blink1Handle);\r\n delay(900);\r\n vTaskResume(blink1Handle);\r\n }\r\n}\r\n\r\nvoid loop(){}<\/pre>\r\n<\/p>\r\n\n
Determining the Executing Core<\/h2>\n\n
Two cores are available on the ESP32, 0 and 1. We can use the function
xTaskCreatePinnedToCore()<\/code> to determine on which of the cores the task is to be executed. The function is passed the same parameters asxCreateTask()<\/code>, except that the core is added at the end. Here is a simple example.<\/p>\r\n\n\r\nvoid setup() {\r\n Serial.begin(115200);\r\n xTaskCreatePinnedToCore(\r\n print1, \/\/ Function name of the task\r\n \"Print 1\", \/\/ Name of the task (e.g. for debugging)\r\n 2048, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL, \/\/ Task handle\r\n 0 \/\/ run on Core 0\r\n );\r\n\r\n xTaskCreatePinnedToCore(\r\n print2, \/\/ Function name of the task\r\n \"Print 2\", \/\/ Name of the task (e.g. for debugging)\r\n 2048, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL, \/\/ Task handle\r\n 1 \/\/ run on Core 1\r\n );\r\n}\r\n\r\nvoid print1(void *pvParameters){\r\n while(1){\r\n Serial.print(\"Task is running on core \");\r\n Serial.println(xPortGetCoreID());\r\n delay(2500);\r\n }\r\n}\r\n\r\nvoid print2(void *pvParameters){\r\n while(1){\r\n Serial.print(\"Task is running on core \");\r\n Serial.println(xPortGetCoreID());\r\n delay(1500);\r\n }\r\n}\r\n\r\nvoid loop(){}<\/pre>\r\n<\/p>\r\n<\/div>\r\n\n
As you can see, you can use
xPortGetCoreID()<\/code> to check on which core the task is being executed.<\/p>\r\n\nWhich Core Should I Use? <\/h4>\n\n
By default, your Arduino code is executed on core 1. If you use Wi-Fi or BLE, a lot of work is required in the background, which is carried out on core 0. If you assign core 0 too many extra tasks, your Wi-Fi and BLE may no longer work reliably. If you don’t use these functions, you don’t need to worry about this issue.<\/p>\r\n\n
Synchronizing FreeRTOS Tasks – Semaphore and Mutex<\/h2>\n\n
If tasks access the same resources, such as external sensors, EEPROMs, ADCs, serial communication, etc., they could interfere with each other with unforeseeable consequences. If this could potentially happen, then the tasks must be synchronized (in the sense of coordinated, not simultaneously). There are two techniques for this, namely semaphores and mutex.<\/p>\r\n
The term semaphore comes from ancient Greek. Sema means sign and phoros means carrying. Put together, this means “signal transmitter”, like, for example, traffic lights. In other words: the (alternatively: the) semaphore gives the task the signal to be allowed to start.<\/p>\r\n
Mutex stands for “Mutual Exclusion Object”, which means that the tasks are mutually excluded. The mutex is very similar to the semaphore, but there are a few subtle differences (see also here<\/a> in the FreeRTOS documentation). <\/p>\r\n
You could say it’s like the baton at a relay race. Only those who have it are allowed to start running. However, the comparison is a little off because the handover runner is allowed to continue running. <\/p>\r\n\n
Semaphores<\/h2>\n\n
There are two types of semaphores, namely binary semaphores and counting semaphores. I will explain the difference using examples.<\/p>\r\n\n
Binary Semaphores – Binary Semaphores<\/h3>\n\n
In the first step, you create a semaphore handle with
SemaphoreHandle_t xSemaphore;<\/code>, which you use in the second step to fill the semaphore with life:xSemaphore = xSemaphoreCreateBinary();<\/code>. You can replace “xSemaphore” with a name of your choice. In the following, I will refer to the semaphore as “sem” for short.<\/p>\r\nAnd these are the rules of the game: for the semaphore to be used, it must be released with
xSemaphoreGive(sem)<\/code>. To receive the semaphore, there is the functionxSemaphoreTake(sem, xTicksToWait)<\/code> withxTicksToWait<\/code> as the maximum waiting time in ticks. If the semaphore was accepted within the waiting time, the function return value ispdTRUE<\/code>, otherwisepdFALSE<\/code>.<\/p>\r\nEach task can release the semaphore provided it is in its possession. And every task can accept the semaphore if it is available.<\/p>\r\n
You often want the task to wait as long as necessary. In this case, you pass
portMAX_DELAY<\/code> asxTicksToWait<\/code>. On the ESP32portMAX_DELAY<\/code> is 232<\/sup> – 1, on the AVR Arduinos it is 216<\/sup> – 1.<\/p>\r\n\nBinary Semaphores – Example Sketch I<\/h4>\n\n
We flash two LEDs again, but this time alternately. First one LED should flash 10 times, then the other and so on alternately.<\/p>\r\n\n
\r\n#define LED1 25\r\n#define LED2 26\r\n\r\nSemaphoreHandle_t sem; \/\/ Create semaphore handle\r\n\r\nvoid setup() {\r\n sem = xSemaphoreCreateBinary(); \/\/ Create binary semaphore\r\n \r\n xTaskCreate(\r\n blink1, \/\/ Function name of the task\r\n \"Blink 1\", \/\/ Name of the task (e.g. for debugging)\r\n 2048, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n xTaskCreate(\r\n blink2, \/\/ Function name of the task\r\n \"Blink 2\", \/\/ Name of the task (e.g. for debugging)\r\n 2048, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n xSemaphoreGive(sem);\r\n}\r\n\r\nvoid blink1(void *pvParameters){\r\n pinMode(LED1, OUTPUT);\r\n while(1){\r\n xSemaphoreTake(sem,portMAX_DELAY);\r\n for(int i=0; i<10; i++){\r\n digitalWrite(LED1, HIGH);\r\n delay(250);\r\n digitalWrite(LED1, LOW);\r\n delay(250);\r\n }\r\n xSemaphoreGive(sem);\r\n delay(100); \/\/ Short delay is needed!\r\n }\r\n}\r\n\r\nvoid blink2(void *pvParameters){\r\n pinMode(LED2, OUTPUT);\r\n while(1){\r\n xSemaphoreTake(sem,portMAX_DELAY);\r\n for(int i=0; i<10; i++){\r\n digitalWrite(LED2, HIGH);\r\n delay(333);\r\n digitalWrite(LED2, LOW);\r\n delay(333); \r\n }\r\n xSemaphoreGive(sem);\r\n delay(100); \/\/ Short delay is needed!\r\n }\r\n}\r\n\r\nvoid loop(){}<\/pre>\r\n#include <Arduino_FreeRTOS.h>\r\n#include <semphr.h> \/\/ Needed in case if you want to use semaphores\r\n\r\n#define LED1 7\r\n#define LED2 8\r\n\r\nSemaphoreHandle_t sem; \/\/ Create semaphore handle\r\n\r\nvoid setup() {\r\n sem = xSemaphoreCreateBinary(); \/\/ Create binary semaphore\r\n \r\n xTaskCreate(\r\n blink1, \/\/ Function name of the task\r\n \"Blink 1\", \/\/ Name of the task (e.g. for debugging)\r\n 128, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n xTaskCreate(\r\n blink2, \/\/ Function name of the task\r\n \"Blink 2\", \/\/ Name of the task (e.g. for debugging)\r\n 128, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n xSemaphoreGive(sem); \/\/ Release semaphore\r\n}\r\n\r\nvoid blink1(void *pvParameters){\r\n pinMode(LED1, OUTPUT);\r\n while(1){\r\n xSemaphoreTake(sem,portMAX_DELAY); \/\/ Take semaphore\r\n for(int i=0; i<10; i++){\r\n digitalWrite(LED1, HIGH);\r\n delay(250);\r\n digitalWrite(LED1, LOW);\r\n delay(250);\r\n }\r\n xSemaphoreGive(sem); \/\/ Release semaphore\r\n delay(100); \/\/ Short delay is needed!\r\n }\r\n}\r\n\r\nvoid blink2(void *pvParameters){\r\n pinMode(LED2, OUTPUT);\r\n while(1){\r\n xSemaphoreTake(sem,portMAX_DELAY); \/\/ Take semaphore\r\n for(int i=0; i<10; i++){\r\n digitalWrite(LED2, HIGH);\r\n delay(333);\r\n digitalWrite(LED2, LOW);\r\n delay(333); \r\n }\r\n xSemaphoreGive(sem); \/\/ Release semaphore\r\n delay(100); \/\/ Short delay is needed!\r\n }\r\n}\r\n\r\nvoid loop(){}<\/pre>\r\n<\/p>\r\n<\/div>\r\n\n
The semaphore is created and released in the setup. One of the two tasks takes it, and this task can start. As long as the semaphore is not released again, the second task must wait. If the semaphore was released by the first task and accepted by the second, the first task must wait again when it encounters the
xSemaphoreTake()<\/code> function. <\/p>\r\nPassing the semaphore does not work without a short
delay()<\/code> afterxSemaphoreGive()<\/code>. Apparently, the task currently executing “grabs” the semaphore itself. Thedelay()<\/code> must therefore be at least one tick long.<\/p>\r\nIn this example, we have not clearly defined which of the two tasks is executed first after the program starts. You can control this by giving one of the two tasks in
xTaskCreate()<\/code> a higher priority. <\/p>\r\nFor the AVR Arduino version, you need to include the library file semphr.h in order to be able to use the semaphore functions.<\/p>\r\n\n
Binary Semaphores – Example Sketch II <\/h4>\n\n
The last example sketch may have given the impression that the binary semaphore is exclusive , i.e. it only allows one of the tasks to be executed. The next sketch shows that this is not the case:<\/p>\r\n\n
\r\n#define LED1 25\r\n#define LED2 26\r\n\r\nSemaphoreHandle_t sem; \/\/ Create semaphore handle \r\nvoid setup() {\r\n sem = xSemaphoreCreateBinary(); \/\/ Create a binary semaphore\r\n \r\n xTaskCreate(\r\n blink1, \/\/ Function name of the task\r\n \"Blink 1\", \/\/ Name of the task (e.g. for debugging)\r\n 2048, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n xTaskCreate(\r\n blink2, \/\/ Function name of the task\r\n \"Blink 2\", \/\/ Name of the task (e.g. for debugging)\r\n 2048, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n}\r\n\r\nvoid blink1(void *pvParameters){\r\n pinMode(LED1, OUTPUT);\r\n while(1){\r\n for(int i=0; i<10; i++){\r\n digitalWrite(LED1, HIGH);\r\n delay(250);\r\n digitalWrite(LED1, LOW);\r\n delay(250);\r\n }\r\n xSemaphoreGive(sem); \/\/ Release semaphore\r\n delay(7000); \/\/ Give time to execute blink2\r\n }\r\n}\r\n\r\nvoid blink2(void *pvParameters){\r\n while(1){\r\n pinMode(LED2, OUTPUT);\r\n xSemaphoreTake(sem,portMAX_DELAY); \/\/ Take semaphore\r\n for(int i=0; i<10; i++){\r\n digitalWrite(LED2, HIGH);\r\n delay(333);\r\n digitalWrite(LED2, LOW);\r\n delay(333); \r\n }\r\n }\r\n}\r\n\r\nvoid loop(){}<\/pre>\r\n#include <Arduino_FreeRTOS.h>\r\n#include <semphr.h>\r\n\r\n#define LED1 7\r\n#define LED2 8\r\n\r\nSemaphoreHandle_t sem; \/\/ Create semaphore handle\r\n\r\nvoid setup() {\r\n sem = xSemaphoreCreateBinary(); \/\/ Create binary semaphore\r\n \r\n xTaskCreate(\r\n blink1, \/\/ Function name of the task\r\n \"Blink 1\", \/\/ Name of the task (e.g. for debugging)\r\n 128, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n xTaskCreate(\r\n blink2, \/\/ Function name of the task\r\n \"Blink 2\", \/\/ Name of the task (e.g. for debugging)\r\n 128, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n}\r\n\r\nvoid blink1(void *pvParameters){\r\n pinMode(LED1, OUTPUT);\r\n while(1){\r\n for(int i=0; i<10; i++){\r\n digitalWrite(LED1, HIGH);\r\n delay(250);\r\n digitalWrite(LED1, LOW);\r\n delay(250);\r\n }\r\n xSemaphoreGive(sem); \/\/ Release semaphore\r\n delay(7000); \/\/ Give time to execute blink2\r\n }\r\n}\r\n\r\nvoid blink2(void *pvParameters){\r\n pinMode(LED2, OUTPUT);\r\n while(1){\r\n xSemaphoreTake(sem, portMAX_DELAY); \/\/ Take semaphore\r\n for(int i=0; i<10; i++){\r\n digitalWrite(LED2, HIGH);\r\n delay(333);\r\n digitalWrite(LED2, LOW);\r\n delay(333); \r\n }\r\n }\r\n}\r\n\r\nvoid loop(){}<\/pre>\r\n<\/p>\r\n<\/div>\r\n\n
In contrast to the previous example, the semaphore is not released in the setup here. The blink2 task is therefore initially blocked by
xSemaphoreTake()<\/code>. However, this does not apply to the blink1 task. After LED1 has flashed ten times, the semaphore is released, but blink1 continues to run for another seven seconds with adelay()<\/code>. In these seven seconds, the while loop in blink2 is run through once before it blocks due to a missing free semaphore. So it’s blink1’s turn and the game starts all over again.<\/p>\r\n\nBinary Semaphores – Example Sketch III<\/h4>\n\n
I would like to present a third example sketch to deepen the knowledge. Here we let LED1 flash ten times again, but after the fifth flash, LED2 flashes ten times quickly while LED 1 continues to flash. This perhaps shows a little more clearly how the tasks are controlled in terms of time by semaphores.<\/p>\r\n\n
\r\n#define LED1 25\r\n#define LED2 26\r\n\r\nSemaphoreHandle_t sem; \/\/ Create semaphore handle \r\n\r\nvoid setup() {\r\n sem = xSemaphoreCreateBinary(); \/\/ Create binary semaphore \r\n \r\n xTaskCreate(\r\n blink1, \/\/ Function name of the task\r\n \"Blink 1\", \/\/ Name of the task (e.g. for debugging)\r\n 2048, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n xTaskCreate(\r\n blink2, \/\/ Function name of the task\r\n \"Blink 2\", \/\/ Name of the task (e.g. for debugging)\r\n 2048, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n}\r\n\r\nvoid blink1(void *pvParameters){\r\n pinMode(LED1, OUTPUT);\r\n while(1){\r\n for(int i=0; i<5; i++){\r\n digitalWrite(LED1, HIGH);\r\n delay(250);\r\n digitalWrite(LED1, LOW);\r\n delay(250);\r\n }\r\n xSemaphoreGive(sem); \/\/ Release semaphore\r\n for(int i=0; i<5; i++){\r\n digitalWrite(LED1, HIGH);\r\n delay(250);\r\n digitalWrite(LED1, LOW);\r\n delay(250);\r\n }\r\n delay(2000);\r\n }\r\n}\r\n\r\nvoid blink2(void *pvParameters){\r\n pinMode(LED2, OUTPUT);\r\n while(1){\r\n xSemaphoreTake(sem,portMAX_DELAY); \/\/ take semaphore\r\n for(int i=0; i<10; i++){\r\n digitalWrite(LED2, HIGH);\r\n delay(50);\r\n digitalWrite(LED2, LOW);\r\n delay(50); \r\n }\r\n }\r\n}\r\n\r\nvoid loop(){}<\/pre>\r\n#include <Arduino_FreeRTOS.h>\r\n#include <semphr.h>\r\n#define LED1 7\r\n#define LED2 8\r\n\r\nSemaphoreHandle_t sem; \/\/ create semaphore handle \r\n\r\nvoid setup() {\r\n sem = xSemaphoreCreateBinary(); \/\/ create binary semaphore\r\n \r\n xTaskCreate(\r\n blink1, \/\/ Function name of the task\r\n \"Blink 1\", \/\/ Name of the task (e.g. for debugging)\r\n 128, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n xTaskCreate(\r\n blink2, \/\/ Function name of the task\r\n \"Blink 2\", \/\/ Name of the task (e.g. for debugging)\r\n 128, \/\/ Stack size (bytes)\r\n NULL, \/\/ Parameter to pass\r\n 1, \/\/ Task priority\r\n NULL \/\/ Task handle\r\n );\r\n}\r\n\r\nvoid blink1(void *pvParameters){\r\n pinMode(LED1, OUTPUT);\r\n while(1){\r\n for(int i=0; i<5; i++){\r\n digitalWrite(LED1, HIGH);\r\n delay(250);\r\n digitalWrite(LED1, LOW);\r\n delay(250);\r\n }\r\n xSemaphoreGive(sem); \/\/ release semaphore\r\n for(int i=0; i<5; i++){\r\n digitalWrite(LED1, HIGH);\r\n delay(250);\r\n digitalWrite(LED1, LOW);\r\n delay(250);\r\n }\r\n delay(2000);\r\n }\r\n}\r\n\r\nvoid blink2(void *pvParameters){\r\n pinMode(LED2, OUTPUT);\r\n while(1){\r\n xSemaphoreTake(sem,portMAX_DELAY); \/\/ take semaphore\r\n for(int i=0; i<10; i++){\r\n digitalWrite(LED2, HIGH);\r\n delay(50);\r\n digitalWrite(LED2, LOW);\r\n delay(50); \r\n }\r\n }\r\n}\r\n\r\nvoid loop(){}<\/pre>\r\n<\/p>\r\n<\/div>\r\n\n
Binary Semaphores – Interrupt-Controlled<\/h3>\n\n
In the last example sketch for binary semaphores, I would like to show you how to release semaphores in an interrupt routine (ISR). To try out the following sketch, connect two buttons to your ESP32 or AVR Arduino. Connect the buttons to an interrupt pin on one side and to GND on the other. Otherwise, the LEDs are used again. One push-button should cause LED1 to flash, the other push-button controls LED2.<\/p>\r\n
- A task can delete itself with
- pcName<\/strong>: This parameter allows you to give the task an easily understandable name, for example, “My favorite task”. pcName is passed as a pointer.<\/li>\r\n
- pvTaskCode<\/strong>: This is the name of the function that contains the code to be executed in the task. The procedure is similar to assigning an interrupt service routine in
- Passing Parameters with Queues <\/a><\/li>\r\n<\/ul>\r\n<\/li>\r\n<\/ul>\r\n\n
- Binary Semaphores – Interrupt-Controlled<\/a><\/li>\r\n
- Binary Semaphores<\/a><\/li>\r\n