Video implementing dual core multitasking and synchronization in the sparkfun ESP 32 thing. In this video we will learn the following multitasking in the ESP 32. Implementing tasks implementing Center offers. The ESP 32 comes with to extensa 32 bit LX six macroprocesses in one package. We have already shown you how the Arduino ID, by default can only run the code on core one. Meanwhile, core zero is idle.

Let us now look at how to leverage the concept of tasks in free Otto's to implement multitasking in ESP 32. To assign specific parts of code to a specific code, you need to create tasks. To make you understand the basics of multitasking. We will take a very simple example. We will create two tasks that independently Blinky LEDs with a different delay time. For that, we need to run each task on separate course.

Start by wiring to led us to the boat as shown in the following circular diagram. Here the red LED is controlled by pin 25 and green LED BY pin 26. Also, make sure you choose the appropriate current limiting resistor for the LEDs. Connect your sparkfun ESP 32 thing to your PC and open the Arduino IDE D and open the LED D will code.io sketch from the repository. As the ESP 32 Arduino core already has free Otto's inbuilt, you don't need to import any new libraries to work with free arctos. First, we have created two task handles named task one and task two using the free arctos keyword task handle underscore t this is just a pointer for the code to access the instructions.

Each task Next we have assigned the pin number of both the LED is to a variable of data type Constantine teacher inside board setup. As always, we enable the serial monitor and set the mode of the GPIO pins 25 and 26 as output. Next comes the fun part. The creation of tasks is always done in the setup loop. A task in ESP 32 is created by the free arctos function called x task create print to call. This function accepts seven parameters to configure the nature of the task.

They are appointed to the task, the name of the task, stack size, the task needs, the parameter of the task, the priority level of the task, the task handle, and finally, the core in which the task should run. Here you can see that we have created two tasks with the same priority level and stack size. The most important difference between the two tasks is the core to which it is pinned. The red LED blink task is pinned to core zero, and the green LED blink task is pinned to core one. This is essentially what allows a code to do multitasking in an ESP 32. Next, we have created function definitions for both the tasks.

During the creation of tasks itself, we have assigned a function name for the task, make sure you use the same function name here also, as both the tasks don't have any parameters, we have defined the functions with void parameter. Furthermore, the functions don't return any values does. The function itself is of type void. To implement an infinite loop, we have used a for loop with no control variable condition or iteration. Next we have used the export gate code function inside both the tasks. This is to use the serial monitor to see on which code the task is running.

In the case of the red LED, we have set it to blink every 1.4 seconds. In the case of green LED, the blink time is set to 0.7 seconds. As we can't remove the void loop from any Arduino sketch, we have lifted empty instead. Now upload the code to your sparkfun ESP 32 thing. You can see that the red and green LEDs are blinking totally independent from each other. If you check in the serial monitor, you can see that both cores are used at the same time.

Thus, you can use this kind of multitasking in applications where each code is doing something totally independent. But in most real life applications, there are cases where we need to synchronize different tasks especially when they are competing for the same resources. In such situations, we need to use send offers. More specifically, we have to use a mutually exclusive center for also known as mutex, semaphore. A mutex, semaphore can exist in only two states, that is a quiet state and release state. It is like a baton in a relay race, there is only one baton and the person owning it has to run.

In the end, the baton is passed to the next runner. Because of this mutex semaphores are often used to synchronize tasks. The synchronization can also be done without free arctos also. But the most important thing to notice that if we use a semaphore to implement synchronization, that is zero CPU load during the waiting period. In the case of normal sequential programming, even an empty loop will utilize CPU. This is one of The reasons why free Otto's is very necessary for IoT applications.

With less CPU utilization comes more battery life. If you want to know more about other sniffers and your application, please check out the resources section. Shall we now implement a mutex semaphore in our Arduino sketch to synchronize the tasks. Basically, the goal is to make the green LED blink task to wait until the red LED blink task has finished and given the semaphore back to the green LED blink task. Once the green LED blink task has finished, it must release the center soul and then the red LED blink task will continue on our ESP 32. There are three functions to deal with the mutex center for XML for create mutex XML forgive and XML for take open the LED sing blink dot INR code file from the repository in the Arduino IDE First, we create a semaphore handle, the name of this handle will be set for itself.

In the setup, we create a mutex semaphore by assigning the external flow create mutex function to the semaphore handle. Next, we will add two instructions to both the tasks. One is to take the Center for if it is available and the other is to give back the center full once the task is done. Center for is just like the baton in a relay race. The XML for take center for command port max underscore delay instruction will wait for infinite time for the mutex semaphore named semaphore to get free. Once the task is done, the XML for gave semaphore will release the semaphore So, that the next task can use it initially the semaphore will be free.

Thus the red LED blink task will take the semaphore and execute After execution, the semaphore is released. As soon as it gets released, the green LED blink task will take the semaphore and execute after execution, the semaphore is released and then the cycle continues. Thus, synchronization is successfully implemented between two tasks. Summary In this video we have covered the following topics, multitasking in the ESB 32 implementing tasks implementing semaphores In the next video, we will cover inter task communication in the sparkfun ESP 32 thing with free arctos