espnow.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <climits>
#include <future>
#include <mutex>
#include <string>
 
#include "spsp/espnow_adapter_if.hpp"
#include "spsp/espnow_packet.hpp"
#include "spsp/espnow_ser_des.hpp"
#include "spsp/espnow_types.hpp"
#include "spsp/layers.hpp"
#include "spsp/local_addr_mac.hpp"
#include "spsp/wifi_espnow_if.hpp"
 
namespace SPSP::LocalLayers::ESPNOW
{
    static constexpr int SIGNAL_MIN = INT_MIN;  
 
    static constexpr uint8_t MAX_PEER_NUM = 15;
 
    struct BridgeConnInfoRTC
    {
        uint8_t addr[6];  
        uint8_t ch;       
    };
 
    class ESPNOW : public ILocalLayer<LocalMessageT>
    {
    public:
        using LocalAddrT = SPSP::LocalLayers::ESPNOW::LocalAddrT;
        using LocalMessageT = SPSP::LocalLayers::ESPNOW::LocalMessageT;
    
    protected:
        struct BridgeConnInfoInternal
        {
            LocalAddrT addr = {};   
            int rssi = SIGNAL_MIN;  
            uint8_t ch = 0;         
 
            BridgeConnInfoInternal() {}
 
            BridgeConnInfoInternal(BridgeConnInfoRTC brRTC)
                : addr{brRTC.addr}, ch{brRTC.ch} {};
 
            bool empty() { return addr == LocalAddrT{}; }
 
            BridgeConnInfoRTC toRTC();
        };
 
        std::mutex m_mutex;                        
        const Config m_conf;                       
        WiFi::IESPNOW& m_wifi;                     
        IAdapter& m_adapter;                       
        SerDes m_serdes;                           
        BridgeConnInfoInternal m_bestBridge = {};  
        std::mutex m_bestBridgeMutex;              
 
        std::array<std::promise<bool>, MAX_PEER_NUM> m_sendingPromises;
 
        std::array<std::mutex, MAX_PEER_NUM> m_sendingMutexes;
    
    public:
        ESPNOW(IAdapter& adapter, WiFi::IESPNOW& wifi, const Config& conf);
 
        ~ESPNOW();
 
        bool send(const LocalMessageT& msg);
 
        bool connectToBridge(BridgeConnInfoRTC* rtndBr = nullptr,
                             BridgeConnInfoRTC* connBr = nullptr);
 
    protected:
        void receive(const LocalMessageT& msg, int rssi);
 
        void sendRaw(const LocalAddrT& dst, const std::string& data);
 
        void recvCb(const LocalAddrT src, std::string data, int rssi);
 
        void sendCb(const LocalAddrT dst, bool delivered);
 
        uint8_t getBucketIdFromLocalAddr(const LocalAddrT& addr) const;
    };
} // namespace SPSP::LocalLayers::ESPNOW