First Working ESP Now Example

- All Controllers Send each other broadcast messages

main/main.c

@@ -10,13 +10,29 @@
 #include "freertos/FreeRTOS.h"
 #include "freertos/task.h"
 #include "nvs_flash.h"
+#include <assert.h>
 #include <stdio.h>
+#include <string.h>
+
+#include "main.h"
 
 #define ESPNOW_WIFI_MODE WIFI_MODE_AP
 #define ESPNOW_WIFI_IF ESP_IF_WIFI_AP
+#define ESPNOW_MAXDELAY 512
+// default CONFIG values from menuconfig
 #define CONFIG_ESPNOW_CHANNEL 1
+#define CONFIG_ESPNOW_PMK "pmk1234567890123"
+#define CONFIG_ESPNOW_SEND_COUNT 100
+#define CONFIG_ESPNOW_SEND_DELAY 1000
+#define CONFIG_ESPNOW_SEND_LEN 10
+#define CONFIG_ESPNOW_LMK "lmk1234567890123"
 
 const char *tag = "Exam";
+static QueueHandle_t s_example_espnow_queue;
+static uint8_t s_example_broadcast_mac[ESP_NOW_ETH_ALEN] = {0xFF, 0xFF, 0xFF,
+                                                            0xFF, 0xFF, 0xFF};
+static uint16_t s_example_espnow_seq[2] = {0, 0};
+static void example_espnow_deinit(example_espnow_send_param_t *send_param);
 
 void wifi_init(void) {
   esp_err_t ret = nvs_flash_init();
@@ -42,13 +58,260 @@ void wifi_init(void) {
                           WIFI_PROTOCOL_11N | WIFI_PROTOCOL_LR));
 }
 
-static esp_err_t example_espnow_init(void)
+static void example_espnow_deinit(example_espnow_send_param_t *send_param) {
-{
+  free(send_param->buffer);
+  free(send_param);
+  vSemaphoreDelete(s_example_espnow_queue);
+  esp_now_deinit();
+}
+
+void example_espnow_data_prepare(example_espnow_send_param_t *send_param) {
+  example_espnow_data_t *buf = (example_espnow_data_t *)send_param->buffer;
+
+  assert(send_param->len >= sizeof(example_espnow_data_t));
+
+  buf->type = IS_BROADCAST_ADDR(send_param->dest_mac)
+                  ? EXAMPLE_ESPNOW_DATA_BROADCAST
+                  : EXAMPLE_ESPNOW_DATA_UNICAST;
+  buf->state = send_param->state;
+  buf->seq_num = s_example_espnow_seq[buf->type]++;
+  buf->crc = 0;
+  buf->magic = send_param->magic;
+  /* Fill all remaining bytes after the data with random values */
+  esp_fill_random(buf->payload,
+                  send_param->len - sizeof(example_espnow_data_t));
+  buf->crc = esp_crc16_le(UINT16_MAX, (uint8_t const *)buf, send_param->len);
+}
+
+static void example_espnow_send_cb(const uint8_t *mac_addr,
+                                   esp_now_send_status_t status) {
+  example_espnow_event_t evt;
+  example_espnow_event_send_cb_t *send_cb = &evt.info.send_cb;
+
+  if (mac_addr == NULL) {
+    ESP_LOGE(tag, "Send cb arg error");
+    return;
+  }
+
+  evt.id = EXAMPLE_ESPNOW_SEND_CB;
+  memcpy(send_cb->mac_addr, mac_addr, ESP_NOW_ETH_ALEN);
+  send_cb->status = status;
+  if (xQueueSend(s_example_espnow_queue, &evt, ESPNOW_MAXDELAY) != pdTRUE) {
+    ESP_LOGW(tag, "Send send queue fail");
+  }
+}
+
+static void example_espnow_recv_cb(const esp_now_recv_info_t *recv_info,
+                                   const uint8_t *data, int len) {
+  example_espnow_event_t evt;
+  example_espnow_event_recv_cb_t *recv_cb = &evt.info.recv_cb;
+  uint8_t *mac_addr = recv_info->src_addr;
+  uint8_t *des_addr = recv_info->des_addr;
+
+  if (mac_addr == NULL || data == NULL || len <= 0) {
+    ESP_LOGE(tag, "Receive cb arg error");
+    return;
+  }
+
+  if (IS_BROADCAST_ADDR(des_addr)) {
+    /* If added a peer with encryption before, the receive packets may be
+     * encrypted as peer-to-peer message or unencrypted over the broadcast
+     * channel. Users can check the destination address to distinguish it.
+     */
+    ESP_LOGD(tag, "Receive broadcast ESPNOW data");
+  } else {
+    ESP_LOGD(tag, "Receive unicast ESPNOW data");
+  }
+
+  evt.id = EXAMPLE_ESPNOW_RECV_CB;
+  memcpy(recv_cb->mac_addr, mac_addr, ESP_NOW_ETH_ALEN);
+  recv_cb->data = malloc(len);
+  if (recv_cb->data == NULL) {
+    ESP_LOGE(tag, "Malloc receive data fail");
+    return;
+  }
+  memcpy(recv_cb->data, data, len);
+  recv_cb->data_len = len;
+  if (xQueueSend(s_example_espnow_queue, &evt, ESPNOW_MAXDELAY) != pdTRUE) {
+    ESP_LOGW(tag, "Send receive queue fail");
+    free(recv_cb->data);
+  }
+}
+
+int example_espnow_data_parse(uint8_t *data, uint16_t data_len, uint8_t *state,
+                              uint16_t *seq, uint32_t *magic) {
+  example_espnow_data_t *buf = (example_espnow_data_t *)data;
+  uint16_t crc, crc_cal = 0;
+
+  if (data_len < sizeof(example_espnow_data_t)) {
+    ESP_LOGE(tag, "Receive ESPNOW data too short, len:%d", data_len);
+    return -1;
+  }
+
+  *state = buf->state;
+  *seq = buf->seq_num;
+  *magic = buf->magic;
+  crc = buf->crc;
+  buf->crc = 0;
+  crc_cal = esp_crc16_le(UINT16_MAX, (uint8_t const *)buf, data_len);
+
+  if (crc_cal == crc) {
+    return buf->type;
+  }
+
+  return -1;
+}
+
+static void example_espnow_task(void *pvParameter) {
+  example_espnow_event_t evt;
+  uint8_t recv_state = 0;
+  uint16_t recv_seq = 0;
+  uint32_t recv_magic = 0;
+  bool is_broadcast = false;
+  int ret;
+
+  vTaskDelay(5000 / portTICK_PERIOD_MS);
+  ESP_LOGI(tag, "Start sending broadcast data");
+
+  /* Start sending broadcast ESPNOW data. */
+  example_espnow_send_param_t *send_param =
+      (example_espnow_send_param_t *)pvParameter;
+  if (esp_now_send(send_param->dest_mac, send_param->buffer, send_param->len) !=
+      ESP_OK) {
+    ESP_LOGE(tag, "Send error");
+    example_espnow_deinit(send_param);
+    vTaskDelete(NULL);
+  }
+
+  while (xQueueReceive(s_example_espnow_queue, &evt, portMAX_DELAY) == pdTRUE) {
+    switch (evt.id) {
+    case EXAMPLE_ESPNOW_SEND_CB: {
+      example_espnow_event_send_cb_t *send_cb = &evt.info.send_cb;
+      is_broadcast = IS_BROADCAST_ADDR(send_cb->mac_addr);
+
+      ESP_LOGD(tag, "Send data to " MACSTR ", status1: %d",
+               MAC2STR(send_cb->mac_addr), send_cb->status);
+
+      if (is_broadcast && (send_param->broadcast == false)) {
+        break;
+      }
+
+      if (!is_broadcast) {
+        send_param->count--;
+        if (send_param->count == 0) {
+          ESP_LOGI(tag, "Send done");
+          example_espnow_deinit(send_param);
+          vTaskDelete(NULL);
+        }
+      }
+
+      /* Delay a while before sending the next data. */
+      if (send_param->delay > 0) {
+        vTaskDelay(send_param->delay / portTICK_PERIOD_MS);
+      }
+
+      ESP_LOGI(tag, "send data to " MACSTR "", MAC2STR(send_cb->mac_addr));
+
+      memcpy(send_param->dest_mac, send_cb->mac_addr, ESP_NOW_ETH_ALEN);
+      example_espnow_data_prepare(send_param);
+
+      /* Send the next data after the previous data is sent. */
+      if (esp_now_send(send_param->dest_mac, send_param->buffer,
+                       send_param->len) != ESP_OK) {
+        ESP_LOGE(tag, "Send error");
+        example_espnow_deinit(send_param);
+        vTaskDelete(NULL);
+      }
+      break;
+    }
+    case EXAMPLE_ESPNOW_RECV_CB: {
+      example_espnow_event_recv_cb_t *recv_cb = &evt.info.recv_cb;
+
+      ret = example_espnow_data_parse(recv_cb->data, recv_cb->data_len,
+                                      &recv_state, &recv_seq, &recv_magic);
+      free(recv_cb->data);
+      if (ret == EXAMPLE_ESPNOW_DATA_BROADCAST) {
+        ESP_LOGI(tag, "Receive %dth broadcast data from: " MACSTR ", len: %d",
+                 recv_seq, MAC2STR(recv_cb->mac_addr), recv_cb->data_len);
+
+        /* If MAC address does not exist in peer list, add it to peer list. */
+        if (esp_now_is_peer_exist(recv_cb->mac_addr) == false) {
+          esp_now_peer_info_t *peer = malloc(sizeof(esp_now_peer_info_t));
+          if (peer == NULL) {
+            ESP_LOGE(tag, "Malloc peer information fail");
+            example_espnow_deinit(send_param);
+            vTaskDelete(NULL);
+          }
+          memset(peer, 0, sizeof(esp_now_peer_info_t));
+          peer->channel = CONFIG_ESPNOW_CHANNEL;
+          peer->ifidx = ESPNOW_WIFI_IF;
+          peer->encrypt = true;
+          memcpy(peer->lmk, CONFIG_ESPNOW_LMK, ESP_NOW_KEY_LEN);
+          memcpy(peer->peer_addr, recv_cb->mac_addr, ESP_NOW_ETH_ALEN);
+          ESP_ERROR_CHECK(esp_now_add_peer(peer));
+          free(peer);
+        }
+
+        /* Indicates that the device has received broadcast ESPNOW data. */
+        if (send_param->state == 0) {
+          send_param->state = 1;
+        }
+
+        /* If receive broadcast ESPNOW data which indicates that the other
+         * device has received broadcast ESPNOW data and the local magic number
+         * is bigger than that in the received broadcast ESPNOW data, stop
+         * sending broadcast ESPNOW data and start sending unicast ESPNOW data.
+         */
+        if (recv_state == 1) {
+          /* The device which has the bigger magic number sends ESPNOW data, the
+           * other one receives ESPNOW data.
+           */
+          if (send_param->unicast == false && send_param->magic >= recv_magic) {
+            ESP_LOGI(tag, "Start sending unicast data");
+            ESP_LOGI(tag, "send data to " MACSTR "",
+                     MAC2STR(recv_cb->mac_addr));
+
+            /* Start sending unicast ESPNOW data. */
+            memcpy(send_param->dest_mac, recv_cb->mac_addr, ESP_NOW_ETH_ALEN);
+            example_espnow_data_prepare(send_param);
+            if (esp_now_send(send_param->dest_mac, send_param->buffer,
+                             send_param->len) != ESP_OK) {
+              ESP_LOGE(tag, "Send error");
+              example_espnow_deinit(send_param);
+              vTaskDelete(NULL);
+            } else {
+              send_param->broadcast = false;
+              send_param->unicast = true;
+            }
+          }
+        }
+      } else if (ret == EXAMPLE_ESPNOW_DATA_UNICAST) {
+        ESP_LOGI(tag, "Receive %dth unicast data from: " MACSTR ", len: %d",
+                 recv_seq, MAC2STR(recv_cb->mac_addr), recv_cb->data_len);
+
+        /* If receive unicast ESPNOW data, also stop sending broadcast ESPNOW
+         * data. */
+        send_param->broadcast = false;
+      } else {
+        ESP_LOGI(tag, "Receive error data from: " MACSTR "",
+                 MAC2STR(recv_cb->mac_addr));
+      }
+      break;
+    }
+    default:
+      ESP_LOGE(tag, "Callback type error: %d", evt.id);
+      break;
+    }
+  }
+}
+
+static esp_err_t example_espnow_init(void) {
   example_espnow_send_param_t *send_param;
 
-    s_example_espnow_queue = xQueueCreate(ESPNOW_QUEUE_SIZE, sizeof(example_espnow_event_t));
+  s_example_espnow_queue =
+      xQueueCreate(ESPNOW_QUEUE_SIZE, sizeof(example_espnow_event_t));
   if (s_example_espnow_queue == NULL) {
-        ESP_LOGE(TAG, "Create mutex fail");
+    ESP_LOGE(tag, "Create mutex fail");
     return ESP_FAIL;
   }
 
@@ -58,7 +321,8 @@ static esp_err_t example_espnow_init(void)
   ESP_ERROR_CHECK(esp_now_register_recv_cb(example_espnow_recv_cb));
 #if CONFIG_ESPNOW_ENABLE_POWER_SAVE
   ESP_ERROR_CHECK(esp_now_set_wake_window(CONFIG_ESPNOW_WAKE_WINDOW));
-    ESP_ERROR_CHECK( esp_wifi_connectionless_module_set_wake_interval(CONFIG_ESPNOW_WAKE_INTERVAL) );
+  ESP_ERROR_CHECK(esp_wifi_connectionless_module_set_wake_interval(
+      CONFIG_ESPNOW_WAKE_INTERVAL));
 #endif
   /* Set primary master key. */
   ESP_ERROR_CHECK(esp_now_set_pmk((uint8_t *)CONFIG_ESPNOW_PMK));
@@ -66,7 +330,7 @@ static esp_err_t example_espnow_init(void)
   /* Add broadcast peer information to peer list. */
   esp_now_peer_info_t *peer = malloc(sizeof(esp_now_peer_info_t));
   if (peer == NULL) {
-        ESP_LOGE(TAG, "Malloc peer information fail");
+    ESP_LOGE(tag, "Malloc peer information fail");
     vSemaphoreDelete(s_example_espnow_queue);
     esp_now_deinit();
     return ESP_FAIL;
@@ -82,7 +346,7 @@ static esp_err_t example_espnow_init(void)
   /* Initialize sending parameters. */
   send_param = malloc(sizeof(example_espnow_send_param_t));
   if (send_param == NULL) {
-        ESP_LOGE(TAG, "Malloc send parameter fail");
+    ESP_LOGE(tag, "Malloc send parameter fail");
     vSemaphoreDelete(s_example_espnow_queue);
     esp_now_deinit();
     return ESP_FAIL;
@@ -97,7 +361,7 @@ static esp_err_t example_espnow_init(void)
   send_param->len = CONFIG_ESPNOW_SEND_LEN;
   send_param->buffer = malloc(CONFIG_ESPNOW_SEND_LEN);
   if (send_param->buffer == NULL) {
-        ESP_LOGE(TAG, "Malloc send buffer fail");
+    ESP_LOGE(tag, "Malloc send buffer fail");
     free(send_param);
     vSemaphoreDelete(s_example_espnow_queue);
     esp_now_deinit();
@@ -106,7 +370,8 @@ static esp_err_t example_espnow_init(void)
   memcpy(send_param->dest_mac, s_example_broadcast_mac, ESP_NOW_ETH_ALEN);
   example_espnow_data_prepare(send_param);
 
-    xTaskCreate(example_espnow_task, "example_espnow_task", 2048, send_param, 4, NULL);
+  xTaskCreate(example_espnow_task, "example_espnow_task", 2048, send_param, 4,
+              NULL);
 
   return ESP_OK;
 }
@@ -116,13 +381,5 @@ void app_main(void) {
   gpio_set_direction(2, GPIO_MODE_OUTPUT);
 
   wifi_init();
-
+  example_espnow_init();
-  while (1) {
-    ESP_LOGI(tag, "LED AN");
-    gpio_set_level(2, 1);
-    vTaskDelay(pdMS_TO_TICKS(1000));
-    ESP_LOGI(tag, "LED AUS");
-    gpio_set_level(2, 0);
-    vTaskDelay(pdMS_TO_TICKS(1000));
-  }
 }

main/main.h

@@ -0,0 +1,61 @@
+#ifndef MAIN_H
+#define MAIN_H
+
+#define ESPNOW_QUEUE_SIZE 6
+#define IS_BROADCAST_ADDR(addr) (memcmp(addr, s_example_broadcast_mac, ESP_NOW_ETH_ALEN) == 0)
+
+typedef enum {
+  EXAMPLE_ESPNOW_SEND_CB,
+  EXAMPLE_ESPNOW_RECV_CB,
+} example_espnow_event_id_t;
+
+typedef struct {
+  uint8_t mac_addr[ESP_NOW_ETH_ALEN];
+  esp_now_send_status_t status;
+} example_espnow_event_send_cb_t;
+
+typedef struct {
+  uint8_t mac_addr[ESP_NOW_ETH_ALEN];
+  uint8_t *data;
+  int data_len;
+} example_espnow_event_recv_cb_t;
+
+typedef union {
+  example_espnow_event_send_cb_t send_cb;
+  example_espnow_event_recv_cb_t recv_cb;
+} example_espnow_event_info_t;
+
+typedef struct {
+  example_espnow_event_id_t id;
+  example_espnow_event_info_t info;
+} example_espnow_event_t;
+
+enum {
+    EXAMPLE_ESPNOW_DATA_BROADCAST,
+    EXAMPLE_ESPNOW_DATA_UNICAST,
+    EXAMPLE_ESPNOW_DATA_MAX,
+};
+/* User defined field of ESPNOW data in this example. */
+typedef struct {
+    uint8_t type;                         //Broadcast or unicast ESPNOW data.
+    uint8_t state;                        //Indicate that if has received broadcast ESPNOW data or not.
+    uint16_t seq_num;                     //Sequence number of ESPNOW data.
+    uint16_t crc;                         //CRC16 value of ESPNOW data.
+    uint32_t magic;                       //Magic number which is used to determine which device to send unicast ESPNOW data.
+    uint8_t payload[0];                   //Real payload of ESPNOW data.
+} __attribute__((packed)) example_espnow_data_t;
+
+typedef struct {
+  bool unicast;   // Send unicast ESPNOW data.
+  bool broadcast; // Send broadcast ESPNOW data.
+  uint8_t state;  // Indicate that if has received broadcast ESPNOW data or not.
+  uint32_t magic; // Magic number which is used to determine which device to
+                  // send unicast ESPNOW data.
+  uint16_t count;  // Total count of unicast ESPNOW data to be sent.
+  uint16_t delay;  // Delay between sending two ESPNOW data, unit: ms.
+  int len;         // Length of ESPNOW data to be sent, unit: byte.
+  uint8_t *buffer; // Buffer pointing to ESPNOW data.
+  uint8_t dest_mac[ESP_NOW_ETH_ALEN]; // MAC address of destination device.
+} example_espnow_send_param_t;
+
+#endif