<\/strong><\/p>\n\n
In my article WLAN with ESP8266 and ESP32<\/a>, I showed how to let ESP boards communicate with each other via WiFi and how to control them via the browser of your PC or smartphone. However, if you only want to exchange data between two or more ESP boards, there is a simpler method called ESP-NOW.<\/p>\n I will explain step by step how to use your ESP32 or ESP8266 based boards with ESP-NOW as a receiver, transmitter or transceiver. I primarily use the ESP32 as a demonstration object. Finally, I will also show you how to modify the code for ESP8266 boards.<\/p>\n These are the topics I will discuss:<\/p>\n\n ESP-NOW is a protocol that allows you to exchange messages of up to 250 bytes between up to twenty ESP32 or ESP8266 boards. ESP-NOW is very flexible. It allows you to set up any board as a transmitter, receiver or transceiver and send messages to single or multiple members of your network. It is also possible to mix ESP32 and ESP8266 boards without any problems.<\/p>\n To use ESP-NOW, you do not need to install any additional software. The required libraries are part of the “standard equipment” of the ESP32 and ESP8266 packages. <\/p>\n\n The members of a network must be clearly identifiable. ESP-NOW uses the MAC address<\/a> of your ESP boards, which you can read out and format with the following sketch:<\/p>\n<\/p>\n \n\n The explicit setting of the Wi-Fi mode (line 7) is required from board package version 3.0.0 in order to determine the MAC address.<\/p>\n And here is the output:<\/p>\n\n To use the WiFi functions, you have to include The MAC address consists of six bytes. Usually, the bytes are specified in the hexadecimal system, separated by colons. E.g. So, you have to find out the MAC address of every board that should participate in your ESP-NOW network and write it down. It is recommended to label the boards in some way to avoid confusion.<\/p>\n Note: If you load your sketches on ESP boards, then it may happen that the first<\/em> If it is too tedious for you to read out all MAC addresses, then you can simply set a new one. The following two sketches show how to do this for the ESP32 and the ESP8266.<\/p>\n\n \n\n And here is the output:<\/p>\n\n A few explanations:<\/p>\n I will change the MAC address only in one of the example sketches. If you want to use this option in the other examples, you have to extend the sketches accordingly.<\/p>\n\n And this is how the counterpart for the ESP8266 looks like:<\/p>\n<\/p>\n \n\n To let your boards communicate via ESP-NOW, you only need a few functions, which I have summarized here in an overview:<\/p>\n\n The function A complete list of the functions can be found here<\/a> in the API documentation for ESP-NOW.<\/p>\n\n Since ESP-NOW can be a little confusing for beginners, we’ll start with a minimal example and then build on that. In this example, one board takes the role of the transmitter, the other serves as the receiver. The message consists of text only. <\/p>\n And again the hint: The code is ESP32 specific<\/strong>. I will come to the transfer to the ESP8266 at the end of the article.<\/p>\n\n \n\n Explanations:<\/p>\n If you don’t want to determine MAC addresses, you could use the broadcast MAC address FF:FF:FF:FF:FF:FF:FF instead of individual addresses. All recipients will then receive the message, provided they are set to the same channel. <\/p>\n\n \n\n Here are some explanations as well:<\/p>\n If everything went well, then the message of the transmitter should be displayed on the serial monitor of the receiver module every five seconds.<\/p>\n\n The “Bare Minimum” sketches are not particularly convenient so far. There are no error messages if something goes wrong, no send confirmation, and no display of the MAC address of the transmitter. Also, we have only sent plain text so far. In practice, it is more likely that users will want to transmit data, such as sensor readings. We will now eliminate these deficits.<\/p>\n\n First, the transmitter sketch:<\/p>\n<\/p>\n \u00a0<\/p>\n<\/div>\n \n\n The receiver sketch can also be made more comfortable:<\/p>\n<\/p>\n \u00a0<\/p>\n<\/div>\n \n\n In practice, one often uses several transmitters and one receiver. A typical application example would be a weather station with sensors at different locations that transmit their data to a central station.<\/p>\n You do not need any additional ESP-NOW functions for this configuration. The only challenge is assigning the incoming data to the transmitters. The obvious solution would be to compare the transmitter MAC address with a list stored in the receiver sketch. However, an identity check of arrays is quite computationally intensive. Alternatively, the message from the transmitter could contain an identifier. <\/p>\n I decided to use a different method. All ESP modules participating in the network get a new MAC address. The MAC addresses differ only in the last byte, which also serves as numbering. In my example, three transmitters are used, and I have assigned the following MAC addresses for them:<\/p>\n Here is the sketch for the transmitter 0:<\/p>\n<\/p>\n \u00a0<\/p>\n<\/div>\n \n\n As data we send the humidity and the temperature, which we could have determined with a DHT22, for example. The data is “packed” in the structure On the receiver side, we first copy the incoming messages to the “auxiliary structure” \u00a0<\/p>\n<\/div>\n \n\n Here is the output:<\/p>\n\n It is just as easy to network one transmitter and multiple receivers. This configuration could be used for smart home applications, for example. The sender must know all the MAC addresses of the peers, i.e. the receivers, and connect to all of them.<\/p>\n For simplicity and better overview, in my example all receivers get sent the same data types, so we only need to define one structure. If necessary, this could be easily changed.<\/p>\n\n \u00a0<\/p>\n<\/div>\n \n\n I don’t think the code needs any further explanation, do you?<\/p>\n You could also simplify this sketch a bit by changing the MAC addresses of the receivers so that they only differ in the last byte. You then only need a one-dimensional array for the Maybe also useful: If you replace the receiver address in the function This is what the output looks like on the transmitter side:<\/p>\n\n The sketch for the receivers should also be understandable without further explanation:<\/p>\n<\/p>\n \u00a0<\/p>\n<\/div>\n \n\n\n
\n
Introduction \/ preparations (ESP32 and ESP8266)<\/h2>\n\n
Getting the MAC address<\/h3>\n\n
#include \"WiFi.h\"\n\/\/#include <ESP8266WiFi.h> \/\/ for ESP8266 boards\n\nvoid setup(){\n Serial.begin(115200);\n delay(1000); \/\/ uncomment if your serial monitor is empty\n WiFi.mode(WIFI_STA); \n while (!(WiFi.STA.started())) { \/\/ comment the while loop for ESP8266\n delay(10);\n }\n \/\/ delay(1000); \/\/ uncomment for ESP8266\n Serial.print(\"MAC-Address: \");\n String mac = WiFi.macAddress();\n Serial.println(mac);\n \n Serial.print(\"Formated: \");\n Serial.print(\"{\");\n int index = 0;\n for(int i=0; i<6; i++){\n Serial.print(\"0x\");\n Serial.print(mac.substring(index, index+2));\n if(i<5){\n Serial.print(\", \");\n }\n index += 3;\n }\n Serial.println(\"}\");\n}\n \nvoid loop(){}<\/pre>\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2024\/07\/output_esp32_get_mac_address_sta.png\")
<\/a>A few explanations about the sketch<\/h4>\n\n
WiFi.h<\/code> for ESP32-based boards. For ESP8266-based boards, include ESP8266WiFi.h<\/code>.<\/p>\n94:3C:C6:33:68:98<\/code>.<\/p>\nSerial.print()<\/code> instructions are “swallowed” during the first program run. A<\/em> while(!Serial)<\/code> after<\/em> Serial.begin()<\/code>, which is recommended for certain boards, does not eliminate the problem (if you should have it). That’s why you’ll find a commented out delay() in my sketches, which you can uncomment if necessary. <\/em><\/p>\n\nchange MAC address<\/h3>\n\n
ESP32<\/h4>\n<\/p>\n
#include <WiFi.h>\n#include <esp_wifi.h>\n\nconst uint8_t newMacAddress[] = {0xC8, 0xC9, 0xA3, 0xC6, 0xFE, 0x54}; \/\/ customize as you wish \nuint8_t requestedNewMacAddress[6] = {0,0,0,0,0,0};\n\nvoid setup(){\n Serial.begin(115200);\n delay(1000); \n WiFi.mode(WIFI_STA);\n while (!(WiFi.STA.started())) {\n delay(100);\n }\n Serial.print(\"Default ESP Board MAC Address: \");\n Serial.println(WiFi.macAddress());\n \n esp_wifi_set_mac(WIFI_IF_STA, newMacAddress);\n esp_wifi_get_mac(WIFI_IF_STA, requestedNewMacAddress);\n \n Serial.print(\"New ESP Board MAC Address: \");\n esp_wifi_get_mac(WIFI_IF_STA, requestedNewMacAddress);\n for (int i=0; i<6; i++) {\n Serial.print(requestedNewMacAddress[i],HEX);\n if (i<5) {\n Serial.print(\":\");\n }\n } \n}\n \nvoid loop(){}<\/pre>\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2024\/07\/output_change_mac_address.png\")
<\/a>\n
esp_wifi.h<\/code>.<\/li>\nuint8_t<\/code>).<\/li>\nWiFi.mode(WIFI_STA)<\/code>.<\/li>\nesp_wifi_set_mac()<\/code> you set the MAC address. The function expects two arguments. The first is the interface used. Since we are working in Station mode, we select the station interface ( = WIFI_IF_STA). The second argument is the new MAC address. \n
esp_wifi_set_mac()<\/code> function here<\/a>.<\/li>\n<\/ul>\n<\/li>\nesp_wifi_set_mac()<\/code> is not permanent, i.e. the ESP “forgets” the setting at a reset.<\/li>\nWiFi.macAddress()<\/code> always returns the hardware MAC address. To check this, take the inconvenient detour via esp_wifi_get_mac()<\/code>. <\/li>\n<\/ul>\nESP8266<\/h4>\n\n
#include <ESP8266WiFi.h>\n\nuint8_t newMacAddress[] = {0x94, 0x3C, 0xC6, 0x33, 0x68, 0x01}; \/\/ customize as you wish\n\nvoid setup(){\n Serial.begin(115200);\n \/\/ delay(1000); \/\/ uncomment if your serial monitor is empty\n Serial.print(\"Default ESP Board MAC Address: \");\n Serial.println(WiFi.macAddress());\n \n WiFi.mode(WIFI_STA);\n wifi_set_macaddr(STATION_IF, newMacAddress);\n \n Serial.print(\"New ESP Board MAC Address: \");\n Serial.println(WiFi.macAddress()); \n}\n \nvoid loop(){}<\/pre>\nOverview of the most important ESP-NOW functions (ESP32 and ESP8266)<\/h2>\n\n
![\"The](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2024\/07\/esp_now_functions.png\")
<\/a>esp_now_register_recv_cb()<\/code> is the main reason why the board package version 3.x is not backwards compatible. More precisely, it is the change of the first function parameter from uint8_t * macAddr<\/code> to const esp_now_recv_info* info<\/code>. esp_now_recv_info<\/code> is a structure with the following public elements: <\/p>\n\n
uint8_t *src_addr<\/code>i.e. the MAC address of the transmitter<\/li>\nuint8_t *des_addr<\/code>i.e. the MAC address of the recipient<\/li>\nwifi_pkt_rx_ctrl_t *rx_ctrl<\/code>this is RX control information<\/li>\n<\/ul>\n\nOne transmitter, one receiver – bare minimum (ESP32)<\/h2>\n\n
Transmitter<\/h3>\n<\/p>\n
#include <esp_now.h>\n#include <WiFi.h>\n\nuint8_t receiverAddress[] = {0x94, 0x3C, 0xC6, 0x33, 0x68, 0x98};\nesp_now_peer_info_t peerInfo;\n\nvoid setup(){\n Serial.begin(115200);\n \/\/ delay(1000); \/\/ uncomment if your serial monitor is empty\n WiFi.mode(WIFI_STA);\n \n esp_now_init();\n \n memcpy(peerInfo.peer_addr, receiverAddress, 6);\n peerInfo.channel = 0;\n peerInfo.encrypt = false;\n\n esp_now_add_peer(&peerInfo);\n}\n \nvoid loop(){\n char message[] = \"Hi, this is a message from the transmitting ESP\";\n esp_now_send(receiverAddress, (uint8_t *) message, sizeof(message)-1); \/\/ -1 to not send the NULL terminator\n delay(5000);\n}<\/pre>\n\n
#include<esp_now.h><\/code> we integrate the ESP-NOW library.<\/li>\npeerInfo<\/code> contains information about the module we want to communicate with. This is a structure of type esp_now_peer_info_t<\/code>. The documentation can be found here<\/a>. For us, the following elements of the structure are relevant:\n\n
peer_addr<\/code> contains the MAC address of the receiver module.\n\n
peerInfo.peer_addr = receiverAddress<\/code> is not possible, because arrays cannot be copied so easily. Therefore, the detour via memcpy()<\/code>.<\/li>\n<\/ul>\n<\/li>\nchannel<\/code> is the WiFi channel<\/a>. You can choose the channels 1 – 13. With “0” the default setting takes effect, namely “1”. I will describe how to change the WLAN channel of your module at the end of the article.<\/li>\nencrypt<\/code> specifies whether you want to encrypt the message. I am not going into that.<\/li>\n<\/ul>\n<\/li>\nesp_now_init()<\/code> initializes ESP-NOW.<\/li>\nesp_now_add_peer(&peerInfo)<\/code> adds the ESP module you defined before with peerInfo<\/code> to the network of the current module. <\/li>\nesp_now_send()<\/code> sends a message. You pass the MAC address of the recipient, the message and its length to the function. The message is of data type uint8_t<\/code> and is passed as a pointer in esp_now_send()<\/code>. Accordingly, message<\/code> must still be explicitly converted using (uint8_t *)<\/code>.<\/li>\n<\/ul>\n\nBroadcasting<\/h4>\n\n
Receiver<\/h3>\n<\/p>\n
#include <esp_now.h>\n#include <WiFi.h>\n\nvoid messageReceived(const esp_now_recv_info *info, const uint8_t* incomingData, int len){\n for(int i=0; i<len; i++){\n Serial.print((char)incomingData[i]);\n }\n Serial.println();\n}\n\n\nvoid setup(){\n Serial.begin(115200);\n \/\/ delay(1000); \/\/ uncomment if your serial monitor is empty\n WiFi.mode(WIFI_STA);\n esp_now_init();\n esp_now_register_recv_cb(messageReceived);\n}\n\nvoid loop(){}<\/pre>\n\n
esp_now_register_recv_cb()<\/code>. With this, you register a function (here: messageReceived), which is called automatically when a message is received. The “cb” stands for “call back”. Since the function is called automatically, loop()<\/code> can be left empty. You know the principle from interrupt service routines.<\/li>\nuint8_t<\/code>, we have to explicitly convert it back to char<\/code>. <\/li>\n<\/ul>\n\nOutput on the serial monitor<\/h4>\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/03\/output_receiver_bare_minimum.png\")
<\/a>One transmitter, one receiver – advanced (ESP32)<\/h2>\n\n
Transmitter sketch<\/h3>\n\n
#include <esp_now.h>\n#include <WiFi.h>\n\nuint8_t receiverAddress[] = {0x94, 0x3C, 0xC6, 0x33, 0x68, 0x98};\nesp_now_peer_info_t peerInfo;\n\ntypedef struct message {\n char text[64];\n int intVal;\n float floatVal;\n} message;\n\nmessage myMessage; \n\nvoid messageSent(const uint8_t *macAddr, esp_now_send_status_t status) {\n Serial.print(\"Send status: \");\n if(status == ESP_NOW_SEND_SUCCESS){\n Serial.println(\"Success\");\n }\n else{\n Serial.println(\"Error\");\n }\n}\n\nvoid setup(){\n Serial.begin(115200);\n \/\/ delay(1000); \/\/\u00a0uncomment\u00a0if\u00a0your\u00a0serial\u00a0monitor\u00a0is\u00a0empty\n WiFi.mode(WIFI_STA);\n \n if (esp_now_init() == ESP_OK) {\n Serial.println(\"ESPNow Init success\");\n }\n else {\n Serial.println(\"ESPNow Init fail\");\n return;\n }\n \n esp_now_register_send_cb((esp_now_send_cb_t)messageSent); \n\n memcpy(peerInfo.peer_addr, receiverAddress, 6);\n peerInfo.channel = 0;\n peerInfo.encrypt = false;\n\n if (esp_now_add_peer(&peerInfo) != ESP_OK) {\n Serial.println(\"Failed to add peer\");\n return;\n }\n}\n \nvoid loop(){\n char textMsg[] = \"Hi Receiver, here's my data for you: \";\n memcpy(&myMessage.text, textMsg, sizeof(textMsg));\n myMessage.intVal = 4242;\n myMessage.floatVal = 42.42;\n esp_err_t result = esp_now_send(receiverAddress, (uint8_t *) &myMessage, sizeof(myMessage));\n if (result != ESP_OK) {\n Serial.println(\"Sending error\");\n }\n delay(5000);\n}<\/pre>\nWhat is different compared to the bare minimum sketch?<\/h4>\n\n
\n
message<\/code> are kind of stripped down classes. message myMessage;<\/code> creates the object myMessage<\/code>.<\/li>\nesp_now_init()<\/code> tells us whether the process was completed without errors. <\/li>\nesp_now_add_peer()<\/code>. Important: the function does not check whether the peer is really available or reachable. But, for example, you would get an error message if the maximum number of peers is exceeded. For more information, see the API documentation<\/a>.<\/li>\ntextMsg<\/code> to the array myMessage.text<\/code> you have to use memcpy()<\/code> for the reasons already mentioned before. You can assign the other elements directly. <\/li>\nesp_now_register_send_cb((esp_now_send_cb_t)messageSent);<\/code> we register the function messageSent<\/code>, which is called when a message has been sent. Again, the parameters are predefined.<\/li>\nstatus<\/code> in the function messageSent<\/code> and checking result<\/code> as the return value of esp_now_send()<\/code> may seem like unnecessary duplication, but different criteria are checked in each case. For details – guess what – see the API documentation.<\/li>\n<\/ul>\n\nReceiver sketch<\/h3>\n\n
#include <esp_now.h>\n#include <WiFi.h>\n\ntypedef struct message {\n char text[64];\n int intVal;\n float floatVal;\n} message;\n\nmessage myMessage;\n\nvoid messageReceived(const esp_now_recv_info *info, const uint8_t* incomingData, int len){\n memcpy(&myMessage, incomingData, sizeof(myMessage));\n Serial.printf(\"Transmitter MAC Address: %02X:%02X:%02X:%02X:%02X:%02X \\n\\r\", \n info->src_addr[0], info->src_addr[1], info->src_addr[2], info->src_addr[3], info->src_addr[4], info->src_addr[5]); \n Serial.print(\"Message: \");\n Serial.println(myMessage.text);\n Serial.print(\"Integer Value: \");\n Serial.println(myMessage.intVal);\n Serial.print(\"Float Value: \");\n Serial.println(myMessage.floatVal);\n Serial.println();\n}\n\nvoid setup(){\n Serial.begin(115200);\n \/\/ delay(1000); \/\/ uncomment if your serial monitor is empty\n WiFi.mode(WIFI_STA);\n \n if (esp_now_init() == ESP_OK) {\n Serial.println(\"ESPNow Init success\");\n }\n else {\n Serial.println(\"ESPNow Init fail\");\n return;\n }\n\n esp_now_register_recv_cb(messageReceived);\n}\n \nvoid loop(){}<\/pre>\nWhat is different here compared to the bare minimum sketch?<\/h4>\n\n
\n
message<\/code> as in the transmitter sketch.<\/li>\nmyMessage<\/code> using memcpy()<\/code> and then we can conveniently access the elements of the structure myMessage<\/code>.<\/li>\nprintf()<\/code> function. \n\n
src_addr<\/code>) is an element of info<\/code>. Since info<\/code> was passed as a pointer to messageReceived()<\/code>, we must use the arrow operator instead of the dot operator to access src_addr<\/code>. <\/li>\n<\/ul>\n<\/li>\n<\/ul>\n\nOutput of receiver_basic.ino<\/h4>\n\n
![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/03\/output_receiver_basic.png\")
<\/a>Several transmitters, one receiver (ESP32)<\/h2>\n\n
\n
<\/strong> <\/li>\n<\/ul>\n\nTransmitter sketch example<\/h3>\n\n
#include <esp_now.h>\n#include <esp_wifi.h>\n#include <WiFi.h>\n\nuint8_t receiverAddress[] = {0x94, 0x3C, 0xC6, 0x33, 0x68, 0x05};\nuint8_t myAddress[] = {0x94, 0x3C, 0xC6, 0x33, 0x68, 0x00};\nesp_now_peer_info_t peerInfo;\n\ntypedef struct data {\n int humidity;\n float temperature;\n} data;\n\ndata myMessage; \n\nvoid messageSent(const uint8_t *macAddr, esp_now_send_status_t status) {\n Serial.print(\"Send status: \");\n if(status == ESP_NOW_SEND_SUCCESS){\n Serial.println(\"Success\");\n }\n else{\n Serial.println(\"Error\");\n }\n}\n\nvoid setup(){\n Serial.begin(115200);\n delay(1000);\n WiFi.mode(WIFI_STA);\n esp_wifi_set_mac(WIFI_IF_STA, myAddress);\n Serial.print(\"New ESP Board MAC Address: \");\n Serial.println(WiFi.macAddress()); \n \n if (esp_now_init() == ESP_OK) {\n Serial.println(\"ESPNow Init success\");\n }\n else {\n Serial.println(\"ESPNow Init fail\");\n return;\n }\n \n esp_now_register_send_cb((esp_now_send_cb_t)messageSent); \n\n memcpy(peerInfo.peer_addr, receiverAddress, 6);\n peerInfo.channel = 0;\n peerInfo.encrypt = false;\n\n if (esp_now_add_peer(&peerInfo) != ESP_OK) {\n Serial.println(\"Failed to add peer\");\n return;\n }\n}\n \nvoid loop(){\n myMessage.humidity = 42;\n myMessage.temperature = 16.9;\n esp_err_t result = esp_now_send(receiverAddress, (uint8_t *) &myMessage, sizeof(myMessage));\n if (result != ESP_OK) {\n Serial.println(\"Sending error\");\n }\n delay(3000);\n}<\/pre>\ndata<\/code>.<\/p>\n\nReceiver<\/h3>\n\n
stationMsg<\/code> and from there we transfer them to the array weatherStation[]<\/code>. The counter for the elements of the array is simply the last digit of the MAC address, i.e. info->src_addr[5]<\/code>:<\/p>\n<\/p>\n#include <esp_now.h>\n#include <esp_wifi.h>\n#include <WiFi.h>\n\nuint8_t myAddress[] = {0x94, 0x3C, 0xC6, 0x33, 0x68, 0x05};\n\ntypedef struct data {\n int humidity;\n float temperature;\n} data;\n\ndata stationMsg;\ndata weatherStation[3] = {0, 0};\n\nvoid messageReceived(const esp_now_recv_info *info, const uint8_t* incomingData, int len){\n memcpy(&stationMsg, incomingData, sizeof(stationMsg));\n weatherStation[info->src_addr[5]].humidity = stationMsg.humidity;\n weatherStation[info->src_addr[5]].temperature = stationMsg.temperature;\n}\n\nvoid setup(){\n Serial.begin(115200);\n delay(1000);\n WiFi.mode(WIFI_STA);\n esp_wifi_set_mac(WIFI_IF_STA, myAddress);\n \n if (esp_now_init() == ESP_OK) {\n Serial.println(\"ESPNow Init success\");\n }\n else {\n Serial.println(\"ESPNow Init fail\");\n return;\n }\n\n esp_now_register_recv_cb(messageReceived);\n}\n \nvoid loop(){\n for(int i=0; i<3; i++){\n Serial.print(\"Weather Station \");\n Serial.print(i);\n Serial.println(\":\");\n Serial.print(\"Humidity [%] : \");\n Serial.println(weatherStation[i].humidity);\n Serial.print(\"Temperature [\u00b0C]: \");\n Serial.println(weatherStation[i].temperature,1);\n Serial.println();\n }\n Serial.println();\n delay(5000); \n}<\/pre>\n![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/03\/output_multi_transm_one_recv_receiver.png\")
<\/a>One transmitter, multiple receivers (ESP32)<\/h2>\n\n
Transmitter<\/h3>\n<\/p>\n
#include <esp_now.h>\n#include <WiFi.h>\n\nuint8_t receiverAddress[3][6] = {{0xC8, 0xC9, 0xA3, 0xCA, 0x22, 0x70},\n {0xC8, 0xC9, 0xA3, 0xC6, 0xFE, 0x54},\n {0x94, 0xE6, 0x86, 0x0D, 0x7B, 0x80}};\nesp_now_peer_info_t peerInfo[3];\n\ntypedef struct message {\n char text[32];\n int intVal;\n float floatVal;\n} message;\n\nmessage myMessage[3]; \n\nvoid messageSent(const uint8_t *macAddr, esp_now_send_status_t status) {\n Serial.printf(\"Send status to receiver %02X:%02X:%02X:%02X:%02X:%02X : \", \n macAddr[0], macAddr[1], macAddr[2], macAddr[3], macAddr[4], macAddr[5]); \n if(status == ESP_NOW_SEND_SUCCESS){\n Serial.println(\"Success\");\n }\n else{\n Serial.println(\"Error\");\n }\n}\n\nvoid setup(){\n Serial.begin(115200);\n \/\/ delay(1000); \/\/ uncomment if your serial monitor is empty\n WiFi.mode(WIFI_STA);\n \n if (esp_now_init() == ESP_OK) {\n Serial.println(\"ESPNow Init success\");\n }\n else {\n Serial.println(\"ESPNow Init fail\");\n return;\n }\n \n esp_now_register_send_cb((esp_now_send_cb_t)messageSent); \n\n for(int i=0; i<3; i++){\n memcpy(peerInfo[i].peer_addr, receiverAddress[i], 6);\n peerInfo[i].channel = 0;\n peerInfo[i].encrypt = false;\n\n if (esp_now_add_peer(&peerInfo[i]) != ESP_OK) {\n Serial.println(\"Failed to add peer\");\n return;\n }\n }\n}\n \nvoid loop(){\n char textMsg0[] = \"Hi Receiver 0\";\n memcpy(&myMessage[0].text, textMsg0, sizeof(textMsg0));\n myMessage[0].intVal = 4242;\n myMessage[0].floatVal = 42.42;\n \n char textMsg1[] = \"Ciao Receiver 1\";\n memcpy(&myMessage[1].text, textMsg1, sizeof(textMsg1));\n myMessage[1].intVal = 1234;\n myMessage[1].floatVal = 12.34;\n \n char textMsg2[] = \"Hola Receiver 2\";\n memcpy(&myMessage[2].text, textMsg2, sizeof(textMsg2));\n myMessage[2].intVal = 4711;\n myMessage[2].floatVal = 47.11;\n \n for(int i=0; i<3; i++){\n esp_err_t result = esp_now_send(receiverAddress[i], (uint8_t *) &myMessage[i], sizeof(myMessage[i]));\n if (result != ESP_OK) {\n Serial.print(\"Sending error module \");\n Serial.println(i);\n }\n }\n delay(10000);\n}<\/pre>\nreceiverAddress<\/code>, and if you want to address receiver no. i, then you only have to set the address with receiverAddress[5] = 0x0i<\/code>.<\/p>\nesp_now_send()<\/code> by NULL (written exactly like this, not “0”), the message will be sent to all registered peers.<\/p>\n\nOutput<\/h4>\n\n
![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/03\/output_one_transm_multi_recv_transmitter.png\"){kind=spacer}
<\/a>Receiver<\/h3>\n\n
#include <esp_now.h>\n#include <WiFi.h>\n\ntypedef struct message {\n char text[32];\n int intVal;\n float floatVal;\n} message;\n\nmessage myMessage;\n\nvoid messageReceived(const esp_now_recv_info *info, const uint8_t* incomingData, int len){\n memcpy(&myMessage, incomingData, sizeof(myMessage));\n Serial.print(\"Message: \");\n Serial.println(myMessage.text);\n Serial.print(\"Integer Value: \");\n Serial.println(myMessage.intVal);\n Serial.print(\"Float Value: \");\n Serial.println(myMessage.floatVal);\n Serial.println();\n}\n\nvoid setup(){\n Serial.begin(115200);\n \/\/ delay(1000); \/\/ uncomment if your serial monitor is empty\n WiFi.mode(WIFI_STA);\n \n if (esp_now_init() == ESP_OK) {\n Serial.println(\"ESPNow Init success\");\n }\n else {\n Serial.println(\"ESPNow Init fail\");\n return;\n }\n\n esp_now_register_recv_cb(messageReceived);\n}\n \nvoid loop(){}<\/pre>\nOutput<\/h4>\n\n
![\"Output](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/03\/output_one_transm_multi_recv_receiver.png\")
<\/a>![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/03\/output_transceiver_lead.png\"){kind=spacer}
<\/a>![\"\"](\"https:\/\/wolles-elektronikkiste.de\/wp-content\/uploads\/2023\/03\/output_transceiver_follower.png\"){kind=spacer}
<\/a>