Video performance benchmarking with free Otto's implementation in the sparkfun ESP 32 thing. In this video, we will look at the performance comparison between an Arduino you know our three ESP a 266 and the ESP 32. Finally, we will also compare the performance increase in the ESP 32 with the implementation of free arctos multitasking and inter task communication. By now you would have experienced firsthand the capabilities of the sparkfun ESP 32 thing. It's no surprise that the ESP 32 is indeed faster than any of the other boards. We will be comparing.

But in this video, we will find out exactly how faster the ESP 32 is, especially with three Otto's implementation to use that extra code that is dominant. Most speed tests out there use only some artificial software load To compare the speed of execution, but I have cooked up a simple yet powerful template code that can put a strain on the code by using both software and hardware loads please download all the codes from the resources section or access it from the repository downloaded earlier. Now low the Arduino you know r three.io no code in Arduino Id let me explain the template code as it is reused for all other boats with slight tweaks here and there. In the code, we are first imported the math dot h library. So that we can work with the power function to find the power of value. The code will also have three functions.

The first function is the double underscore power function, which takes in a variable of data type unsigned integer. It then iterate from zero to that number and on each iteration and finds the square of the number. The function also keeps track of the time it took for execution with the Millis function and returns the value does this function adds a software load on the CPU. The second function is loop underscore GPIO. This function adds a hardware load on the CPU. The way we do it is by switching a GPIO pin on and off very fast for a specified number of times.

Just like the double underscore PL function, it takes in a variable of data type unsigned integer. It then iterate from zero to that number on each iteration, and it quickly said the GPIO pin 13 high and low. The function also keeps track of the time it took for execution with the Millis function and returns the value. The third function is the do underscore measure function. The purpose of this function is to set the input parameter count for both the previous functions and it The sum of the execution time for both the functions. Finally, it will convert the execution time from milliseconds to seconds and prints it on the serial monitor.

Inside the do underscore measure function, you can see that we have used a plus equal operator for these two lines of codes. This is done when we need to do a cumulative sum of two independent variables as shown here. If you go through the code, you can see that you enter 32 underscore T is used a lot. This is a data type called as an unsigned integer. It can hold only whole numbers, but no negatives. The number after the unit refers to the number of bits the data type uses.

Thus 32 bits can hold numbers from zero to two raised to 32. In the word setup, we begin the serial monitor with the baud rate of 9600. As we are using the Arduino you know r three in the void loop, we have called the do underscore measure function, which will initiate the speed test on Arduino you know r three. After uploading the code to our Arduino you know r three, I have opened the serial monitor and set the baud rate to 9600. After waiting for some time, I've got the result of the speed test. The combined software and hardware load took around 7.1 seconds to compete on an Arduino.

Next, open the ESP a 266 dot IO no code in Arduino ID. The code is almost the same as the Arduino you know our three code. The only difference is that we have set the baud rate of the serial monitor to 115200 and change this text to ESP a to six. Now after connecting my node MCU ESP eight to six, six Upload the code and enable the serial monitor with the correct baud rate. After waiting for some time, I've got the results of the speed test. The combined software and hardware load took around 2.4 seconds to complete on a node MCU ESP 8266.

Next, open the ESP 32 underscore single underscore core.io. No code in Arduino ID. The code is almost the same as the ESP a 266 dot i n o code. The only difference is that we have added an instruction to check on which code the code is running. Now, after connecting my sparkfun ESP 32 thing, I uploaded the code and enabled the serial monitor with the correct baud rate. The combined software and hardware load took around just 0.4 seconds to complete.

Furthermore, it was achieved with just a single core that is The core one. Now let's unlock the true potential of the ESP 32. By using free arctos, multitasking and inter task communication, we will run the same load on both the cores at the same time. And we will use free Otto's tasks and queues to implement a very reliable system. Open the ESP 32 underscore D will underscore core.io no code in the Arduino ID, I will explain the changes to the base code. We have first added three macro definitions.

These instructions save the pin numbers for the GPIO switching test for each core. This instruction keeps the size of each message in the queue that will be created later. The next instruction creates a handle for accessing the queue that will be created later. The double underscore POW and loop underscore GPIO functions are the same as the previous code before going to the do underscore measure function, let's take a look at the void setup loop. Here we have set the pin modes of both the GPIO pins 13 and 14 as output. Then we have created a queue with length 10 the size in bytes which each item in the queue should hold is based on the data tab and the macro we defined earlier.

Next, you can see that we have created three tasks. The first task called my core zero task is pinned to the core of zero and the second task called my core one task is pinned to code one. When you check the function definition for both these tasks, you will realize that both are calling the same do underscore measure function. So essentially, what this code both the cores are running the same speed test parallely the third time called Microsoft task is pinned to the core one, and its function is to collect the results from the queue and print it on the serial monitor. Now let's discuss about the modified do underscore measure function. To understand the updated do underscore measure function, you need to first understand the need for a queue in the speed test.

Ultimately, we want the time of execution for each core printed independently on the serial monitor. But let's say both the Miko one task and Miko two task send the result at the same time. This will lead to a collision and only one result will be retrievable. To avoid this, we created a queue in which whenever a result is produced by either of the tasks, it will get stored in the queue, so that even if the main result task is busy, the result won't be lost. Inside the do underscore measure function We will store the core ID of the currently running task to the zero index of the message array. Now, based on the core ID, we will save the time of execution of the loop underscore GPIO function starting from the index position one, then we will implement a cumulative addition with the data present in the index position 10.

This position has the time of execution of the double underscore path function. Next, the total time of execution is stored in index position level of the message array. Finally, this free autos function will load the message array to the queue created earlier. The main result task will access the message array from the queue and extract the core ID and execution time and display it on the serial monitor. This is the full implementation of multitasking and inter task communication in the speed test code. Now let's see what are the results after uploading the combined software in hardware load took around just 0.2 seconds to complete for a single core.

Remember that both cores are running the same load parallely. Still, it managed to do it two times faster on each core. To give a context of the upgrade in processing power, it will need two instances of the same code running parallel on both cores to reach the execution time versus of the last test on the ESP 32. This means that in effect per core performance has increased twice and combined core performance has quadrupled. The per core performance bump was due to the implementation of cues, cue implementation remote the need to override previous results. Thus making the access speed of data much faster.

The Combined core performance bump was obviously due to the implementation of multitasking using tasks. Summary. In this video we have covered the following topics performance comparison between Arduino you know our three node MCU, ESP 8066 and sparkfun ESP 32 performance comparison with and without free Otto's implementation on the sparkfun ESP 32 thing. Section summary in the section we have covered the following topics, what is the real time operating system free Otto's implementation in the ESP 32 What are tasks queues and semaphores implementing dual core multitasking and synchronization in the sparkfun ESP 32 thing. inter task communication in the sparkfun ESP 32 thing with free arctos performance benchmarking with Free Otto's implementation in the sparkfun ESP 32 thing. In the next section, we will learn about deep sleep in the ESP 32