espnow_face.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "ndn/face.hpp"
 
#include <array>
#include <cstring>
 
// Forward declaration for ESP-NOW types
extern "C" {
#include "esp_now.h"
}
 
namespace ndn {
 
constexpr size_t ESPNOW_MAX_PAYLOAD = 1470;
 
constexpr size_t ESPNOW_MAX_PEERS = 20;
 
constexpr uint8_t BROADCAST_MAC[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
 
inline FaceId macToFaceId(const uint8_t* mac) {
    // Use lower 2 bytes (offset by +2 since 0 is invalid)
    return static_cast<FaceId>(((mac[4] << 8) | mac[5]) + 2);
}
 
struct PeerInfo {
    uint8_t mac[6];     
    FaceId faceId;      
    bool inUse;         
    uint32_t lastSeen;  
};
 
class EspNowFace : public Face {
public:
    explicit EspNowFace(FaceId faceId = 2);
 
    ~EspNowFace() override;
 
    FaceId id() const override { return faceId_; }
 
    Error start() override;
 
    void stop() override;
 
    Error send(const uint8_t* data, size_t len) override;
 
    Error sendTo(FaceId destFace, const uint8_t* data, size_t len) override;
 
    Error broadcast(const uint8_t* data, size_t len) override;
 
    size_t maxPayloadSize() const override { return ESPNOW_MAX_PAYLOAD; }
 
    FaceId addPeer(const uint8_t* mac);
 
    void removePeer(FaceId faceId);
 
    bool getMacAddress(FaceId faceId, uint8_t* mac) const;
 
    size_t peerCount() const;
 
    void processReceiveQueue();
 
    void setMacFilter(const uint8_t* mac);
 
    void setMacFilters(const uint8_t macs[][6], size_t count);
 
    void clearMacFilters();
 
    bool hasMacFilter() const { return macFilterEnabled_; }
 
    static constexpr size_t MAX_MAC_FILTERS = 4;
 
    static EspNowFace* instance() { return instance_; }
 
private:
    // ESP-NOW callbacks (forwarded from static to instance methods)
    static void onReceive(const esp_now_recv_info_t* info, const uint8_t* data, int len);
    static void onSend(const esp_now_send_info_t* info, esp_now_send_status_t status);
 
    // Receive handling
    void handleReceive(const uint8_t* srcMac, const uint8_t* data, size_t len);
 
    // Peer lookup
    PeerInfo* findPeer(FaceId faceId);
    PeerInfo* findPeerByMac(const uint8_t* mac);
    const PeerInfo* findPeer(FaceId faceId) const;
 
    FaceId faceId_;
    bool running_ = false;
 
    // Peer management
    std::array<PeerInfo, ESPNOW_MAX_PEERS> peers_{};
 
    // Receive queue (for safely passing data from ISR context)
    // Reduced from 16 to 8 for v2.0 large payload support (memory saving)
    static constexpr size_t RX_QUEUE_SIZE = 8;
    struct RxPacket {
        uint8_t srcMac[6];
        uint8_t data[ESPNOW_MAX_PAYLOAD];
        size_t len;
        bool valid;
    };
    std::array<RxPacket, RX_QUEUE_SIZE> rxQueue_{};
    volatile size_t rxQueueHead_ = 0;
    volatile size_t rxQueueTail_ = 0;
 
    // Static instance (for callbacks)
    static EspNowFace* instance_;
 
    // MAC address filters (multiple supported)
    uint8_t macFilters_[MAX_MAC_FILTERS][6] = {};
    size_t macFilterCount_ = 0;
    bool macFilterEnabled_ = false;
};
 
}  // namespace ndn