skruecken/espNowTest
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactored in multiple files.

Browse Source 
- isMaster variable should not be set like this but now it is working
- TODO: Rework it in a modular way!
- shared.h is not very pretty but works that way
- There should be a universal logger with the tag
This commit is contained in:
simon 2024-10-04 16:11:16 +02:00
parent b6fbe05312
commit 44cd594d96
5 changed files with 508 additions and 456 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

393
main/espnow_handler.c Normal file
View File

@ -0,0 +1,393 @@
#include "driver/gpio.h"
#include "esp_crc.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_mac.h"
#include "esp_netif.h"
#include "esp_now.h"
#include "esp_random.h"
#include "esp_wifi.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "hal/gpio_types.h"
#include "nvs_flash.h"
#include "portmacro.h"
#include <assert.h>
#include <stdbool.h>
#include <stdio.h>
#include <string.h>
#include "espnow_handler.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 250
#define CONFIG_ESPNOW_LMK "lmk1234567890123"
static QueueHandle_t s_espnow_queue;
static uint8_t s_broadcast_mac[ESP_NOW_ETH_ALEN] = {0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF};
static uint16_t s_espnow_seq[2] = {0, 0};
void setIsMaster(bool status) {
isMaster = status;
}
void wifi_init(void) {
esp_err_t ret = nvs_flash_init();
if (ret == ESP_ERR_NVS_NO_FREE_PAGES ||
ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
// NVS partition was truncated and needs to be erased
ESP_ERROR_CHECK(nvs_flash_erase());
ret = nvs_flash_init();
}
ESP_ERROR_CHECK(ret);
ESP_ERROR_CHECK(esp_netif_init());
ESP_ERROR_CHECK(esp_event_loop_create_default());
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
ESP_ERROR_CHECK(esp_wifi_init(&cfg));
ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));
ESP_ERROR_CHECK(esp_wifi_set_mode(ESPNOW_WIFI_MODE));
ESP_ERROR_CHECK(esp_wifi_start());
ESP_ERROR_CHECK(
esp_wifi_set_channel(CONFIG_ESPNOW_CHANNEL, WIFI_SECOND_CHAN_NONE));
ESP_ERROR_CHECK(esp_wifi_set_protocol(
ESPNOW_WIFI_IF, WIFI_PROTOCOL_11B | WIFI_PROTOCOL_11G |
WIFI_PROTOCOL_11N | WIFI_PROTOCOL_LR));
}
void espnow_deinit(espnow_send_param_t *send_param) {
free(send_param->buffer);
free(send_param);
vSemaphoreDelete(s_espnow_queue);
esp_now_deinit();
}
void espnow_data_prepare(espnow_send_param_t *send_param) {
espnow_data_t *buf = (espnow_data_t *)send_param->buffer;
ESP_LOGI(tag, "Example_Data_SIZE: %u, send_param_len: %d\n",
sizeof(espnow_data_t), send_param->len);
assert(send_param->len >= sizeof(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 = 0; //s_espnow_seq[buf->type]++;
buf->crc = 0;
buf->magic = send_param->magic;
buf->unionPage = UNION_STATUS;
buf->realPayload.status.isMaster = isMaster;
buf->crc = esp_crc16_le(UINT16_MAX, (uint8_t const *)buf, send_param->len);
}
void espnow_send_cb(const uint8_t *mac_addr,
esp_now_send_status_t status) {
espnow_event_t evt;
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_espnow_queue, &evt, ESPNOW_MAXDELAY) != pdTRUE) {
ESP_LOGW(tag, "Send send queue fail");
}
}
void espnow_recv_cb(const esp_now_recv_info_t *recv_info,
const uint8_t *data, int len) {
espnow_event_t evt;
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_espnow_queue, &evt, ESPNOW_MAXDELAY) != pdTRUE) {
ESP_LOGW(tag, "Send receive queue fail");
free(recv_cb->data);
}
}
int espnow_data_parse(uint8_t *data, uint16_t data_len, uint8_t *state,
uint16_t *seq, uint32_t *magic) {
espnow_data_t *buf = (espnow_data_t *)data;
uint16_t crc, crc_cal = 0;
if (data_len < sizeof(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);
switch (buf->unionPage) {
case UNION_STATUS:
if (buf->realPayload.status.isMaster) {
ESP_LOGI(tag, "Recived Data from Master");
} else {
ESP_LOGI(tag, "Recived Data from Slave");
}
break;
case UNION_SENSORDATA:
ESP_LOGI(tag, "Yeah Daten %d", buf->realPayload.sensorData.dataPoint);
break;
}
if (crc_cal == crc) {
return buf->type;
}
return -1;
}
esp_err_t espnow_init(void) {
espnow_send_param_t *send_param;
s_espnow_queue = xQueueCreate(ESPNOW_QUEUE_SIZE, sizeof(espnow_event_t));
if (s_espnow_queue == NULL) {
ESP_LOGE(tag, "Create mutex fail");
return ESP_FAIL;
}
/* Initialize ESPNOW and register sending and receiving callback function. */
ESP_ERROR_CHECK(esp_now_init());
ESP_ERROR_CHECK(esp_now_register_send_cb(espnow_send_cb));
ESP_ERROR_CHECK(esp_now_register_recv_cb(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));
#endif
/* Set primary master key. */
ESP_ERROR_CHECK(esp_now_set_pmk((uint8_t *)CONFIG_ESPNOW_PMK));
/* 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");
vSemaphoreDelete(s_espnow_queue);
esp_now_deinit();
return ESP_FAIL;
}
memset(peer, 0, sizeof(esp_now_peer_info_t));
peer->channel = CONFIG_ESPNOW_CHANNEL;
peer->ifidx = ESPNOW_WIFI_IF;
peer->encrypt = false;
memcpy(peer->peer_addr, s_broadcast_mac, ESP_NOW_ETH_ALEN);
ESP_ERROR_CHECK(esp_now_add_peer(peer));
free(peer);
/* Initialize sending parameters. */
send_param = malloc(sizeof(espnow_send_param_t));
if (send_param == NULL) {
ESP_LOGE(tag, "Malloc send parameter fail");
vSemaphoreDelete(s_espnow_queue);
esp_now_deinit();
return ESP_FAIL;
}
memset(send_param, 0, sizeof(espnow_send_param_t));
send_param->unicast = false;
send_param->broadcast = true;
send_param->state = 0;
send_param->magic = esp_random();
send_param->count = CONFIG_ESPNOW_SEND_COUNT;
send_param->delay = CONFIG_ESPNOW_SEND_DELAY;
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");
free(send_param);
vSemaphoreDelete(s_espnow_queue);
esp_now_deinit();
return ESP_FAIL;
}
memcpy(send_param->dest_mac, s_broadcast_mac, ESP_NOW_ETH_ALEN);
espnow_data_prepare(send_param);
xTaskCreate(espnow_task, "espnow_task", 2048, send_param, 4, NULL);
return ESP_OK;
}
void espnow_task(void *pvParameter) {
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. */
espnow_send_param_t *send_param = (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");
espnow_deinit(send_param);
vTaskDelete(NULL);
}
while (xQueueReceive(s_espnow_queue, &evt, portMAX_DELAY) == pdTRUE) {
switch (evt.id) {
case EXAMPLE_ESPNOW_SEND_CB: {
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");
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);
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");
espnow_deinit(send_param);
vTaskDelete(NULL);
}
break;
}
case EXAMPLE_ESPNOW_RECV_CB: {
espnow_event_recv_cb_t *recv_cb = &evt.info.recv_cb;
ret = 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");
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);
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");
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;
}
}
}

105
main/espnow_handler.h Normal file
View File

@ -0,0 +1,105 @@
#ifndef ESPNOW_HANDLER_H
#define ESPNOW_HANDLER_H
#include "shared.h"
static bool isMaster;
#define MAX_PAYLOAD_SIZE 250
#define ESPNOW_QUEUE_SIZE 6
#define IS_BROADCAST_ADDR(addr) \
(memcmp(addr, s_broadcast_mac, ESP_NOW_ETH_ALEN) == 0)
typedef enum {
EXAMPLE_ESPNOW_SEND_CB,
EXAMPLE_ESPNOW_RECV_CB,
} espnow_event_id_t;
typedef struct {
uint8_t mac_addr[ESP_NOW_ETH_ALEN];
esp_now_send_status_t status;
} espnow_event_send_cb_t;
typedef struct {
uint8_t mac_addr[ESP_NOW_ETH_ALEN];
uint8_t *data;
int data_len;
} espnow_event_recv_cb_t;
typedef union {
espnow_event_send_cb_t send_cb;
espnow_event_recv_cb_t recv_cb;
} espnow_event_info_t;
typedef struct {
espnow_event_id_t id;
espnow_event_info_t info;
} espnow_event_t;
enum {
EXAMPLE_ESPNOW_DATA_BROADCAST,
EXAMPLE_ESPNOW_DATA_UNICAST,
EXAMPLE_ESPNOW_DATA_MAX,
};
enum {
UNION_STATUS,
UNION_SENSORDATA,
};
typedef struct {
bool isMaster;
} __attribute__((packed)) payloadStatus;
typedef struct {
uint8_t dataPoint;
} __attribute__((packed)) payloadSensorData;
union realPayload {
payloadStatus status;
payloadSensorData sensorData;
};
/* 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 unionPage;
union realPayload realPayload; // Real payload of ESPNOW data.
} __attribute__((packed)) espnow_data_t;
static_assert(sizeof(espnow_data_t) <= MAX_PAYLOAD_SIZE,
"payloadData struct is too big to be sent in one part, keep it "
"under 250 Bytes!");
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.
} espnow_send_param_t;
void wifi_init(void);
void espnow_deinit(espnow_send_param_t *send_param);
void espnow_data_prepare(espnow_send_param_t *send_param);
void espnow_send_cb(const uint8_t *mac_addr,
esp_now_send_status_t status);
void espnow_recv_cb(const esp_now_recv_info_t *recv_info,
const uint8_t *data, int len);
int espnow_data_parse(uint8_t *data, uint16_t data_len, uint8_t *state,
uint16_t *seq, uint32_t *magic);
esp_err_t espnow_init(void);
void espnow_task(void *pvParameter);
void setIsMaster(bool status);
#endif

373
main/main.c
View File

@ -18,377 +18,7 @@
#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 250
#define CONFIG_ESPNOW_LMK "lmk1234567890123"
const char *tag = "Alox";
static QueueHandle_t s_espnow_queue;
static uint8_t s_broadcast_mac[ESP_NOW_ETH_ALEN] = {0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF};
static uint16_t s_espnow_seq[2] = {0, 0};
static void espnow_deinit(espnow_send_param_t *send_param);
void wifi_init(void) {
esp_err_t ret = nvs_flash_init();
if (ret == ESP_ERR_NVS_NO_FREE_PAGES ||
ret == ESP_ERR_NVS_NEW_VERSION_FOUND) {
// NVS partition was truncated and needs to be erased
ESP_ERROR_CHECK(nvs_flash_erase());
ret = nvs_flash_init();
}
ESP_ERROR_CHECK(ret);
ESP_ERROR_CHECK(esp_netif_init());
ESP_ERROR_CHECK(esp_event_loop_create_default());
wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
ESP_ERROR_CHECK(esp_wifi_init(&cfg));
ESP_ERROR_CHECK(esp_wifi_set_storage(WIFI_STORAGE_RAM));
ESP_ERROR_CHECK(esp_wifi_set_mode(ESPNOW_WIFI_MODE));
ESP_ERROR_CHECK(esp_wifi_start());
ESP_ERROR_CHECK(
esp_wifi_set_channel(CONFIG_ESPNOW_CHANNEL, WIFI_SECOND_CHAN_NONE));
ESP_ERROR_CHECK(esp_wifi_set_protocol(
ESPNOW_WIFI_IF, WIFI_PROTOCOL_11B | WIFI_PROTOCOL_11G |
WIFI_PROTOCOL_11N | WIFI_PROTOCOL_LR));
}
static void espnow_deinit(espnow_send_param_t *send_param) {
free(send_param->buffer);
free(send_param);
vSemaphoreDelete(s_espnow_queue);
esp_now_deinit();
}
void espnow_data_prepare(espnow_send_param_t *send_param) {
espnow_data_t *buf = (espnow_data_t *)send_param->buffer;
ESP_LOGI(tag, "Example_Data_SIZE: %u, send_param_len: %d\n",
sizeof(espnow_data_t), send_param->len);
assert(send_param->len >= sizeof(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_espnow_seq[buf->type]++;
buf->crc = 0;
buf->magic = send_param->magic;
buf->unionPage = UNION_STATUS;
buf->realPayload.status.isMaster = isMaster;
buf->crc = esp_crc16_le(UINT16_MAX, (uint8_t const *)buf, send_param->len);
}
static void espnow_send_cb(const uint8_t *mac_addr,
esp_now_send_status_t status) {
espnow_event_t evt;
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_espnow_queue, &evt, ESPNOW_MAXDELAY) != pdTRUE) {
ESP_LOGW(tag, "Send send queue fail");
}
}
static void espnow_recv_cb(const esp_now_recv_info_t *recv_info,
const uint8_t *data, int len) {
espnow_event_t evt;
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_espnow_queue, &evt, ESPNOW_MAXDELAY) != pdTRUE) {
ESP_LOGW(tag, "Send receive queue fail");
free(recv_cb->data);
}
}
int espnow_data_parse(uint8_t *data, uint16_t data_len, uint8_t *state,
uint16_t *seq, uint32_t *magic) {
espnow_data_t *buf = (espnow_data_t *)data;
uint16_t crc, crc_cal = 0;
if (data_len < sizeof(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);
switch (buf->unionPage) {
case UNION_STATUS:
if (buf->realPayload.status.isMaster) {
ESP_LOGI(tag, "Recived Data from Master");
} else {
ESP_LOGI(tag, "Recived Data from Slave");
}
break;
case UNION_SENSORDATA:
ESP_LOGI(tag, "Yeah Daten %d", buf->realPayload.sensorData.dataPoint);
break;
}
if (crc_cal == crc) {
return buf->type;
}
return -1;
}
static void espnow_task(void *pvParameter) {
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. */
espnow_send_param_t *send_param = (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");
espnow_deinit(send_param);
vTaskDelete(NULL);
}
while (xQueueReceive(s_espnow_queue, &evt, portMAX_DELAY) == pdTRUE) {
switch (evt.id) {
case EXAMPLE_ESPNOW_SEND_CB: {
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");
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);
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");
espnow_deinit(send_param);
vTaskDelete(NULL);
}
break;
}
case EXAMPLE_ESPNOW_RECV_CB: {
espnow_event_recv_cb_t *recv_cb = &evt.info.recv_cb;
ret = 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");
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);
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");
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 espnow_init(void) {
espnow_send_param_t *send_param;
s_espnow_queue = xQueueCreate(ESPNOW_QUEUE_SIZE, sizeof(espnow_event_t));
if (s_espnow_queue == NULL) {
ESP_LOGE(tag, "Create mutex fail");
return ESP_FAIL;
}
/* Initialize ESPNOW and register sending and receiving callback function. */
ESP_ERROR_CHECK(esp_now_init());
ESP_ERROR_CHECK(esp_now_register_send_cb(espnow_send_cb));
ESP_ERROR_CHECK(esp_now_register_recv_cb(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));
#endif
/* Set primary master key. */
ESP_ERROR_CHECK(esp_now_set_pmk((uint8_t *)CONFIG_ESPNOW_PMK));
/* 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");
vSemaphoreDelete(s_espnow_queue);
esp_now_deinit();
return ESP_FAIL;
}
memset(peer, 0, sizeof(esp_now_peer_info_t));
peer->channel = CONFIG_ESPNOW_CHANNEL;
peer->ifidx = ESPNOW_WIFI_IF;
peer->encrypt = false;
memcpy(peer->peer_addr, s_broadcast_mac, ESP_NOW_ETH_ALEN);
ESP_ERROR_CHECK(esp_now_add_peer(peer));
free(peer);
/* Initialize sending parameters. */
send_param = malloc(sizeof(espnow_send_param_t));
if (send_param == NULL) {
ESP_LOGE(tag, "Malloc send parameter fail");
vSemaphoreDelete(s_espnow_queue);
esp_now_deinit();
return ESP_FAIL;
}
memset(send_param, 0, sizeof(espnow_send_param_t));
send_param->unicast = false;
send_param->broadcast = true;
send_param->state = 0;
send_param->magic = esp_random();
send_param->count = CONFIG_ESPNOW_SEND_COUNT;
send_param->delay = CONFIG_ESPNOW_SEND_DELAY;
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");
free(send_param);
vSemaphoreDelete(s_espnow_queue);
esp_now_deinit();
return ESP_FAIL;
}
memcpy(send_param->dest_mac, s_broadcast_mac, ESP_NOW_ETH_ALEN);
espnow_data_prepare(send_param);
xTaskCreate(espnow_task, "espnow_task", 2048, send_param, 4, NULL);
return ESP_OK;
}
#include "espnow_handler.h"
void app_main(void) {
// Master Slave Detection, default pin is pull up so ground it and check state
@ -397,6 +27,7 @@ void app_main(void) {
int checkMaster = gpio_get_level(Master_SlavePin);
if (checkMaster == 0) {
isMaster = true;
setIsMaster(true);
}
ESP_LOGI(tag, "ESP MASTER State %d\n", isMaster);

87
main/main.h
View File

@ -1,93 +1,10 @@
#ifndef MAIN_H
#define MAIN_H
#include <stdint.h>
#define Master_SlavePin 23
#define MAX_PAYLOAD_SIZE 250
#define ESPNOW_QUEUE_SIZE 6
#define IS_BROADCAST_ADDR(addr) \
(memcmp(addr, s_broadcast_mac, ESP_NOW_ETH_ALEN) == 0)
#include "shared.h"
static bool isMaster;
typedef enum {
EXAMPLE_ESPNOW_SEND_CB,
EXAMPLE_ESPNOW_RECV_CB,
} espnow_event_id_t;
typedef struct {
uint8_t mac_addr[ESP_NOW_ETH_ALEN];
esp_now_send_status_t status;
} espnow_event_send_cb_t;
typedef struct {
uint8_t mac_addr[ESP_NOW_ETH_ALEN];
uint8_t *data;
int data_len;
} espnow_event_recv_cb_t;
typedef union {
espnow_event_send_cb_t send_cb;
espnow_event_recv_cb_t recv_cb;
} espnow_event_info_t;
typedef struct {
espnow_event_id_t id;
espnow_event_info_t info;
} espnow_event_t;
enum {
EXAMPLE_ESPNOW_DATA_BROADCAST,
EXAMPLE_ESPNOW_DATA_UNICAST,
EXAMPLE_ESPNOW_DATA_MAX,
};
enum {
UNION_STATUS,
UNION_SENSORDATA,
};
typedef struct {
bool isMaster;
} __attribute__((packed)) payloadStatus;
typedef struct {
uint8_t dataPoint;
} __attribute__((packed)) payloadSensorData;
union realPayload {
payloadStatus status;
payloadSensorData sensorData;
};
/* 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 unionPage;
union realPayload realPayload; // Real payload of ESPNOW data.
} __attribute__((packed)) espnow_data_t;
static_assert(sizeof(espnow_data_t) <= MAX_PAYLOAD_SIZE,
"payloadData struct is too big to be sent in one part, keep it "
"under 250 Bytes!");
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.
} espnow_send_param_t;
#define Master_SlavePin 23
#endif

6
main/shared.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef SHARED_H
#define SHARED_H
static char *tag = "Alox";
#endif