Published July 18, 2023 © CC BY

Arduino Nano ESP32 ESP-NOW tutorial

Arduino Nano ESP32 is just launched, why don't try something interesting by transferring data between two boards using the ESP-NOW protocol?

BeginnerProtip2 hours3,216

Things used in this project

Hardware components

Arduino Nano ESP32

Software apps and online services

Arduino IDE

Story

Something about the Arduino Nano ESP32

The new Arduino Nano ESP32 was just launched, anyway I'll not write about specs of the board since there is already a lot about on the Arduino.cc website. I'll say you only about some things you must know for following this tutorial:

There are 4 default leds on board: there is the yellow one you can drive using the classical LED_BUILTIN definition, and then there are 3 new small Red, Green and Blue leds (it's an RGB led having 3 separate cathodes for each color). Blue is connected on a dedicate GPIO that is not routed to the external board pins, while the Green one is connected to B1 pin and the Red on B0 pin. Since those leds are directly driven from GPIOs, those leds will work in opposite way than the LED_BUILTIN: they will turn on when you tie low the respective GPIO. You can refer to these leds as LED_RED, LED_GREEN and LED_BLUE.
The board pinout is the same of all Arduino Nano family

Arduino Nano ESP32 pinout. Pay attention using B0 and B1 pins since are used for special bootloader modes

Prepare Arduino IDE for the Arduino Nano ESP32

Click on the Board Icon on the left menù bar (or, in the old way, go in the menù Tools > Board > Board Manager) and type ESP32 in the search bar:

2 results will appear: the ESP32 by Arduino is the one supporting this board

Click on the Install button in the ESP32 by Arduino - titled box.

How to program the Arduino Nano ESP32

The Arduino Nano ESP32 has no USB-to-serial bridge but ESP32 native USB port is used, anyway it works like any other Arduino board.

You must only select the Board and the COM port as usually:

This board will create 2 ports: select the COMx one

If board don't respond, you can try manually entering the bootloader mode by doing a double click on the reset button: the green led will glow indicating board is entered in bootloader mode, anyway ESP32 will exit from this modality after tenth of seconds.

ESP-NOW protocol

What is this? I'll report here the original description by Espressif:

ESP-NOW is a wireless communication protocol defined by Espressif, which enables the direct, quick and low-power control of smart devices, without the need of a router. ESP-NOW can work with Wi-Fi and Bluetooth LE, and supports the ESP8266, ESP32, ESP32-S and ESP32-C series of SoCs. It’s widely used in smart-home appliances, remote controlling, sensors, etc.

So it's a simple way letting two or more ESP devices talk each other without using a wi-fi infrastructure.

The physical layer of this protocol is the IEEE 802.11 b/g/n so is the same of the Wi-Fi but can coexists with the Wi-Fi and Bluetooth LE (the only limitation is that the ESP-NOW must use the same channel of the AP),

This protocol was designed for applications not needing a lot of data to be exchanged (the limit is 250 bytes) and so it needs few CPU and memory resources. Using the ESP-NOW protocol you can connect one-to-many or many-to-many devices, pairing up to 20 devices and Encryption is supported too.

You can find more about the ESP-NOW here: https://docs.espressif.com/[...]

What will we do

You'll need 2 Arduino Nano ESP32 : they will exchange some examples data each other, so I called them "Device A" and "Device B" since in this situation makes no sense talk about "master" and "slave" or "client" and "server" and so on: each device act the same and then code is pretty similar for each board.

We will do this!

I made this example with another idea in my mind: to have a remote command for a robot that can receive some telemetry data from robot too, so 2 bi-directional devices. The difference between my idea and this example will be only the intefacing with external components. I added some "text" data example (a char array) since, during my experience, I noticed lot of people had some difficulties handling this kind of data.

Some Preliminary Work

Since this example will make 2 boards exchanging data, but there can be a lot of similar applications in the same environment, every board needs to know with which board to talk and this is achieved by knowing the MAC address of the paired boards. MAC address is unique and so there is no (apparent) possibility to exchange data (this is not really true but we'll made things simplier here!).

A paired device is also called peer

So, first than run the main example, the obtaining of MAC addresses of boards is needed. You can do this running the attached NanoESP32_MacAddress.ino example sketch in each board: this sketch will write continuously the board MAC Address in the Serial Terminal.

After uploaded the sketch, open the serial terminal at 115200 and look at response: you can detach the board for stopping the data flow and then copy/paste the MAC address.

Code explained

The ESP-NOW framework will transfer data as a simple byte sequence (a byte array), so if we want to transfer, as in this example, a char array and a 16-bit number, the received sequence will contain this stuff as an entire array (single bytes in sequence).

Then we must separate single elements from the array: this can be achieved in a lot of ways. In the past, I used to do it in a very obsolete manner by adding commas for separating elements and then extract and convert every piece... but this a very boring task and now there are lot of easier ways.

This time I used structures for storing single elements in a more tidy way and then I applied the memcpy function for transfer the received buffer in the structure (that is treated at low level as a simple byte array).

I defined 2 different structures for data received and data to be transmitted: this is not needed everytime ad depends upon data you want to transfer! If you want to transfer only a numerical value (for example: a temperature), a simple number (maybe a float) can be used instead of a structure

Probably usage of a JSON is not suitable since we said the ESP-NOW can transfer only 250bytes at once, and transferring a byte sequence with data occupying always the same place is more compact.

Now we need a place for storing the informations about the coupled device (the MAC address): a structure having the type esp_now_peer_info_t is used for this, than a function called esp_now_add_peer will be used from the framework for acquiring and store those data.

There are further 2 functions to be defined for using the ESP-NOW data transfer: those are callback functions: this means those procedures will be called automatically by the CPU at a precise event and so there is no need to call them during the code execution (are properly interrupt functions).

So there is a callback will be called at the end of data transmission, and we must defin it as (you can change the names, but parameters must be as written):

void payloadSentCB(const uint8_t *mac_addr, esp_now_send_status_t status)

this function will store the transmission status in the status variable and can assume two values:

ESP_NOW_SEND_SUCCESS
ESP_NOW_SEND_FAIL

I think there is no need to explain. There could be many reasons for having a FAIL response: one can be there is a too short interval between data sending, or simply the device supposed to receive data is not working (not plugged?).

The other callback will be called at the end of data receiving:

void payloadReceivedCB(const uint8_t *mac_addr, const uint8_t *payload, int len)

I called payload the array of data received following some other conventions. As I said, all of the data will stored in this array that will have len bytes in it. For transferring data in my structure I've used the memcpy function using my structure as target.

Notice both callback functions returns the MAC address of the peer: I don't use it but this can be useful in case you build an application when a device will talk to many other devices and you want to understand from which of them you received the response.

Once you defined those 2 callbacks, you need to register them so the ESP-NOW framework will know which function call at the specific event:

// Register callback on payload received
esp_now_register_recv_cb(payloadReceivedCB);
// Register callback on payload sendt
esp_now_register_send_cb(payloadSentCB);

The ESP-NOW framework is initiated using the esp_now_init() function, that will return true in positive (good) case. After a successful init you must couple the devices you want talk to, and this is done using the esp_now_add_peer() function passing the esp_now_peer_info_t structure type we defined earlier.

In the loop I'm only preparing and then sending data. I added some Arduino Nano ESP32 led flashing just for fun and for showing how to use them. The data receiving is entirely managed in the callback.

You'll see the data transfer result by seeing the messages in the serial terminal, so you need to open 2 serial terminals (you can open 2 different Arduino IDE windows).

/*
  ESP-NOW example on Arduino Nano ESP32
  by Giovanni 'Cyb3rn0id' Bernardo
  https://www.linktree.com/cyb3rn0id

  Code for "Device A"

  Obtain the MAC address of Device B first
*/

#include <esp_now.h>
#include "WiFi.h"

// Device B MAC address
uint8_t deviceBAddress[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

// Structure used for sending data
struct structTX
  {
    char text[5]; // we'll send "Ciao" to Device B
    uint16_t count; // we'll send an incremental counter to Device B
  };

// Structure used for receiving data
struct structRX
  {
  char text[6]; // we'll receive "Hello" from Device B
  uint16_t number; // we'll receive a random number from Device B
  };

// I define two structures for sending and receiving data
structTX payloadToSend;
structRX payloadReceived;

// I instantiate a structure that will contain infos about the coupled device (also called 'peer' : the Device B)
// we can define additional esp_now_peer_info_t structures for adding other coupled devices
esp_now_peer_info_t deviceBInfo;

// This is a callback function that will be automatically called at the end of data sending procedure
void payloadSentCB(const uint8_t *mac_addr, esp_now_send_status_t status) 
  {
  if (status == ESP_NOW_SEND_SUCCESS)
    {
    Serial.println("Payload sent to Device B");
    }
  else
    {
    Serial.println("Error sending payload to Device B");
    }
  } // \payloadSentCB

// This is a callback function that will be automatically called when a payload is received
// Note: the first parameter could change in the future with: const esp_now_recv_info_t *recv_info
// https://docs.espressif.com/projects/esp-idf/en/latest/esp32/migration-guides/release-5.x/5.0/networking.html
// see also the example: https://github.com/espressif/esp-idf/blob/4fc2e5cb95/examples/wifi/espnow/main/espnow_example_main.c
void payloadReceivedCB(const uint8_t *mac_addr, const uint8_t *payload, int len) 
  {
  // callback will store the entire payload as a byte sequence in the '*payload' array
  // using memcpy function I'll transfer data from that RAM location to my 'payloadReceived' structure
  // callback stores also the MAC address of the device: this can be useful in case
  // we wanto to connect to more devices and then understand from which one we've received data
  memcpy(&payloadReceived, payload, sizeof(payloadReceived));
  
  // now I can manage received data
  Serial.print("I received ");
  Serial.print(len);
  Serial.println(" bytes of data");

  // content of the 'text' field (first 6 bytes of payload)
  Serial.print("Received text: ");
  // I must use a loop for printing array (text) elements
  for (uint8_t i=0; i<5; i++) Serial.print(payloadReceived.text[i]);
  Serial.println();

  // content of the 'number' field (subsequent 2 bytes of data)
  Serial.print("Received number: ");
  Serial.println(payloadReceived.number);
  } // \payloadReceivedCB

void setup()
  {
  Serial.begin(115200);
  
  // those are the default led on the Arduino Nano ESP32
  pinMode(LED_BUILTIN, OUTPUT);  // the yellow led near the USB connector
  pinMode(LED_RED, OUTPUT);
  pinMode(LED_GREEN, OUTPUT);
  pinMode(LED_BLUE, OUTPUT);

  digitalWrite(LED_BUILTIN, LOW); // yellow led off
  digitalWrite(LED_RED, HIGH); // red led off : yes, the RGB leds will turn off by putting High
  digitalWrite(LED_GREEN, HIGH); // green led off 
  digitalWrite(LED_BLUE, HIGH); // blue led off 

  WiFi.mode(WIFI_MODE_STA);

  // I start to zero the 'count' element of payloadToSend
  // this thing cannot be done outside a function for a data structure
  payloadToSend.count=0;

  // I'll copy the device B address in the peer_addr field of the deviceBInfo structure
  // (we will repeat this for additional devices)
  memcpy(deviceBInfo.peer_addr, deviceBAddress, 6);
  deviceBInfo.channel=0; // when you put 0 here, the default SoftAP channel will be used
  deviceBInfo.encrypt=false; // no encryption will be used
    
  // ESP-NOW start
  if (esp_now_init() != ESP_OK) 
    {
    Serial.println("Error starting ESP-NOW");
    return;
    }
  
  // Add the peer device (Device B)
  // (we will repeat this for additional devices)
  if (esp_now_add_peer(&deviceBInfo) != ESP_OK)
    {
    Serial.println("Error adding the peer device");
    return;
    }
  
  // Register callback on payload received
  esp_now_register_recv_cb(payloadReceivedCB);
  
  // Register callback on payload sendt
  esp_now_register_send_cb(payloadSentCB);
  } // \setup
 
void loop()
  {
  static uint8_t blink=0;

  // Preparing data to sent to Device B
  strcpy(payloadToSend.text, "Ciao"); // set the 'text' field
  payloadToSend.count++; // set the 'count' field
  if (payloadToSend.count>255) payloadToSend.count=0; // counter rollover

  // Sending the payload
  esp_now_send(deviceBAddress, (uint8_t *)&payloadToSend, sizeof(payloadToSend));

  switch(blink)
    {
      case 0:
      digitalWrite(LED_BUILTIN, HIGH); // yellow led on
      digitalWrite(LED_RED, HIGH); // red led off
      digitalWrite(LED_GREEN, HIGH); // green led off
      digitalWrite(LED_BLUE, HIGH); // blue led off
      break;

      case 1:
      digitalWrite(LED_BUILTIN, LOW); // yellow led off
      digitalWrite(LED_RED, LOW); // red led on
      digitalWrite(LED_GREEN, HIGH); // green led off
      digitalWrite(LED_BLUE, HIGH); // blue led off
      break;
      
      case 2:
      digitalWrite(LED_BUILTIN, HIGH); // yellow led on
      digitalWrite(LED_RED, HIGH); // red led off
      digitalWrite(LED_GREEN, LOW); // green led on
      digitalWrite(LED_BLUE, HIGH); // blue led off
      break;

      case 3:
      digitalWrite(LED_BUILTIN, LOW); // yellow led off
      digitalWrite(LED_RED, HIGH); // red led off
      digitalWrite(LED_GREEN, HIGH); // green led off
      digitalWrite(LED_BLUE, LOW); // blue led on
      break;
    } // \switch(blink)

  blink++;
  if (blink>3) blink=0;

  delay(1000);
  } // \loop

/*
  ESP-NOW example on Arduino Nano ESP32
  by Giovanni 'Cyb3rn0id' Bernardo
  https://www.linktree.com/cyb3rn0id

  Code for "Device B"

  Obtain the MAC address of Device A first
*/

#include <esp_now.h>
#include "WiFi.h"

// Device A MAC address
uint8_t deviceAAddress[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00};

// Structure used for receiving data
struct structRX
  {
    char text[5]; // we'll receive "Ciao" from Device A 
    uint16_t count; // we'll receive an incremental counter from Device A
  };

// Structure used for sending data
struct structTX
  {
  char text[6]; // we'll send "Hello" to Device A
  uint16_t number; // we'll send a random number to Device A
  };

// I define two structures for sending and receiving data
structTX payloadToSend;
structRX payloadReceived;

// I instantiate a structure that will contain infos about the coupled device (also called 'peer' : the Device A)
// we can define additional esp_now_peer_info_t structures for adding other coupled devices
esp_now_peer_info_t deviceAInfo;

// This is a callback function that will be automatically called at the end of data sending procedure
void payloadSentCB(const uint8_t *mac_addr, esp_now_send_status_t status) 
  {
  if (status == ESP_NOW_SEND_SUCCESS)
    {
    Serial.println("Payload sent to Device A");
    }
  else
    {
    Serial.println("Error sending payload to Device A");
    }
  } // \payloadSentCB

// This is a callback function that will be automatically called when a payload is received
// Note: the first parameter could change in the future with: const esp_now_recv_info_t *recv_info
// https://docs.espressif.com/projects/esp-idf/en/latest/esp32/migration-guides/release-5.x/5.0/networking.html
// see also the example: https://github.com/espressif/esp-idf/blob/4fc2e5cb95/examples/wifi/espnow/main/espnow_example_main.c
void payloadReceivedCB(const uint8_t *mac_addr, const uint8_t *payload, int len) 
  {
  // callback will store the entire payload as a byte sequence in the '*payload' array
  // using memcpy function I'll transfer data from that RAM location to my 'payloadReceived' structure
  // callback stores also the MAC address of the device: this can be useful in case
  // we wanto to connect to more devices and then understand from which one we've received data
  memcpy(&payloadReceived, payload, sizeof(payloadReceived));
  
  // now I can manage received data
  Serial.print("I received ");
  Serial.print(len);
  Serial.println(" bytes of data");

  // content of the 'text' field (first 5 bytes of payload)
  Serial.print("Received text: ");
  // I must use a loop for printing array (text) elements
  for (uint8_t i=0; i<4; i++) Serial.print(payloadReceived.text[i]);
  Serial.println();

  // content of the 'count' field (subsequent 2 bytes of data)
  Serial.print("Received count: ");
  Serial.println(payloadReceived.count);
  } // \payloadReceivedCB

void setup()
  {
  Serial.begin(115200);
  
  // those are the default led on the Arduino Nano ESP32
  pinMode(LED_BUILTIN, OUTPUT);  // the yellow led near the USB connector
  pinMode(LED_RED, OUTPUT);
  pinMode(LED_GREEN, OUTPUT);
  pinMode(LED_BLUE, OUTPUT);

  digitalWrite(LED_BUILTIN, LOW); // yellow led off
  digitalWrite(LED_RED, HIGH); // red led off : yes, the RGB leds will turn off by putting High
  digitalWrite(LED_GREEN, HIGH); // green led off 
  digitalWrite(LED_BLUE, HIGH); // blue led off 

  WiFi.mode(WIFI_MODE_STA);

  // I start to zero the 'count' element of payloadToSend
  // this thing cannot be done outside a function for a data structure
  payloadToSend.number=0;

  // random number generator init using the analog read as seed
  randomSeed(analogRead(0));
  
  // I'll copy the device A address in the peer_addr field of the deviceAInfo structure
  // (we will repeat this for additional devices)
  memcpy(deviceAInfo.peer_addr, deviceAAddress, 6);
  deviceAInfo.channel=0; // when you put 0 here, the default SoftAP channel will be used
  deviceAInfo.encrypt=false; // no encryption will be used
    
  // ESP-NOW start
  if (esp_now_init() != ESP_OK) 
    {
    Serial.println("Error starting ESP-NOW");
    return;
    }
  
  // Add the peer device (Device A)
  // (we will repeat this for additional devices)
  if (esp_now_add_peer(&deviceAInfo) != ESP_OK)
    {
    Serial.println("Error adding the peer device");
    return;
    }
  
  // Register callback on payload received
  esp_now_register_recv_cb(payloadReceivedCB);
  
  // Register callback on payload sendt
  esp_now_register_send_cb(payloadSentCB);
  } // \setup
 
 
void loop()
  {
  static uint8_t blink=0;

  // Preparing data to sent to Device A
  strcpy(payloadToSend.text, "Hello"); // set the 'text' field 
  payloadToSend.number=random(65536); // set the 'number' field to a number from o to 65535

  // Sending the payload
  esp_now_send(deviceAAddress, (uint8_t *)&payloadToSend, sizeof(payloadToSend));
  
  switch(blink)
    {
      case 0:
      digitalWrite(LED_BUILTIN, HIGH); // yellow led on
      digitalWrite(LED_RED, HIGH); // red led off
      digitalWrite(LED_GREEN, HIGH); // green led off
      digitalWrite(LED_BLUE, HIGH); // blue led off
      break;

      case 1:
      digitalWrite(LED_BUILTIN, LOW); // yellow led off
      digitalWrite(LED_RED, LOW); // red led on
      digitalWrite(LED_GREEN, HIGH); // green led off
      digitalWrite(LED_BLUE, HIGH); // blue led off
      break;
      
      case 2:
      digitalWrite(LED_BUILTIN, HIGH); // yellow led on
      digitalWrite(LED_RED, HIGH); // red led off
      digitalWrite(LED_GREEN, LOW); // green led on
      digitalWrite(LED_BLUE, HIGH); // blue led off
      break;

      case 3:
      digitalWrite(LED_BUILTIN, LOW); // yellow led off
      digitalWrite(LED_RED, HIGH); // red led off
      digitalWrite(LED_GREEN, HIGH); // green led off
      digitalWrite(LED_BLUE, LOW); // blue led on
      break;
    } // \switch(blink)

  blink++;
  if (blink>3) blink=0;
  delay(1000);
  } // \loop

Credits

Giovanni '@Cyb3rn0id' Bernardo

8 projects • 46 followers

Technical Writer, Maker. Addicted to retrocomputing and making stuff with microcontrollers & 3D-printing. Available for technical reviews.

Contact

Comments

Please log in or sign up to comment.

Arduino Nano ESP32 ESP-NOW tutorial

Things used in this project

Hardware components

Software apps and online services

Story

Something about the Arduino Nano ESP32

Prepare Arduino IDE for the Arduino Nano ESP32

How to program the Arduino Nano ESP32

ESP-NOW protocol

What will we do

Some Preliminary Work

Code explained

Code

NanoESP32_MacAddress.ino

Arduino Nano ESP32 - ESP-NOW example - Device A

Arduino Nano ESP32 - ESP-NOW example - Device B

Credits

Giovanni '@Cyb3rn0id' Bernardo

Comments

Embed the widget on your own site

Arduino Nano ESP32 ESP-NOW tutorial

Arduino Nano ESP32 ESP-NOW tutorial

Things used in this project

Hardware components

Software apps and online services

Story

Something about the Arduino Nano ESP32

Prepare Arduino IDE for the Arduino Nano ESP32

How to program the Arduino Nano ESP32

ESP-NOW protocol

What will we do

Some Preliminary Work

Code explained

Code

NanoESP32_MacAddress.ino

Arduino Nano ESP32 - ESP-NOW example - Device A

Arduino Nano ESP32 - ESP-NOW example - Device B

Credits

Giovanni '@Cyb3rn0id' Bernardo

Comments

Related channels and tags