in

Connect ESP32 and ESP8266. Send and receive data

SwA


ESP-Now is a protocol developed by Espressif that enables multiple devices (ESP32 and ESP8266) to connect to each other. ESP-Now is a low power wireless protocol that connects ESP32 and ESP8266 devices without using WiFi. This protocol is useful when we want to exchange data between ESP devices without using a router. The main feature of the ESP-Now is low power requirements.

ESP-Now: One-to-One, Broadcast, Gateway

There are several scenarios where the ESP-Now protocol can be used to connect ESP32 and ESP8266 or ESP devices. These devices can play different roles.

One-to-one communication

In one-to-one communication two ESP devices connect to exchange data.

ESP-Now: ESP32 connects to ESP8266

Using the ESP-Now terminology, there are in this scenario two peers. It is possible to set the role of each peer:

  • Master
  • Slave
  • Combo (master and slave at the same time)

One-to-many – Broadcast: Master and slaves

In one-to-many (Broadcast), ESP32 or ESP8266 acts as a broadcaster sending the same message to all the peers connected.

ESP-Now broadcast mesage. One ESP device broadcasts a message to other ESP devices

The broadcaster plays the master role that connects to several slaves. This scenario is useful when we want to control several devices that act as slaves using a broadcaster that sends data to them. You can think about a system that switch all the lights off using a central controller

Many-to-one: Gateway

The last scenario, where the ESP-now can be used, is many-to-one configuration. In this scenario, there is a central gateway that collects all the data incoming from the peers connected to it. You can imagine several sensors that send the data acquired to a central collector that will handle somehow this information.

ESP-Now gateway. Multiple ESP8266 send data to ESP32 using ESP-Now protocol

During this ESP-Now tutorial, we will describe and implement all the scenarios described above.

Recommended:
How to connect ESP32 to the smartphone through Node-RED
Send Email using ESP32 with SMTP Server: Plain and HTML email

How to use ESP-Now

Before going into the details about using ESP-Now to connect ESP32 and ESP822, it is useful to understand the steps to follow to initialize and connect the devices. The ESP-Now protocol is supported by ESP32 and ESP8266 even if there are some differences in the methods. Anyway, the main steps are valid for both devices and are:

  1. Initialize the ESP-Now
  2. If we are developing a master or a broadcaster
    • Add peer (if we are developing a master or broadcaster)
    • Define the callback function to know if a message is sent
    • Send a message
  3. If we are developing a slave
    • Add a callback function to know when a new message is arriving

One important thing to notice is that the ESP-Now protocol supports only 250 bytes as payload. If you need to send a bigger payload you can consider using MQTT protocol with ESP32.

ESP-Now functions

This a list of the most useful functions to use ESP-Now if we want to exchange data between ESP devices:

ESP32 ESP 8266 Description
esp_now_init() esp_now_init() Initialize the ESP-Now protocol
esp_now_add_peer() esp_now_add_peer() Add a new peer. These two functions differ in the parameters the accept
esp_now_register_send_cb() esp_now_register_send_cb() Callback function to know info about the message sent
esp_now_register_rcv_cb() esp_now_register_rcv_cb() Callback function invoked when a new message arrives

To have more information, you can referer to the EspressIf guide for the ESP32 and here for the ESP8266.

ESP-Now: One-to-one connection

In this paragraph, we are going to discuss how to exchange data between two ESP8266 devices using ESP-Now protocol in a One-to-one configuration where one of the device is a master while the other is the slave.

This is very simple scenario, where there is a device that sends data and the other one that receives it. We will have two different codes: one for the sender and the another one for the receiver.

ESP-Now ESP8266 Sender

The ESP8266 sender code is shown below:

#include #include #include uint8_t peer1[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; typedef struct message { int red; int green; int blue; }; struct message myMessage; void onSent(uint8_t *mac_addr, uint8_t sendStatus) { Serial.println("Status:"); Serial.println(sendStatus); } void setup() { Serial.begin(115200); WiFi.mode(WIFI_STA); Serial.print("Mac Address: "); Serial.print(WiFi.macAddress()); Serial.println("ESP-Now Sender"); if (esp_now_init() != 0) { Serial.println("Problem during ESP-NOW init"); return; } esp_now_set_self_role(ESP_NOW_ROLE_CONTROLLER); Serial.println("Registering a peer"); esp_now_add_peer(peer1, ESP_NOW_ROLE_SLAVE, 1, NULL, 0); Serial.println("Registering send callback function"); esp_now_register_send_cb(onSent); } void loop() { myMessage.red = 10; myMessage.green = 80; myMessage.blue = 180; Serial.println("Send a new message"); esp_now_send(NULL, (uint8_t *) &myMessage, sizeof(myMessage)); delay(60000); }

A brief code description:

  • Line 10: This is the MAC address of the slave. We use this address to send data
  • Line 11-15: The message structure. This is the message we want to send to the ESP-Now peer (or slave). The message can hold several fields (i.e. char, int, float and so on).
  • Line 17-20: The callback function invoked when the message is sent
  • Line 29: The ESP-Now is initialized before using it
  • Line 33: The ESP8266 defines its role. This is the master role
  • Line 36: The code adds the peer to the peer list. In this case, the device, which acts as master, add the other ESP8266 (the slave) using the Mac address. In this way, the two ESP devices can exchange data through the ESP-Now protocol
  • Line 38: We register the callback function that is triggered as soon as the message is sent
  • Line 45: The master sends the message to the other ESP8266 through the ESP-Now

ESP-Now ESP8266 Receiver

The receiver code is much more simpler:

#include #include #include typedef struct message { int red; int green; int blue; } message; message myMessage; void onDataReceiver(uint8_t * mac, uint8_t *incomingData, uint8_t len) { Serial.println("Message received."); memcpy(&myMessage, incomingData, sizeof(myMessage)); Serial.print("Red:"); Serial.println(myMessage.red); Serial.print("Green:"); Serial.println(myMessage.green); Serial.print("Blue:"); Serial.println(myMessage.blue); } void setup() { Serial.begin(115200); WiFi.disconnect(); ESP.eraseConfig(); WiFi.mode(WIFI_STA); Serial.print("Mac Address: "); Serial.print(WiFi.macAddress()); Serial.println("nESP-Now Receiver"); if (esp_now_init() != 0) { Serial.println("Problem during ESP-NOW init"); return; } esp_now_register_recv_cb(onDataReceiver); } void loop() { }

  • Line 10-21: This is the callback function triggered when a new message arrives through the ESP-Now protocol
  • Line 35: As in the ESP8266 sender, we have to initialize the ESP-Now protocol
  • Line 42: We register the ESP-Now callback function that will be invoked as soon as a new message arrives to the ESP8266

Testing the ESP-Now connection between ESP8266

Running the code: one in the sender device and the other in the receiver the result you get is something like:

ESP-Now connect two ESP devices

ESP-Now Broadcast: Connect ESP32 and multiple ESP8266

This is little bit more complex example that describes how to use ESP-Now with ESP32. In this scenario, we can suppose that there is an ESP32 that is a broadcaster and sends data to multiple ESP8266 devices thorugh the ESP-Now protocol. This is a one-to-many configuration. To describes this scenario, we will suppose that the:

  • ESP32 connects to two ESP8266 devices through the ESP-Now protocol
  • The ESP32 broadcasts a message containing RGB color information to all the connected devices
  • The ESP8266 devices receive this message and control an RGB Led strips.

This example is interesting because we can describe how to use the ESP-Now to broadcast a message and how to integrate ESP32 and ESP8266 using the ESP-Now protocol. You can use all ESP32 or all ESP8266 in this example.

ESP-Now ESP32: Broadcast

This code describes how to use ESP32 with ESP-Now:

#include #include #include uint8_t mac_peer1[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; uint8_t mac_peer2[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; esp_now_peer_info_t peer1; esp_now_peer_info_t peer2; int i = 0; typedef struct message { int red; int green; int blue; }; struct message myMessage; void setup() { Serial.begin(115200); WiFi.mode(WIFI_STA); Serial.print("Mac Address: "); Serial.print(WiFi.macAddress()); Serial.println("ESP32 ESP-Now Broadcast"); if (esp_now_init() != 0) { Serial.println("Problem during ESP-NOW init"); return; } memcpy(peer1.peer_addr, mac_peer1, 6); peer1.channel = 4; peer1.encrypt = 0; Serial.println("Registering a peer 1"); if ( esp_now_add_peer(&peer1) == ESP_OK) { Serial.println("Peer 1 added"); } memcpy(peer2.peer_addr, mac_peer2, 6); peer2.channel = 4; peer2.encrypt = 0; Serial.println("Registering a peer 2"); if ( esp_now_add_peer(&peer2) == ESP_OK) { Serial.println("Peer 2 added"); } } void loop() { myMessage.red = random(0, 254); myMessage.green = random(0, 254); myMessage.blue = random(0, 254); Serial.println("Send a new message"); esp_now_send(NULL, (uint8_t *) &myMessage, sizeof(myMessage)); delay(2000); }

A brief code description:

  • Line 10-12: We define two variables named peer1 and peer2 that will contain the information related to the two ESP8266 that will receive the messages
  • Line 30: We initialize the ESP-Now protocol
  • Line 34-36: We define the peer1 details:
    • its Mac Address,
    • the channel we will use to send data (you can choose the ESP-Now channel you like)
    • the encryption (false in this scenario)
  • Line 39: The ESP32 add the ESP8266 (the peer1) to the peer list
  • Line 42-44: We define the peer2 details:
    • its Mac Address,
    • the channel we will use to send data (you can choose the ESP-Now channel you like)
    • the encryption (false in this scenario)
  • Line 47: The ESP32 add the ESP8266 (the peer2) to the peer list
  • Line 56: We are sending the message. Note here that we used NULL that means we want to send the message to all the peer registered

ESP-Now Receiver

This receiver is almost the same described previously, with the only difference that when the ESP8266 receive a message it wil set the LED color.

#include #include #include #include #define NUM_OF_LEDS D6 #define PIN 12 typedef struct message { int red; int green; int blue; } message; uint8_t key[] = {0x33, 0x44, 0x33, 0x44, 0x33, 0x44, 0x33, 0x44, 0x33, 0x44, 0x33, 0x44, 0x33, 0x44, 0x33, 0x44}; message myMessage; Adafruit_NeoPixel pixels(NUM_OF_LEDS, PIN, NEO_GRB + NEO_KHZ800); void onDataReceiver(uint8_t * mac, uint8_t *incomingData, uint8_t len) { Serial.println("Message received."); memcpy(&myMessage, incomingData, sizeof(myMessage)); Serial.print("Red:"); Serial.println(myMessage.red); Serial.print("Green:"); Serial.println(myMessage.green); Serial.print("Blue:"); Serial.println(myMessage.blue); pixels.fill(pixels.Color(myMessage.red, myMessage.green, myMessage.blue)); pixels.show(); } void setup() { Serial.begin(115200); WiFi.disconnect(); ESP.eraseConfig(); pixels.begin(); WiFi.mode(WIFI_STA); Serial.print("Mac Address: "); Serial.print(WiFi.macAddress()); Serial.println("nESP-Now Receiver"); if (esp_now_init() != 0) { Serial.println("Problem during ESP-NOW init"); return; } esp_now_register_recv_cb(onDataReceiver); } void loop() { }

If you are using Wemos D1 mini, there could be a bug that prevents this device to receive broadcast messages. In this case, you can follow this guide to know how to fix it.

Testing the ESP-Now with ESP32 and ESP8266

If you run the code in the ESP32 and ESP8266 devices you will notice that very 2 seconds the LEDs, connected to the ESP8266, change color. The ESP32 sends messages with random RGB values.

ESP-Now Gateway: Use ESP32 to collect sensor data

In the last part of this tutorial, we will use the ESP32 as an ESP-Now gateway to collect sensor readings connected to multiple ESP8266. In other words, ESP8266 devices send data to the ESP32.

ESP32 Receiver

This is the code of the ESP32 receiver that is connected to other ESP8266 using ESP-Now:

#include #include #include typedef struct message { float temperature; float humidity; }; struct message myMessage; void onDataReceiver(const uint8_t * mac, const uint8_t *incomingData, int len) { Serial.println("Message received."); memcpy(&myMessage, incomingData, sizeof(myMessage)); Serial.println("=== Data ==="); Serial.print("Mac address: "); for (int i = 0; i < 6; i++) { Serial.print("0x"); Serial.print(mac[i], HEX); Serial.print(":"); } Serial.print("nnTemperature: "); Serial.println(myMessage.temperature); Serial.print("nHumidity: "); Serial.println(myMessage.humidity); Serial.println(); } void setup() { Serial.begin(115200); WiFi.mode(WIFI_STA); Serial.print("Mac Address: "); Serial.print(WiFi.macAddress()); Serial.println("ESP32 ESP-Now Broadcast"); if (esp_now_init() != 0) { Serial.println("Problem during ESP-NOW init"); return; } esp_now_register_recv_cb(onDataReceiver); } void loop() { }

Notice the message (line 5-8) is different than before because it holds the temperature and the humidity. The other aspects are almost the same covered previously.

ESP-Now sender

There are two ESP8266 senders that wirelessly sends data to the ESP32. The ESP sender code is shown below:

#include #include #include #include #include #include #define DHTTYPE DHT11 #define DHTPin D6 uint8_t peer1[] = {0x24, 0x6F, 0x28, 0x10, 0x67, 0xD8}; typedef struct message { float temperature; float humidity; }; struct message myMessage; DHT dht(DHTPin, DHTTYPE); void onSent(uint8_t *mac_addr, uint8_t sendStatus) { Serial.println("Status:"); Serial.println(sendStatus); } void setup() { Serial.begin(115200); dht.begin(); WiFi.mode(WIFI_STA); Serial.print("Mac Address: "); Serial.print(WiFi.macAddress()); Serial.println("ESP-Now Sender"); if (esp_now_init() != 0) { Serial.println("Problem during ESP-NOW init"); return; } esp_now_set_self_role(ESP_NOW_ROLE_CONTROLLER); Serial.println("Registering a peer"); esp_now_add_peer(peer1, ESP_NOW_ROLE_SLAVE, 1, NULL, 0); Serial.println("Registering send callback function"); esp_now_register_send_cb(onSent); } void loop() { myMessage.temperature = dht.readTemperature(); myMessage.humidity = dht.readHumidity(); Serial.println("Send a new message"); esp_now_send(NULL, (uint8_t *) &myMessage, sizeof(myMessage)); delay(60000); }

Every minute, these two ESP8266 devices send the temperature and the humidity acquired by DHT11 sensor.

The final result is shown in the picture below:

ESP-Now between ESP devices

Wrapping up

This post describes how to use ESP-Now wireless protocol. The ESP-Now is fast and reliable protocol that connects different devices. There are different scenarios where we can use ESP-Now. We have used ESP-Now protocol to connect ESP8266 with an ESP8266 in one-to-one configuration. Moreover, we have learned how to use ESP-Now to connect ESP32 and ESP8266 where the ESP32 receives data from multiple ESP8266 devices. On the other hand, the ESP8266 can send data to ESP8266.



Source link

What do you think?

Comments

Leave a Reply

Your email address will not be published. Required fields are marked *

five − four =

Loading…

0
Transform Patient’s Engagement with Healthcare Providers

Transform Patient’s Engagement with Healthcare Providers

Facebook Employees Take the Rare Step to Call Out Mark Zuckerberg

Facebook Employees Take the Rare Step to Call Out Mark Zuckerberg