#esp32 tutorial

In this esp32 tutorial, we will check how to use variable length arrays on the Arduino core running on the ESP32. The tests of this tutorial were performed using a DFRobot’s ESP-WROOM-32 device integrated in a ESP32 development board.

Introduction

In this esp32 tutorial, we will check how to use variable length arrays on the Arduino core running on the ESP32.

Variable length arrays are arrays that can be declared with a length that is not a constant expression [1]. Thus, this gives more flexibility to declare arrays when we don’t know their length at compile time.

One very important thing to take in consideration is that these arrays are allocated in the stack memory[2]. This means that we don’t need to worry about explicit memory allocation and de-allocation, even though the length of these arrays is not determined at compile time.Naturally, this is an advantage in comparison to dynamic allocation of memory on the heap using, for example, the malloc function, which is commonly used when we don’t know the length of the array at compile time.

Furthermore, that kind of dynamic allocation in the heap in embedded systems should be avoided if possible (you can read a very interesting article about this here). So, the variable length arrays can be used as alternative.

Note however that variable length arrays also have some particularities that need to be carefully taken in consideration. One problem that they present is that they give no mechanism for checking if the stack size available was exceeded [3], meaning that we don’t have any way of handling that failure in our code.

Thus, we need to be careful using this feature and make sure that the dynamic value we will use for the array length doesn’t exceed the available stack.

Note that this is a feature of the C language and thus it is not specific from the ESP32 or even the Arduino environment. So, you should be able to use this feature in other microcontrollers. Variable length arrays were introduced in the C99 standard.

The tests of this ESP32 tutorial were performed using a DFRobot’s ESP-WROOM-32 device integrated in a ESP32 FireBeetle board.

The code

In our code, we will compare the use of a variable length array versus the dynamic allocation of an array on the heap, using a malloc call.

For both cases, we will check the effect on the available heap memory. You can check here a detailed tutorial on how to get the available heap on the ESP32.

We will write all our code in the setup function. We will start by opening a serial connection to output the results of our program.

Serial.begin(115200);

Then, we will declare an integer variable called arrayLength that will store the dynamically generated length for the array.

In order for us to confirm that we can really use a value not known at compile time and that this feature is not only some compiler functionality that gets the value of the expression for the array length, we will use a random value for it. You can check here a tutorial on how to generate random numbers on the ESP32.

So, we will generate a random number between 98 and 100 for the length of our array. Note that, as mentioned in the introductory section, we need to be careful with the maximum length of the array to avoid exceeding the stack available size.

You can change this randomly assigned value to a big number to see the stack exceeding message generated by the core.

int arrayLength = random(98,100);

Now we will print the current size of the heap, so we can track if some change will occur from our declarations.

We get the free heap of the ESP32 by calling the getFreeHeap method on the ESP variable, which is available by default in our code without the need for includes. This method will return the free heap in bytes.

Serial.print("Heap before variable size array: "); Serial.println(ESP.getFreeHeap());

After this we will declare our variable length array, using the variable that stored the number randomly generated.

int stackArray[arrayLength];

After this, we will print the free heap again in order to later confirm that the array was not allocated there.

Serial.print("Heap after variable size array: "); Serial.println(ESP.getFreeHeap());

Now we will repeat the same approach but for an array allocated in the heap, using the malloc function. This function receives as input the size of the memory block we want to allocate, in bytes [4].

In our case, we want an array with the length defined in the arrayLength variable. Thus, we will multiply that value by the number of bytes a int occupies. We can get the number of bytes of an int using the sizeof operator.

We also need to make a cast to a pointer to int, since the malloc function returns a generic pointer to void [4] and the cast needs to be explicit..

Serial.print("Heap before malloc: "); Serial.println(ESP.getFreeHeap()); int * heapArray =(int *) malloc(arrayLength*sizeof(int)); Serial.print("Heap after malloc: "); Serial.println(ESP.getFreeHeap());

All the code we need for our validation is already written. Nonetheless, we will need to use these declared arrays to do something or they will be removed due to compiler optimizations, which means that the calls to get the free heap would return the same value even though we are allocating memory with the malloc.

Thus, we will finalize our code by iterating both arrays to initialize their values and print them to the serial port. The final full code can be seen below and already includes this additional part.

void setup() {  Serial.begin(115200);  int arrayLength = random(98,100);  Serial.print("Heap before variable size array: ");  Serial.println(ESP.getFreeHeap());  int stackArray[arrayLength];  Serial.print("Heap after variable size array: ");  Serial.println(ESP.getFreeHeap());  Serial.print("Heap before malloc: ");  Serial.println(ESP.getFreeHeap());  int * heapArray =(int *) malloc(arrayLength*sizeof(int));  Serial.print("Heap after malloc: ");  Serial.println(ESP.getFreeHeap());  for(int i= 0; i<arrayLength; i++){    heapArray[i] = i;    stackArray[i]=i;    Serial.print(heapArray[i]);    Serial.print(stackArray[i]);  } } void loop() {}

Testing the code

To test the code, simply compile it and upload it to your ESP32 using the Arduino IDE. Then, open the serial monitor.You should get an output similar to the one illustrated in figure 1.

Figure 1 – Output of the comparison program.

As we can see, the variable length array declaration had no impact on the available heap, meaning it was indeed allocated on the stack, as expected. On the other hand, after using the malloc, the heap available decreased.

For curiosity, figure 2 shows the result of running the same code but without the final loop. As can be seen, the size of the heap always stays the same, which means that the malloc call had no effect. Most likely, the compiler ignored those instructions since the variables wouldn’t be used.

Figure 2 – Running the program without the final loop.

The objective of this post is to explain how to obtain the IP of a client that contacts a HTTP web server running on the ESP32, on the Arduino core. The tests of this ESP32 tutorial were performed using a DFRobot’s ESP-WROOM-32 device integrated in a ESP32 FireBeetle board.

Introduction

The objective of this post is to explain how to obtain the IP of a client that contacts a HTTP web server running on the ESP32, on the Arduino core.

We will use the HTTP async web server libraries we have been covering in the past tutorials. So, much of the code will be similar to what we have been covering and thus we will focus on the route handling function where we will analyze how to get the IP of the clients that contact the server.

If you have not been following the previous tutorials, you can check the “Related Posts” section at the end of this article, which lists all the previous tutorials.

The tests of this ESP32 tutorial were performed using a DFRobot’s ESP-WROOM-32 device integrated in a ESP32 FireBeetle board.

The code

As usual, we start by doing the library includes and global variables declaration that we will need to connect to the WiFi network and to configure the HTTP async web server.

#include <WiFi.h> #include <FS.h> #include <AsyncTCP.h> #include <ESPAsyncWebServer.h> const char* ssid = "yourNetworkName"; const char* password = "yourNetworkPassword"; AsyncWebServer server(80);

Next, on the Arduino setup function, we connect the ESP32 to the WiFi network and print its local IP after the connection is established, so we know the address to use for contacting it.

We are printing a couple of newlines after so we separate the local IP of the ESP32 from the IP of the clients that will contact it, that we will also print next.

Serial.begin(115200); WiFi.begin(ssid, password); while (WiFi.status() != WL_CONNECTED) {    delay(1000);    Serial.println("Connecting to WiFi.."); } Serial.print("Server IP: "); Serial.println(WiFi.localIP()); Serial.println("\n\n");

Now that we have handled the WiFi connection, we need to configure the routes of the server. As we have been doing in the past tutorials, we simply need to call the on method on the server object, passing as input the route, the HTTP method(s) allowed on that route and the handling function.

For this example, we will call our route “/getIp” and listen to HTTP GET requests. Note however that we should be able to print the IP of the client using this approach independently of the HTTP method that our route is listening to.

server.on("/printIp", HTTP_GET, [](AsyncWebServerRequest *request){ // Route handling function code });

Now we are going to focus on the AsyncWebServerRequest object pointer that is accessible inside the handling function.

As we have been seen through these tutorials, our web server works asynchronously. We also know that HTTP works on top of TCP sockets, so under the hood the async HTTP web server library is using this mechanism for the lower level communication.

Thus, the web server API allows us to access the lower level client object which is used to exchange the data with the client.

This is an object of class AsyncClient (header file here), which is implemented in the AsyncTCP library. As we have seen in the HTTP web server introductory tutorial, this ESP32 async TCP library is one of the dependencies for the HTTP async web server library. Also, this is one of the libraries that we include on the beginning of our programs.

Thus, in order to obtain the mentioned object, we can call the client method on our request object pointer.

This method takes no arguments and returns a pointer to an object of class AsyncClient. We can then use this new object pointer to call the remoteIP method, which also takes no arguments and returns the client IP.

You can check below the mentioned method calls. Note that we first return the answer of the HTTP request to the client and only then take care of getting the IP and printing it to the serial console. That way, we won’t leave the client hanging, waiting for an answer.

server.on("/printIp", HTTP_GET, [](AsyncWebServerRequest *request){    request->send(200, "text/plain", "ok");    Serial.print("Received request from client with IP: ");    Serial.println(request->client()->remoteIP()); });

To finalize our code we still need to call the begin method on the server object so it begins listening to incoming HTTP requests. You can check the full source code below.

#include <WiFi.h> #include <FS.h> #include <AsyncTCP.h> #include <ESPAsyncWebServer.h> const char* ssid = "yourNetworkName"; const char* password =  "yourNetworkPassword"; AsyncWebServer server(80); void setup(){  Serial.begin(115200);  WiFi.begin(ssid, password);  while (WiFi.status() != WL_CONNECTED) {    delay(1000);    Serial.println("Connecting to WiFi..");  }  Serial.print("Server IP: ");  Serial.println(WiFi.localIP());  Serial.println("\n\n");  server.on("/printIp", HTTP_GET, [](AsyncWebServerRequest *request){    request->send(200, "text/plain", "ok");    Serial.print("Received request from client with IP: ");    Serial.println(request->client()->remoteIP());  });  server.begin(); } void loop(){}

Testing the code

To test the code we need to follow the usual procedure. First, we compile and upload the code to the ESP32 using the Arduino IDE.

When the procedure finishes, open the serial monitor and copy the IP that gets printed. Then, open a web browser of your choice, and type the following in the address bar, changing #yourDeviceIp# by the IP you have just copied.

http://#yourDeviceIp#/printIp

In your web browser, you should get the “ok” answer we defined in the code. If you go back to the serial monitor, then a message similar to the one shown in figure 1 should get printed, containing the local IP of the computer that you have used to contact the ESP32.

Figure 1 – IP of the clients getting printed. In my case, I’ve tested making the request from two different computers and, as shown in the figure, I got two different IPs. I’ve also included in the figure a snippet of the local IP of the first PC, which matches the one printed in the console.

If you are on Windows, you can get your computer IP by opening a command line window and using the ipconfig command. On Linux, you need to use the ifconfig command.

In this tutorial, we are going to check how to use AES-128 in ECB mode, using the Arduino core running on the ESP32 and the mbed TLS library. The tests were performed using a DFRobot’s ESP32 module device integrated in a ESP32 development board.

Introduction

In this tutorial, we are going to check how to use AES-128 in ECB mode, using the Arduino core running on the ESP32 and the mbed TLS library.

The mbed TLS library is already available by default on the Arduino core, so there is no need to install additional software.

If you need a more conceptual introduction about AES and the ECB mode, please consult the introduction section of this previous, which includes a brief explanation about it.

As mentioned there, ECB (Electronic Code Book) mode is not recommended due to the fact that it exposes patterns in the encrypted message. Thus, we are just using it for demonstration purposes.

The tests were performed using a DFRobot’s ESP32 module device integrated in a ESP32 development board.

The code

The first thing we need to do is including the aes.h file from the mbed TLS library, which exposes the set of functionalities needed to use the AES encryption algorithm.

#include "mbedtls/aes.h"

We will write the remaining code on the Arduino setup function, since we are only going to perform the encryption of a testing string. The first thing we need to do is opening a serial connection, to later output the results of our program.

Serial.begin(115200);

Then we need to create a variable variable of struct type mbedtls_aes_context, which will be used in the next functions calls. This variable will hold the algorithm context.

mbedtls_aes_context aes;

Now we need to define a key for the encryption. Since we are using AES-128, the key needs to have a length of 128 bits (16 bytes). I will be using an arbitrary key for demonstration purposes that is not secure at all. You can check here a guide on how to generate a proper AES key with mbed TLS.

char * key = "abcdefghijklmnop";

Then we need to define the plain text data to be encrypted. Remember from the previous post that AES operates on 16 bytes data blocks. Nonetheless, the ECB encryption function from mbed TLS supports only a single block of data [1], so we need to specify a plain text string with just 16 bytes.

char *input = "Tech tutorials x";

Additionally, we need a 16 bytes buffer to store the output data. Since it will be a simple byte buffer, we declare it as unsigned char.

unsigned char output[16];

Now we will start to call the functions needed to encrypt the data. The first thing we need to do is initializing the AES context we have just created, before using it in another function calls [2]. We do it by calling the mbedtls_aes_init function, which receives a pointer to the context.

mbedtls_aes_init( &aes );

After initializing the context, we need to set the encryption key, which will be used to cipher the plaint text data. We do it by calling the mbedtls_aes_setkey_enc function.

As first input, it receives a pointer to the AES context we have just initialized, as second the encryption key we have just declared and as third and final parameter it receives the size of the key used, in bits [3].

This function call receives the key as constant, so we need to make a cast when passing our previously defined key.

In our case, we are using AES-128, so we need to pass the value 128 to the key length. Naturally, this value should be coherent with the actual size of our key string, which has indeed 128 bits (16 bytes).

Since each char has a size of 1 byte, we can pass the key length in a more dynamic format by getting the string length (which is equal to the number of bytes) and multiplying by the number of bits in a byte (8).

mbedtls_aes_setkey_enc( &aes, (const unsigned char*) key, strlen(key) * 8 );

To do the actual encryption in ECB mode, we need to call the

mbedtls_aes_crypt_ecb function.

This function receives as first input a pointer to the AES context, as second the operation mode (encryption or decryption), as third the 16 bytes length input data and as fourth a 16 bit length output buffer.

Since we want to encrypt data, we pass the constant MBEDTLS_AES_ENCRYPT as second argument of the function call.

As third argument we pass our previously defined input data, making the cast to constant like we did before when setting the key. As fourth argument, we pass the buffer we declared to hold the output data.

mbedtls_aes_crypt_ecb(&aes, MBEDTLS_AES_ENCRYPT, (const unsigned char*)input, output);

To finalize the mbed TLS function calls, we need to free the AES context we have used with a call to the mbedtls_aes_free function, which also receives as input a pointer to the context.

mbedtls_aes_free( &aes );

Now that we have obtained the bytes of the encrypted data, we will iterate them and print them in a user friendly format, namely in hexadecimal. We will do that by using the sprintf function to format each of the bytes in a two characters length hexadecimal string.

We will need to use the %02x format specifier on the sprintf function to indicate we want to print each byte as a hexadecimal string with two characters, padded with a leading zero if needed. You can read more about format specifiers

here.

The final source code can be seen below and already includes these prints.

#include "mbedtls/aes.h" void setup() {  Serial.begin(115200);  mbedtls_aes_context aes;  char * key = "abcdefghijklmnop";  char *input = "Tech tutorials x";  unsigned char output[16];  mbedtls_aes_init( &aes );  mbedtls_aes_setkey_enc( &aes, (const unsigned char*) key, strlen(key) * 8 );  mbedtls_aes_crypt_ecb(&aes, MBEDTLS_AES_ENCRYPT, (const unsigned char*)input, output);  mbedtls_aes_free( &aes );  for (int i = 0; i < 16; i++) {    char str[3];    sprintf(str, "%02x", (int)output[i]);    Serial.print(str);  } } void loop() {}

Testing the code

In order to test the code developed on this ESP32 tutorial, simply compile it and upload it to your device using the Arduino IDE.When it finishes, open the serial monitor. You should get an output similar to figure 1, which shows the encrypted data in hexadecimal format.

Figure 1 – Output of the program.

At the time of writing I hadn’t found a suitable online tool to test the encryption and compare it against the results obtained on the ESP32, so we can test it using the Python program introduced in the previous post.

As can be seen in figure 2, if we encrypt the same data with the same key in ECB mode, we get the same result as in the ESP32.

Figure 2– Comparison of the ESP32 result with the encryption on a Python program, using the pycrypto library.

You can check the full Python testing code below. Please consider that, as explained in detail in the previous post, to use the Python code below we first need to install pycrypto. The mentioned post contains an explanation on how to do it.

from Crypto.Cipher import AES key = 'abcdefghijklmnop' cipher = AES.new(key, AES.MODE_ECB) msg =cipher.encrypt('Tech tutorials x') print(msg.encode("hex")) print(msg.encode("hex") == "567a3b23b683d8488d5d40d2a56e31d2")

The objective of this ESP32 / ESP8266 Arduino Tutorial is to explain how to use an initializer list to initialize data members of a class. The tests on the ESP32 were performed using a DFRobot’s ESP32 module device integrated in a ESP32 development board. The tests on the ESP8266 were performed on a DFRobot’s

ESP8266 development board.

Introduction

The objective of this post is to explain how to use an initializer list to initialize data members of a class.

Note that even tough we are testing the code on the Arduino core running on the ESP32 and the ESP8266, initializer lists are a C++ concept that can be used not only for other microcontrollers supported on the Arduino environment but also in C++ programs.

The member initializer list is specified after the arguments of the constructor. It begins with a colon followed by the name of each variable to initialize, separated by commas [1]. The value to assign to each data member is specified between parenthesis after the name of each data member of the list.

Other important thing to mention is that we can use the arguments of the constructor in the initializer list, to initialize the data members.

After the initializer list specification we then declare the body of the constructor inside brackets. If we initialize all the data members in the initializer list and don’t have any additional logic for the constructor, we simply leave the brackets empty.

In this article, we will use the initializer list to initialize the members of a class, in alternative to the intialization we have performed in the body of the constructor, in this previous post.

You can read here a very interesting article which explains some use cases when we should use an initializer list.

The tests on the ESP32 were performed using a DFRobot’s ESP32 module device integrated in a ESP32 development board. The tests on the ESP8266 were performed on a DFRobot’s ESP8266 FireBeetle board.

The code

As usual, we will start by declaring our class at the top of our code. It will have two public data members that we will later initialize using the initializer list.

class TestClass{  public:    int x;    int y; };

Next we will have a constructor that receives two inputs, to initialize each data member. Besides that, it will have the initializer list, where we will use the first argument of the constructor to initialize the first data member of the class and the second argument to initialize the second data member.

We will declare an empty body for the constructor since we already initialized all the data members.

class TestClass{  public:    int x;    int y;    TestClass(int arg1, int arg2): x(arg1), y(arg2)    {    } };

Moving to the Arduino setup function, we will first open a serial connection, for printing the results of our program.

Serial.begin(115200);

Next we will create an object of our class, passing as input of the constructor the values we want for initializing the data members. The notation we use is the same as the previous post, even tough we have used an initializer list.

TestClass myObject(40, 30);

Finally, we will simply access and print the values of the data members to the serial port, to confirm they were correctly assigned. Remember that since the data members are public, we can access them using the dot operator.

The final code for this tutorial can be seen below and already includes these prints.

class TestClass{  public:    int x;    int y;    TestClass(int arg1, int arg2): x(arg1), y(arg2)    {    } }; void setup() {  Serial.begin(115200);  TestClass myObject(40, 30);  Serial.print("Data member x:");  Serial.println(myObject.x);  Serial.print("Data member y:");  Serial.println(myObject.y); } void loop() {}

Testing the code

To test the code, simply compile it and upload it using the Arduino IDE. Next, open the serial monitor and check the printed results. You should get an output similar to figure 1, which shows the value of the data members of the class getting printed.

Figure 1- Output of the program.

In this ESP32 tutorial we will check how to use structs as items in FreeRTOS queues. This will allow us to store more complex messages in queues, facilitating the process of inter-task communication. The tests were performed using a DFRobot’s ESP32 module device integrated in a ESP32 development board.

Introduction

In this ESP32 tutorial we will check how to use structs as items in FreeRTOS queues. This will allow us to store more complex messages in queues, facilitating the process of inter- task communication.

You can check a more detailed introduction about FreeRTOS queues on this previous tutorial.

In our program, we will focus on the process of inserting and consuming items from the queue. Thus, we will create a simple data struct, create some variables of that data type, insert them in the queue and then consume them.

Our data struct will represent an IoT sensor measurement. In a real application use case, we could have, for example, one task (or multiple) obtaining measurements from different devices and then sending them to a dispatcher task that would send the measurements to the cloud. The communication mechanism used between the tasks could then be a queue, where each item would represent a measurement’s information.

Naturally this is one of that many possible use cases and you should adapt the data structure to the needs of your application’s architecture.

The tests were performed using a DFRobot’s ESP32 module device integrated in a ESP32 development board.

The code

The first thing we are going to do is declaring our struct. As mentioned, we will create a testing struct that represents an IoT sensor measurement, just for demonstration purposes. For a more detailed tutorial about using structs on the Arduino environment, please consult this blog post.

Our struct will be equal to the one presented on the mentioned tutorial and will have three fields: a device ID, a measurement type and a measurement value. The first two members will be of type int and the third will be of type float.

struct sensor {  int deviceId;  int measurementType;  float value; };

Now that we have finished our struct declaration, we will declare a global variable of type QueueHandle_t. This type is used to reference a FreeRTOS queue, which we will create later.

QueueHandle_t queue;

Moving on to the Arduino setup function, we will open a serial connection, in order to output the results of our program and obtain them on the Arduino IDE serial monitor when testing the code.

Serial.begin(115200);

After this, we will create the FreeRTOS queue. To do it, we simply need to call the xQueueCreate function. This function receives as first input the maximum number of items that the queue can hold and as second input the size, in bytes, of an element of the queue [1]. All the elements of the queue should have the same size.

For the first argument, we will pass the value 10, which means that the queue can hold, at most, 10 items at a single time. You can test with other value if you want.

The size of each item will be equal to the size of the structure we have previously declared. To get its value, in bytes, we can use the sizeof function.

If the queue is successfully created, the xQueueCreate returns an handle for the queue, which is of type QueueHandle_t. This type corresponds to the type of the global variable we declared at the beginning of the program and so we will assign result of the function to that variable.

queue = xQueueCreate( 10, sizeof( struct sensor ) );

In case the memory for the queue couldn’t be allocated, then the function returns NULL instead of a queue handle [1]. Thus, we will do an error checking a print a message in case the queue was not created.

if(queue == NULL){    Serial.println("Error creating the queue"); }

Moving on to the Arduino loop function, we will start to insert items on the queue. We will do this in a loop with 10 iterations, which corresponds to the size of the queue.

for(int i = 0; i<10; i++){    //Queue insertion code }

In each iteration, we will create a variable with the type of our struct and assign values to its fields. We will assign the current iteration value to the deviceId field, so it varies for each message.We will assign some arbitrary fixed values to the other fields.

struct sensor mySensor; mySensor.deviceId = i; mySensor.measurementType = 1; mySensor.value = 20.4;

To insert the item in the queue, we need to call the xQueueSend function, which will insert it at the end of the queue [2].

As first argument, the function receives the queue handle we previously obtained. As second argument, it receives a pointer to the item we want to insert. Note that even tough we are passing a pointer to the item, it will actually be copied into the queue [2], not just referenced.

In our case, it means that the whole struct will be copied into the queue. For larger data structures, it may be a better option to use the queue to store references to those structures, but that is a more advanced use case that we will not cover here.

The last argument corresponds to the maximum amount of time the task should block waiting for space to become available on the queue, in case it is full, to be able to insert the item [2].

We will pass it the value portMAX_DELAY, which means that the task should wait indefinitely in case the queue is full. Nonetheless, we will design or program flow in such a way that ensures this never happen.

for(int i = 0; i<10; i++){    struct sensor mySensor;    mySensor.deviceId = i;    mySensor.measurementType = 1;    mySensor.value = 20.4;    xQueueSend(queue, &mySensor, portMAX_DELAY); }

Now that we have an insertion loop, we will also design a similar consumption loop, to get the inserted items and print their values to the serial port.

Before the loop, we will declare another variable with the type of our struct, which we will use as buffer to receive the item from the queue. Since we will get each item and print its value right away in the same iteration, we can reuse this variable to get all the items of the queue.

struct sensor element;

Then, inside another loop with 10 iterations, we will get each item with a call to the xQueueReceive function.

As first argument, the function receives the queue handle which we have stored on the global variable. As second argument, it receives a pointer to the buffer into which the item will be copied, which we declared before the loop. As third argument, it receives the maximum amount of time the task should block waiting for an item, in case the queue is empty [3]. Again, we will pass the portMAX_DELAY value, taking into account that the task will never block because we will never call the function when the queue is empty.

After receiving the item, which will be of our struct type, we will print the value of each  of its members to confirm they match the values of the previously inserted items.

for(int i = 0; i<10; i++){    xQueueReceive(queue, &element, portMAX_DELAY);    Serial.print("Device ID: ");    Serial.println(element.deviceId);    Serial.print("Measurement type: ");    Serial.println(element.measurementType);    Serial.print("Value: ");    Serial.println(element.value);    Serial.println("----------------"); }

At the end, we will do a small four seconds delay between each iteration of the loop. The final source code can be seen below. It already includes this delay and, at the start of the Arduino loop, an error checking in case the queue was not successfully created.

struct sensor {  int deviceId;  int measurementType;  float value; }; QueueHandle_t queue; void setup() {  Serial.begin(115200);  queue = xQueueCreate( 10, sizeof( struct sensor ) );  if(queue == NULL){    Serial.println("Error creating the queue");  } } void loop() {  if(queue == NULL){    Serial.println("Queue was not created");    return;  }  for(int i = 0; i<10; i++){    struct sensor mySensor;    mySensor.deviceId = i;    mySensor.measurementType = 1;    mySensor.value = 20.4;    xQueueSend(queue, &mySensor, portMAX_DELAY);  }  struct sensor element;  for(int i = 0; i<10; i++){    xQueueReceive(queue, &element, portMAX_DELAY);    Serial.print("Device ID: ");    Serial.println(element.deviceId);    Serial.print("Measurement type: ");    Serial.println(element.measurementType);    Serial.print("Value: ");    Serial.println(element.value);    Serial.println("----------------");  }  Serial.println();  delay(4000); }

Testing the code

To test the code, simply compile it and upload it to your ESP32 using the Arduino IDE. When it finishes, open the serial monitor and check the result. You should get an output similar to figure 1, which shows the values of the items obtained from the queue.

As expected, the items obtained are equal to the ones originally inserted on the queue. The device ID is incremented in each item and the remaining values are equal.

Figure 1 – Output of the program.

In this ESP32 tutorial, we will check how to get temperature measurements on the Arduino core running on the ESP32, using a DHT22 temperature and humidity sensor. The tests were performed using a DFRobot’s ESP32 module integrated in a ESP32 development board. Introduction

In this ESP32 tutorial, we will check how to get temperature measurements on the Arduino core running on the ESP32, using a DHT22 temperature and humidity sensor.

Note that DHT22 is the common name given to the device but its real name is AM2302 [1]. You can consult the datasheet here.

The interface with the DHT22 is quite simple since it uses a single wire protocol [2], meaning we just need to connect it to a single GPIO of our microcontroller.

It works with a supply voltage in the range of 3.3 V to 5.5 V [2], so it can be easily used with the ESP32.

In order to interact with the sensor using a higher level API that abstracts the lower level details of the one-wire communication, we will use this Arduino library.

To facilitate the interaction with the sensor, I’m using a DFRobot DHT22 module which already has all the electronics needed and exposes a wiring terminal that facilitates the connections. The tests were performed using a DFRobot’s ESP32 module integrated in a ESP32 development board.

Installing the library

The easiest way to install the library is via the Arduino IDE library manager. To open it, go to Sketch -> Include library -> Manage libraries and the library manager should appear.

There, type “DHT22” on the search bar and install the one named “DHT sensor library for ESPx“, as highlighted in figure 1.

Figure 1 – Installing the DHT22 library for the ESP32.

The electric diagram

As mentioned, there’s only the need for a single pin of the microcontroller to be connected to the DHT22, so the schematic diagram for the connection of the ESP32 to the sensor is very simple, as can be seen in figure 2.

Figure 2– Electric diagram to connect the ESP32 and the DHT22.

Depending on your sensor module, the data pin may be labeled differently, so it is represented in the previous schematic with the generic name “data”. Others may not even be labeled such as the module I’m using, where the pins can be distinguished by the colors of the wires:

Black: GND

Red: VCC

Green: Data

Please check carefully the pins and labeling of your DHT22 module to avoid damaging it when connecting it to the ESP32.

Depending on your ESP32 board, it may have a 3.3 V output pin that is able to be used as power supply for the DHT22. Nonetheless, if you are not sure if the pin exists or what is the maximum current it can supply, the best option is to use an external power supply such as this. In that case, don’t forget to have a common GND connection between the ESP32 and the DHT22.

The code

The first think we need to do is including our newly installed DHT library, so we can have access to the functionalities needed to get temperature measurements.

#include "DHTesp.h"

Then we need to declare an object of class DHTesp, which will expose the methods we need to obtain the temperature. We will declare it globally so we can later access it both in the Arduino setup and the loop functions.

DHTesp dht;

Moving on to the Arduino setup, we start by opening a Serial connection, to later output the temperature measurements we will obtain from the DHT sensor.

Serial.begin(115200);

To finalize the Arduino setup function, we need to initialize the sensor interface and to specify the pin where it is connected. We do this by calling the setup method on our previously declared DHTesp object.

As input, it receives the number of the microcontroller pin where the sensor is connected [3]. I will be using GPIO 27, but you can try with others.

Note that this function call has an additional optional argument for specifying the sensor module we are using, since the library is compatible with sensors other than the DHT22 [3]. This value is passed as an enumerated value.

In case we don’t specify any argument for this parameter, then it will default to the enum value AUTO_DETECT [3], which means it will try to detect automatically the sensor type.

We will then take advantage of this feature and not pass any additional parameter, so the library tries do detect the sensor type automatically.

dht.setup(27);

Moving on to the main loop function, we will periodically get the current temperature by calling the getTemperature method on our previously initialized DHTesp object.

This function takes no arguments and returns the temperature in degree Centigrade, as a float [3].

float temperature = dht.getTemperature();

Then we will print the obtained value to the serial interface.

Serial.print("Temperature: "); Serial.println(temperature);

To finalize, we will do a small 10 seconds delay before we get another temperature measurement.

delay(10000);

The final source code can be seen below.

#include "DHTesp.h" DHTesp dht; void setup() {  Serial.begin(115200);  dht.setup(27); } void loop() {  float temperature = dht.getTemperature();  Serial.print("Temperature: ");  Serial.println(temperature);  delay(10000); }

Testing the code

To test the code, simply compile it and upload it to your ESP32 device using the Arduino IDE. When the whole procedure finishes, open the serial monitor and check the result.

You should get an output similar to figure 3, which shows multiple temperature measurements getting printed.

Figure 3– Temperature measurements obtained from the DHT22 with the ESP32.

In this esp32 tutorial, we will check how to use the ESP32 to request weather data from an API for a given city, using the Arduino core. The tests of this ESP32 tutorial were performed using a DFRobot’s ESP32 module device integrated in a ESP32 development board. Introduction

In this tutorial, we will check how to use the ESP32 to request weather data from an API for a given city, using the Arduino core.

We are going to use the OpenWeatherMap, which has a very simple to use API that allows us to retrieve weather information.

Note that, in order to use the API, we will need to register in the website to get an API key, which we will use in our requests. This service offers multiple subscription options to access the API, being one of them free, which is the one used in this tutorial.

Note that the free service allows to use less services from the API and has a lower number of API calls per minute. Nonetheless, it is enough for the tests we are going to perform in this tutorial.

The tests of this ESP32 tutorial were performed using a DFRobot’s ESP32 module device integrated in a ESP32 development board. Getting the API key

As mentioned, we will need an API key to be able to use OpenWeatherMap’s API. The API key is one of the parameters we need to pass in the query string of our HTTP requests.

So, the first thing you need to do is registering on the website. After that, you should be redirected to the user area. There, you should click the “API Keys” tab, where you can retrieve your key, in the area highlighted in figure 1.

Figure 1– Getting the API key.

You can generate more API keys for your account by supplying a name and clicking the “Generate” button. Nonetheless the default one works fine and you can use it for this tutorial.

Note however that the activation of the API key takes 10 minutes, so you will not be able to perform requests before that.Once the activation time ends, you can do a quick test to check if you can reach the API with your key. To do it, simply access the following URL on your browser, changing {yourAPIkey} by the key you have obtained:

http://api.openweathermap.org/data/2.5/weather?q=Lisbon,pt&APPID=yourAPIkey

You should get an output similar to figure 2, which is basically a JSON with the weather information for the requested city (Lisbon for this test).

Figure 2– OpenWeatherMap API answer.

The API method format

As mentioned in the introductory section, we will request the current weather information for a given location, more specifically, for a city. To do it, we will use

this API method.

Note that this method supports many formats and options, but we will use one of the simplest. The base endpoint will be:

api.openweathermap.org/data/2.5/weather

In order to ask the current weather for a specific city, we need to pass a query parameter called q. This parameter receives the city name and country code divided by comma, using ISO 3166 country codes [1].

In my case, I will be asking the current weather for Lisbon, in Portugal, so the q query parameter will have the following format:

q=Lisbon,pt

Appending it to the base URL we have the result shown below. Note that between the base URL and the query parameters we need to put a question mark.

http://api.openweathermap.org/data/2.5/weather?q=Lisbon

In your case, you should change it by your city name and country code. Note that, as indicated in the documentation, you can alternatively call this API passing a city ID or geographic coordinates of the local for which you want to retrieve the weather information. The city.list.json.gz file from

this link contains the list of city IDs and geographical coordinates.

To finalize, we need to add the API key to our URL. This will correspond to an additional query parameter called APPID, which will have the key we have retrieved after registering on the OpenWeatherMap website. Note that query parameters are separated by an ampersand (“&“).

http://api.openweathermap.org/data/2.5/weather?q=Lisbon,pt&APPID={yourAPIkey}

You can now try it again on your web browser and it should return the current weather information for your city.

The Arduino code

The Arduino code for this tutorial will be very simple and similar to this previous post, where we explain how to make HTTP GET requests from the ESP32. So, in this code, we are only going to check how to reach the API and print the returned result.

The first thin we need to do is including some libraries. We will need the WiFi.h library to be able to connect the ESP32 to a WiFi network. Additionally, we will need the HTTPClient.h library so we can make HTTP requests using a very simple interface.

#include <WiFi.h> #include <HTTPClient.h>

We will also need the WiFi network credentials (network name and password), so we can connect to it. We will store them in two global variables.

const char* ssid = "yourNetworkName"; const char* password = "yourNetworkPass";

We will also store the endpoint and the API key in two global variables. Note that here we are already building the final endpoint with the city and country code and the starting part of the API key query parameter. Thus, later we will only need to concatenate the endpoint with the API key when initializing the request.

Don’t forget to change Lisbon and PT by the city and country code to which you want to retrieve the weather data.

const String endpoint = "http://api.openweathermap.org/data/2.5/weather?q=Lisbon,pt&APPID="; const String key = "yourAPIkey";

Moving on to the Arduino setup function, we will first open a serial connection, to output the results of our program, and then connect the ESP32 to the WiFi network.

void setup() {  Serial.begin(115200);  WiFi.begin(ssid, password);  while (WiFi.status() != WL_CONNECTED) {    delay(1000);    Serial.println("Connecting to WiFi..");  }  Serial.println("Connected to the WiFi network"); }

We will write the rest of the code on the Arduino loop function, so we send periodic requests to the API.

The first thing we will do is declaring an object of class HTTPClient, which we will use to perform the request.

HTTPClient http;

Then we will initialize the request by calling the begin method on the HTTPClient object. This method receives as input the URL to which we want to send the request to.

Remember that we have both the URL and the API key in two global String variables, which means we simply need to concatenate them and pass the result as input of the begin method.

http.begin(endpoint + key);

Now, to make the actual request, we simply need to call the GET method on our HTTPClient object. This method takes no arguments and returns the HTTP response code, in case of successfully sending the request.

Note that in case the returned value is lesser than zero, then it means an internal error has occurred on the ESP32 and thus it will not correspond to a HTTP response code. In that case, the returned value will correspond to a specific internal error. You can check here the possible internal error codes.

int httpCode = http.GET();

Now that we have made the request, we will get the answer payload. To do so, we call the getString method of the HTTPClient object, which takes no arguments and returns the response in a String format. Additionally, we will also print the HTTP response code we obtained earlier.

We will wrap the previous calls in an error check, so we are sure that we were able to reach the server.

if (httpCode > 0) { //Check for the returning code        String payload = http.getString();        Serial.println(httpCode);        Serial.println(payload); } else {      Serial.println("Error on HTTP request"); }

To finalize, we call the end method on our HTTPClient object, so it frees all the resources.

http.end();

The final source code can be seen below. Note that before attempting to make a new request, we start by checking if the ESP32 is still connected to the WiFi network.

Also, we added a 30 seconds delay between each request. As mentioned, there is a maximum amount of requests that can be performed each minute, which you can consult here for the free account.

#include <WiFi.h> #include <HTTPClient.h> const char* ssid = "yourNetworkName"; const char* password =  "yourNetworkPass"; const String endpoint = "http://api.openweathermap.org/data/2.5/weather?q=Lisbon,pt&APPID="; const String key = "yourAPIkey"; void setup() {  Serial.begin(115200);  WiFi.begin(ssid, password);  while (WiFi.status() != WL_CONNECTED) {    delay(1000);    Serial.println("Connecting to WiFi..");  }  Serial.println("Connected to the WiFi network"); } void loop() {  if ((WiFi.status() == WL_CONNECTED)) { //Check the current connection status    HTTPClient http;    http.begin(endpoint + key); //Specify the URL    int httpCode = http.GET();  //Make the request    if (httpCode > 0) { //Check for the returning code        String payload = http.getString();        Serial.println(httpCode);        Serial.println(payload);      }    else {      Serial.println("Error on HTTP request");    }    http.end(); //Free the resources  }  delay(30000); }

Testing the code

To test the code, simply compile it and upload it to your ESP32 device using the Arduino IDE. Once the procedure finishes, open the Serial Monitor of the Arduino IDE.

Once the connection to the WiFi network is finished, you should start to see a periodic printing of the weather information for the specified city, as shown in figure 3.

Figure 3– Weather information.

Note that in this tutorial we are not going to cover the actual information returned, but you can check the format of the response JSON here. You can also use this website to format the JSON in a more user friendly format.

The objective of this esp32 tutorial is to explain how to configure the ESP32 to act as a discoverable Bluetooth device and then find it using a Python program. The tests of this ESP32 tutorial were performed using a DFRobot’s

ESP32 module device integrated in a ESP32 development board.

Introduction

The objective of this tutorial is to explain how to configure the ESP32 to act as a discoverable Bluetooth device and then find it using a Python program.

The ESP32 will be running the Arduino core. On Python, we will be using

Pybluez, a module that will allow us to use the Bluetooth functionalities of a computer that supports this protocol.

Note that the use of Pybluez was already covered in this previous tutorial. As mentioned there, you can get the .exe file from the module’s page and install it.

Since the Bluetooth functionalities have just recently arrived to the Arduino core at the time of writing, you may need to get the latest version from the Github page to be able to follow this tutorial.

On the ESP32 side, we will use some lower level IDF functions to start the Bluetooth stacks and to make the device discoverable. This was already covered in detail on this previous tutorial. You can check here the Bluetooth classic API from IDF.

The tests of this ESP32 tutorial were performed using a DFRobot’s ESP32 module device integrated in a ESP32 development board.

The Python code

We start our Python script by importing the new library we have just installed. Note that even tough the library is called Pybluez, the actual code module we are going to use is called bluetooth.

import bluetooth

To start the discovery, we simply need to call the discover_devices function. In order for the discovery to return the names of the devices, we pass the value True in the lookup_names parameter of the function. Note that this is an optional parameter that defaults to False and without setting it to True we would only get the address of the devices.

Take in consideration that the execution of this function takes a while, in order to scan the nearby devices. By default, the discovery duration is 8 seconds, and we will not change it.

devices = bluetooth.discover_devices(lookup_names=True)

This function call will return a list that we can iterate in a for in loop, in order to print each device’s information. Each element of the list will contain both the Bluetooth address and the device name. Before this loop, we will also print the size of the list, which will correspond to the number of Bluetooth devices found during the discovery procedure.

print("Devices found: %s" % len(devices)) for item in devices:    print(item)

The final code can be seen below.

import bluetooth devices = bluetooth.discover_devices(lookup_names=True) print("Devices found: %s" % len(devices)) for item in devices:    print(item)

The Arduino code

We will start our code by including the libraries needed to start the Bluetooth stacks (esp_bt_main.h) and to make the device discoverable (esp_gap_bt_api.h).

Since one of the parameters that will be printed by the Python script is the address of the device, we will also print it in the ESP32 side, for comparison.

For a detailed tutorial on how to print the Bluetooth address of the ESP32, please check this previous post. For that functionality, we will need the esp_bt_device.h library.

#include "esp_bt_main.h" #include "esp_gap_bt_api.h" #include "esp_bt_device.h"

Now that we have all the needed libraries included, we need a function to initialize both the controller and host stacks of Bluetooth. This was also covered in greater detail in this previous tutorial.

This function will receive as input a string with the name of the device, which will be seen by other Bluetooth enabled devices when discovering it. Thus, this name should be later obtained in the Python program.

bool initBluetooth(const char *deviceName) { // Initialization code }

In the implementation of the function, we will first call the btStart function, to initialize the Bluetooth controller stack. Them we will call the esp_bluedroid_init and esp_bluedroid_enable functions to both init and enable Bluedroid (the host stack).

We will also perform an error checking on the call of each of the previously mentioned functions, so we are sure everything has initialized correctly.

if (!btStart()) {    Serial.println("Failed to initialize controller");    return false; } if (esp_bluedroid_init()!= ESP_OK) {    Serial.println("Failed to initialize bluedroid");    return false; } if (esp_bluedroid_enable()!= ESP_OK) {    Serial.println("Failed to enable bluedroid");    return false; }

After the initialization, we will set the device name. To do it, we need to call the esp_bt_dev_set_device_name function. This function will receive as input a string with the name of the device. We will use the name which is the argument of our initBluetooth function.

esp_bt_dev_set_device_name(deviceName);

Then we need to make the device discoverable with a call to the esp_bt_gap_set_scan_mode function, passing as input the ESP_BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE enumerated value.

esp_bt_gap_set_scan_mode(ESP_BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE);

With this, we finish our initBluetooth function. Now we still need to declare and implement a function that will be used to retrieve the Bluetooth address of the ESP32.

We will basically reuse the same function of the already mentioned previous post to get the address. In its implementation, we first call the esp_bt_dev_get_address function to get the six bytes that compose the unique address. Then we will print them in the standard format, which corresponds to printing each byte in hexadecimal, separated by colons.

void printDeviceAddress() {  const uint8_t* point = esp_bt_dev_get_address();  for (int i = 0; i < 6; i++) {    char str[3];    sprintf(str, "%02X", (int)point[i]);    Serial.print(str);    if (i < 5){      Serial.print(":");    }  } }

Moving on to the Arduino setup function, we will start by opening a wired serial connection, to print the results of our program. Note that the Serial object is being used by both our previously declared functions, so we need to make sure it is initialized before using it.

Serial.begin(115200);

Next we call the initBluetooth function, passing as input the name to assign to the ESP32. I’m using “ESP32 BT”, but you can use other name.

initBluetooth("ESP32 BT");

To finalize the setup function, we call the printDeviceAddress function, which will output the Bluetooth address of the ESP32. We will later be able to compare against the one obtained in the Python script.

printDeviceAddress();

The final Arduino source code for the ESP32 can be seen below.

#include "esp_bt_main.h" #include "esp_bt_device.h" #include "esp_gap_bt_api.h" bool initBluetooth(const char *deviceName) {  if (!btStart()) {    Serial.println("Failed to initialize controller");    return false;  }  if (esp_bluedroid_init()!= ESP_OK) {    Serial.println("Failed to initialize bluedroid");    return false;  }  if (esp_bluedroid_enable()!= ESP_OK) {    Serial.println("Failed to enable bluedroid");    return false;  }  esp_bt_dev_set_device_name(deviceName);  esp_bt_gap_set_scan_mode(ESP_BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE); } void printDeviceAddress() {  const uint8_t* point = esp_bt_dev_get_address();  for (int i = 0; i < 6; i++) {    char str[3];    sprintf(str, "%02X", (int)point[i]);    Serial.print(str);    if (i < 5){      Serial.print(":");    }  } } void setup() {  Serial.begin(115200);  initBluetooth("ESP32 BT");  printDeviceAddress(); } void loop() {}

Testing the code

The first step for testing the code is to compile it and upload it to the ESP32 using the Arduino IDE. If you run into compilation problems, then you may be using an older version of the Arduino core without support for Bluetooth, which you can easily update by following this guide.

When the procedure finishes, simply open the Arduino IDE serial monitor. You should get an output similar to figure 1, which shows the device address getting printed.

Figure 1 – Bluetooth address of the ESP32. After this, simply run the Python script we have developed on the environment of your choice. I’m running it on IDLE, the Python IDE that comes with the language installation.

You should get an output similar to figure 1, which shows the ESP32 getting detected during the scan. Note that the address matches the one we obtained on the Arduino IDE serial monitor and the device name is the same we specified in the Arduino code.

Figure 2 – Finding the device with Pybluez.