ESP-NOW is a great protocol when it comes to low latency applications because the accesspoint-less communication enables ultra fast message transport. The delay between the button press and the receiving of the sent message is as low as 200ms. This is great for smart home solutions where you immediately see the result (light/outlet goes on).
When using ESP-NOW with the Picoclicks you have to use an ESP based bridge which converts these messages into ones of another protocol. In the most cases an ESP-NOW to MQTT bridge is the best way to go with. Before talking about the bridge let's have a look at the senders code.
ESP-NOW sender
Here, the sender is the IOT-button itself. Once the Picoclick is pressed a message will be filled with informations and sent to its destination. Afterwards the Picoclick will deactivate itself again. A functional code can look like this:
#include <Arduino.h>
#include <WiFi.h>
#include <esp_now.h>
#include <FastLED.h>
#include "config.h"
// ESPNOW packet structure.
// Can be modified but should be the same on the receivers side.
typedef struct struct_message {
int id;
int value;
int battery_level;
int single_tap_duration;
} struct_message;
typedef struct struct_message_recv {
bool answer;
} struct_message_recv;
struct_message data;
struct_message_recv data_recv;
#define ESPNOW_ID 8888 // Random 4 digit number
uint8_t receiver_address[] = {0x10, 0x91, 0xA8, 0x32, 0x7B, 0x70}; // Mac address of the receiver.
bool espnow_answer_received = false;
void on_data_recv(const uint8_t * mac, const uint8_t *incomingData, int len) {
memcpy(&data_recv, incomingData, sizeof(data_recv));
espnow_answer_received = true;
}
void setup(){
pinMode(BUTTON_PIN, INPUT);
pinMode(ADC_ENABLE_PIN, OUTPUT);
pinMode(ADC_PIN, INPUT);
analogReadResolution(12);
digitalWrite(ADC_ENABLE_PIN, HIGH);
btStop();
WiFi.mode(WIFI_STA);
FastLED.addLeds<APA102, APA102_SDI_PIN, APA102_CLK_PIN, BGR>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);
FastLED.setBrightness(160);
delay(50);
if(esp_now_init() != ESP_OK) {
printf("Error initializing ESP-NOW\r\n");
return;
}
set_fastled(CRGB::Blue);
esp_now_peer_info_t peerInfo;
memcpy(peerInfo.peer_addr, receiver_address, 6);
peerInfo.channel = 0;
peerInfo.encrypt = false;
if(esp_now_add_peer(&peerInfo) != ESP_OK){
printf("Failed to add peer\r\n");
return;
}
esp_now_register_recv_cb(on_data_recv);
// Fill ESPNOW struct with values.
data.id = ESPNOW_ID;
data.value = 1;
data.battery_level = int(get_battery_voltage());
data.single_tap_duration = 1000;
esp_now_send(receiver_address, (uint8_t *) &data, sizeof(data));
// wait on espnow answer
unsigned long t_wait_answer_start = millis();
while(!espnow_answer_received && millis() <= t_wait_answer_start + 300){
delayMicroseconds(1);
}
// This will reduce power consumption.
WiFi.mode(WIFI_OFF);
setCpuFrequencyMhz(10);
CRGB col = espnow_answer_received ? CRGB::Green : CRGB::Red;
set_fastled(col);
delay(500);
int counter = 0;
while(digitalRead(BUTTON_PIN) == 1){
set_fastled(counter % 2 == 0 ? CRGB::Blue : CRGB::Black, (counter+1) % 2 == 0 ? CRGB::Blue : CRGB::Black);
delay(50);
counter++;
}
set_fastled(CRGB::Blue);
delay(500);
// Add a loop which will wait as long as the button is pressed before entering deepsleep.
// Once in deepsleep the USB console is not available anymore.
esp_deep_sleep_start();
}
void loop() {
}
The code above does one more thing which ensures that the message delivery was succesfull. After it sends out the initial message with all the informations it waits for an answer form the receiver device for 300ms:
The espnow_answer_received flag will be set to true if the receive callback is executed, so once a message is received at the sender. If this isn't the case the while loop will be escaped after 300ms. To give the user a feedback the LEDs will light up in green or red depending on the receiving state.
CRGB col = espnow_answer_received ? CRGB::Green : CRGB::Red;
ESP-NOW receiver
The receiver can be any ESP based device but in this case I'm using a Picoclick as well. Once the button is pressed the receiver is powered on and will wait for a message from the sender. While waiting the LEDs will cycle through all colors.
Once a message is received the send_answer() function will be called. It adds an ESP-NOW peer with the received MAC address of the sender device, sends the answer message and will delete the peer afterwards.
As the receiver devices turns its LEDs green just like the sender, both devices will light up in green at almost the same time.
The following code is a ESP-NOW to MQTT bridge on a single device. To make things work, you need to change the channel of your router to the fixed channel 1. For further informations for that or the Home Assistant integration you should check out the video.
To run this code you need to add your WiFi credentials in the top section and your MQTT credentials in the reconnect function.
The code forwards all ESP-NOW messages as MQTT messages to be integrated into Home Assistant. The topic is generated by the identifier "node" and the four digit "ESPNOW_ID". A typical topic can look like this: home/node1234/value
