#if CONFIG_ESPNOW_ENABLE_LONG_RANGE
    ESP_ERROR_CHECK( esp_wifi_set_protocol(ESPNOW_WIFI_IF, WIFI_PROTOCOL_11B|WIFI_PROTOCOL_11G|WIFI_PROTOCOL_11N|WIFI_PROTOCOL_LR) );
#endif

...
bool condition_to_not_encrypt = (lmk == nullptr || peer_addr_to_add[0] & 0x01 || pmk_is_set == false);
// peer can be in a different interface from the home (this station) and still receive the message.
esp_now_peer_info_t peer_info;
memset(&peer_info, 0, sizeof(peer_info)); // set everything to zero
memcpy(peer_info.peer_addr, peer_addr_to_add, MAC_ADDR_LEN);
peer_info.ifidx = wifi_phy_interface; // this does not really matter to set it the same as the peer. This is relevant to the home station WiFi mode and interface. ESP_ERR_ESPNOW_IF
peer_info.channel = wifi_primary_channel;
if (condition_to_not_encrypt)
    peer_info.encrypt = false;
else
{
    peer_info.encrypt = true;
    memcpy(peer_info.lmk, lmk, KEY_LENGTH);
}

err = esp_now_add_peer(&peer_info);
...

// Define the log levels
#define LOG_NONE 0 // to not output any logs
#define LOG_MONITOR 1
#define LOG_ERROR 2
#define LOG_WARNING 3
#define LOG_INFO 4
#define LOG_DEBUG 5
#define LOG_VERBOSE 6

#define EASYMAC2STR(a) (a)[0], (a)[1], (a)[2], (a)[3], (a)[4], (a)[5]
#define EASYMACSTR "%02X:%02X:%02X:%02X:%02X:%02X"

// How to use in code
uint8_t some_MAC[] = {0xCD, 0x56, 0x47, 0xFC, 0xAF, 0xB3};
MONITOR(TAG, "Mac: " EASYMACSTR " This was some MAC address" , EASYMAC2STR(some_MAC));

 #include <EasyEspNow.h>

begin(channel, phy_interface, tx_q_size, synch_send) // begin everything, set channel, wifi interface, tx queue size, synchronous send. If synch. send true => tx size will default to 1
setPMK(pmk_to_set) // set Primary Master Key - PMK, must have length of 16 bytes
getPMK(pmk_buff) // get PMK, copy content into the buffer that user provided
stop() // stop everything
easy_send_error_t send(dstAddress, payload, payload_len) // to enqueu message for send with specific length to destination address
easy_send_error_t sendBroadcast(payload, payload_len) // just a call to send() with Broadcast address as destination
enableTXTask(enable) // enable or disable the TX task responsible for exhausting TX queu and sending the messages
readyToSendData() // readinnes to send if TX has space, if full not ready
waitForTXQueueToBeEmptied() // blocking function to wait until TX queue is empty
onDataReceived(frame_rcvd_cb) // to register user defined callback function upon receiving data. Higher level
onDataSent(frame_sent_cb) // to register user defined callback function upon sending data. Higher level

typedef struct
{
	uint8_t mac[MAC_ADDR_LEN]; // MAC address of the peer
    bool encrypted; // flag to keep track if peer encrypted or no
	uint32_t time_peer_added = 0; // last time a peer was seen; millis()
} peer_t;

typedef struct
{
	uint8_t peer_number; // totoal number of peers
	peer_t peer[MAX_TOTAL_PEER_NUM]; // list of peers
} peer_list_t;

addPeer(peer_addr_to_add, lmk = nullptr) // add peer with provided MAC address, and encrypts it with LMK
deletePeer(peer_addr_to_delete); // delete peer with provided MAC address
uint8_t *deletePeer(keep_broadcast_addr = true) // this deletes the oldest peer and returns its MAC. It can delete the broadcast peer too if it is the oldest and `keep_broadcast_addr = false`
peer_t *getPeer(peer_addr_to_get, esp_now_peer_info_t &peer_info) // returns peer_t structure for the peer and puts the info in the peer_info structure
peerExists(peer_addr) // check if peer exists or no
updateLastSeenPeer(peer_addr) // update last seen value for peer with MAC address
countPeers(CountPeers count_type) // count peers, total | unencrypted | encrypted
printPeerList() // prints the peer list, used more for debugging
peer_list_t getPeerList() // this will return the complete peer_list structure for the user's convinience. returns it by value

const char *easySendErrorToName(easy_send_error_t send_error) // returns the send error as a char array
wifi_interface_t autoselect_if_from_mode(wifi_mode_t mode, bool apstaMOD_to_apIF = true) // helper function to determine wifi interface depending on wifi mode
char *easyMac2Char(const uint8_t *some_mac, size_t len = MAC_ADDR_LEN, bool upper_case = true) // return a MAC as a char array for easy print, if any issue will default to {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
easyPrintMac2Char(const uint8_t *some_mac, size_t len = MAC_ADDR_LEN, bool upper_case = true) // just print the MAC, if any issue will default to {0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
getEspNowVersion() // esp-now version
getPrimaryChannel() // returns channel in which wifi radio is on, same channel in which esp-now frames will be sent
wifi_second_chan_t getSecondaryChannel() // secondary channel
getAddressLength() // length of a MAC address (6 because there are 6 octets in a MAC)
getMaxMessageLength() // max length of a message that can be delivered via ESP-NOW
getDeviceMACAddress() // return MAC address of this device
uint8_t *generateRandomMAC(bool local = true, bool unicast = true) // generate random mac, can be local/global unicast/multicast
switchChannel(uint8_t primary, wifi_second_chan_t second = WIFI_SECOND_CHAN_NONE) // switches operating wifi channel on the fly, updates channel for all peers in their info. The switch of channel for this base station and for the peers it holds may result in messages not being sent to destination or received from source peers due to channel change. Handle carefully.

/**
 * https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/network/esp_now.html#frame-format
 * This would be the promiscuous packet
 * It is an Action frame. On 802.11 managment type (0), subtype 0x0d (13)
 */

// These are common fields of the MAC header for both encrypted and unencrypted frames
typedef struct
{
    unsigned protocol : 2;
    unsigned type : 2;
    unsigned subtype : 4;
    uint8_t flags;
    uint16_t duration;
    uint8_t destination_address[6];
    uint8_t source_address[6];
    uint8_t broadcast_address[6];
    uint16_t sequence_control;
} __attribute__((packed)) espnow_frame_header_common_t;

// Unencrypted frame as a promiscuous packet in ESP
typedef struct
{
    espnow_frame_header_common_t esp_now_frame_header;
    uint8_t category_code;              // 0x7f ; set to the value (127)
    uint8_t organization_identifier[3]; // 0x18fe34
    uint8_t random_values[4];
    struct
    {
        uint8_t element_id;                 // 0xdd ; set to the value (221)
        uint8_t length;                     // The length is the total length of Organization Identifier, Type, Version and Body
        uint8_t organization_identifier[3]; // 0x18fe34
        uint8_t type;                       // 0x04 ; the Type field is set to the value (4) indicating ESP-NOW
        uint8_t version;                    // the Version field is set to the version of ESP-NOW.
        uint8_t body[0];
    } vendor_specific_content;
} __attribute__((packed)) espnow_frame_format_t;

// Encrypted CCMP frame promiscuous packet in ESP
typedef struct
{
    espnow_frame_header_common_t esp_now_frame_header;
    uint8_t ccmp_parameters[8];

    // The rest are the decrypted fields. If you are sniffing in Wireshark the raw 802.11 packets, you will not see the below, only the encrypted data
    // You can see the following if you print the raw bytes of the packets
    uint8_t category_code;              // 0x7f ; set to the value (127)
    uint8_t organization_identifier[3]; // 0x18fe34
    uint8_t random_values[4];
    struct
    {
        uint8_t element_id;                 // 0xdd ; set to the value (221)
        uint8_t length;                     // The length is the total length of Organization Identifier, Type, Version and Body
        uint8_t organization_identifier[3]; // 0x18fe34
        uint8_t type;                       // 0x04 ; the Type field is set to the value (4) indicating ESP-NOW
        uint8_t version;                    // the Version field is set to the version of ESP-NOW.
        uint8_t body[0];
    } vendor_specific_content;
} __attribute__((packed)) espnow_frame_format_ccmp_t;

// If frame received is unencrypted -> `ccmp_encrypted_frame` must be nullptr
// If frame received is encrypted -> `unencrypted_frame` must be nullptr
typedef struct
{
    wifi_pkt_rx_ctrl_t *radio_header;
    espnow_frame_format_t *unencrypted_frame;
    espnow_frame_format_ccmp_t *ccmp_encrypted_frame;
} espnow_frame_recv_info_t;

/* SYNCHRONOUS MODE */
// assures no packet drop when sending
void loop()
{
    String data = "Hello World";
    // Here is doing only Broadcasting
    easy_send_error_t code = easyEspNow.send(ESPNOW_BROADCAST_ADDRESS, (uint8_t *)data.c_str(), data.length());
    MONITOR(MAIN_TAG, "Last send return code value: %s\n", easyEspNow.easySendErrorToName(code));

    // add some delay to simulate longer code run
    // if this is faster than TX exhaust rate (i have set it in the code to be `vTaskDelay(pdMS_TO_TICKS(13)`
    // you will get this: [115535] [WARNING] [EASY_ESP_NOW]: Synchronous send mode. Waiting for free space in TX Queue
    // otherwise no WARNING.
    vTaskDelay(pdMS_TO_TICKS(13));
}

/* ASYNCHRONOUS MODE */
// TX queue can hold more than 1 outgoing message
// packet dropping can happen when TX queue is full and a message can't be enqued
void loop()
{
    String data = "Hello World";
    // Here is doing only Broadcasting
    easy_send_error_t code = easyEspNow.send(ESPNOW_BROADCAST_ADDRESS, (uint8_t *)data.c_str(), data.length());
    MONITOR(MAIN_TAG, "Last send return code value: %s\n", easyEspNow.easySendErrorToName(code));

    // add some delay to simulate longer code run
    // if this is significantly faster than TX exhaust rate (i have set it in the code to be `vTaskDelay(pdMS_TO_TICKS(13)`
    // you will get this: [31220] [WARNING] [EASY_ESP_NOW]: TX Queue full. Can not add message to queue. Dropping message...
    // packet drop
    vTaskDelay(pdMS_TO_TICKS(1000));
}

/* ASYNCHRONOUS MODE */
// TX queue can hold more than 1 outgoing message
// how to mitigate packet dropping when TX queue is full
void loop()
{
    String data = "Hello World";
    // condition is needed to avoid packet drop only when doing asynch
    if (!easyEspNow.readyToSendData()) // if TX queue is full, wait for it to completely exhaust
        easyEspNow.waitForTXQueueToBeEmptied();
    easy_send_error_t code = easyEspNow.send(ESPNOW_BROADCAST_ADDRESS, (uint8_t *)data.c_str(), data.length());
    MONITOR(MAIN_TAG, "Last send return code value: %s\n", easyEspNow.easySendErrorToName(code));

    // add some delay to simulate longer code run
    // if this is significantly faster than TX exhaust rate (i have set it in the code to be `vTaskDelay(pdMS_TO_TICKS(13)`
    // packet drop mitigation condition will take place
    vTaskDelay(pdMS_TO_TICKS(1000));
}

uint8_t PMK[] = {0x1A, 0x2B, 0x3C, 0x4D, 0x5E, 0x6F, 0x7A, 0x8B, 0x9C, 0xAD, 0xBE, 0xCF, 0xDA, 0xEB, 0xFC, 0x0D};
uint8_t LMK1[] = {0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A};
uint8_t LMK2[] = {0xFB, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A};

// On sketches for Device A, B, C
esp_now_init();
esp_now_set_pmk(PMK);

// On device A adding B as a peer
esp_now_peer_info_t peerInfo;
memcpy(peerInfo.peer_addr, MAC_B, 6);
peerInfo.channel = some_channel;
peerInfo.encrypt = true;
memcpy(peerInfo.lmk, LMK1, 16);
esp_now_add_peer(&peerInfo);

// On device B adding A as a peer
esp_now_peer_info_t peerInfo;
memcpy(peerInfo.peer_addr, MAC_A, 6);
peerInfo.channel = some_channel;
peerInfo.encrypt = true;
memcpy(peerInfo.lmk, LMK1, 16);
esp_now_add_peer(&peerInfo);
/* Now A and B can talk in encrypted way using ESP-NOW API */

///////////////////////////////////////////////////////////////////////
// On device A adding C as a peer
esp_now_peer_info_t peerInfo;
memcpy(peerInfo.peer_addr, MAC_C, 6);
peerInfo.channel = some_channel;
peerInfo.encrypt = true;
memcpy(peerInfo.lmk, LMK2, 16);
esp_now_add_peer(&peerInfo);

// On device C adding A as a peer
esp_now_peer_info_t peerInfo;
memcpy(peerInfo.peer_addr, MAC_A, 6);
peerInfo.channel = some_channel;
peerInfo.encrypt = true;
memcpy(peerInfo.lmk, LMK2, 16);
esp_now_add_peer(&peerInfo);

/* Now A and C can talk in encrypted way using ESP-NOW API */

///////////////////////////////////////////////////////////////////////
// On device B adding C as a peer
esp_now_peer_info_t peerInfo;
memcpy(peerInfo.peer_addr, MAC_C, 6);
peerInfo.channel = some_channel;
peerInfo.encrypt = true;
memcpy(peerInfo.lmk, LMK1, 16);
esp_now_add_peer(&peerInfo);

// On device C adding B as a peer
esp_now_peer_info_t peerInfo;
memcpy(peerInfo.peer_addr, MAC_B, 6);
peerInfo.channel = some_channel;
peerInfo.encrypt = true;
memcpy(peerInfo.lmk, LMK1, 16);
esp_now_add_peer(&peerInfo);

/* Now B and C can talk in encrypted way using ESP-NOW API */

/** Bottom line:
 *  A uses LMK1 to talk to B and LMK2 to talk to C
 *  B uses LMK1 to talk to A and LMK1 to talk to C
 *  C uses LMK2 to talk to A and LMK1 to talk to B
*/