mesh.h

Go to the documentation of this file.

 
#ifndef MESH_h
#define MESH_h
 
#include <meshPacket.h>
#include <meshTables.h>
#include <meshBuffers.h>
#include <meshPacketBuilder.h>
#include <meshPacketSplitter.h>
#include <meshPacketDecoders.h>
#include <RFInterface.h>
 
#ifndef SIMULATION
#include <wirish.h>
#else
#include <mutex>
#endif
 
#if MESH_IMPL_CONSOLE_ITEM == 1
#include <SerialConsole.h>
#endif
 
 
typedef enum {
    MeshDisconnected = 0,   
    MeshConnectionScan,     
    MeshConnectionRequest,  
    MeshConnected,          
    MeshDisconnecting,      
}MeshConnectionState;
 
typedef enum {
    MDR_None = 0,                   
    //Connection reasons - BEGIN
    MDR_NotFound = 1,               
    MDR_ConnectionRefused = 2,      
    MDR_NetworkFull = 3,            
    MDR_ConnectionError = 4,        
    MDR_ConnectionRemoteError = 5,  
    MDR_ConnectionTimeout = 6,      
    //Connection reasons - END
 
    //Disconnect reasons - BEGIN
    MDR_DisconnectCalled = 30,      
    MDR_DisconnectRequest = 31,     
    MDR_NetworkDrop = 32,           
    //Disconnect reasons - END
 
    MDR_Unknown = 255, 
}MeshDisconnectReason;
 
typedef enum {
    MPE_OK = 0,                 
    MPE_OIDT_Overwrritten = -1, 
    MPE_Timeout = -2,           
    MPE_NodeLost = -3,          
    MPE_NoNetwork = -4,         
    MPE_Full_outFIFO = -5,      
    MPE_Full_waitingFIFO = -6,  
    MPE_LostRemote = -7,        
    MPE_NoRoute = -8,           
    MPE_Invalid = -9,           
    MPE_GenErr = -10,           
    MPE_AllocErr = -11          
}MeshPacketError;
 
 
class MeshNet
#if (MESH_IMPL_CONSOLE_ITEM == 1)
    :public ConsoleItem
#endif //MESH_IMPL_CONSOLE_ITEM == 1
{
public:
 
 
    MeshNet(): MeshNet(false){}
 
    virtual ~MeshNet();
 
 
    virtual bool begin(MeshMAC mac, RFInterface& RFI);
 
    virtual bool begin();
 
    virtual bool end();
 
 
    bool setChannel(uint8_t channel_);
 
 
 
    bool connect(MeshMAC netBSSID, bool autoConnect = false, uint32_t autoConnectInterval = 30000);
 
    bool directConnect(MeshMAC netBSSID, uint8_t interpreterAddr);
 
    bool disconnect();
 
    void setAutoConnect(MeshMAC netBSSID, uint32_t retryInterval = 60000);
 
    void disableAutoConnect();
 
 
    bool startNetScan(void(*responseCallback)(MeshNet*, const MeshNetScanResult&), uint32_t timeout, MeshNetScanFlags flags, MeshMAC ResponderBSSID = 0);
 
    bool startNetScan(void(*responseCallback)(MeshNet*, const MeshNetScanResult&), uint32_t timeout = 2000);
 
 
    int16_t send(uint8_t addr, const uint8_t* data, uint16_t dataSize);
 
    int16_t send(uint8_t addr, const MeshVariableArray<uint8_t>& data);
 
    int16_t send(uint8_t addr, MeshVariableArray<uint8_t>&& data);
 
 
    int16_t ping(uint8_t addr, uint32_t timeout, int16_t testDataLength = 0);
 
 
#ifndef MESH_NO_STATISTICS
 
    void resetStatistics();
#endif // !MESH_NO_STATISTICS
 
 
    virtual void handle();
 
 
 
    inline uint8_t getMinChannel(){
        return rf->MinChannelNumber;
    }
 
    inline uint8_t getMaxChannel(){
        return rf->MaxChannelNumber;
    }
 
 
    inline bool isConnected() const {
        return connectionState == MeshConnectionState::MeshConnected;
    }
 
    inline bool isDisconnecting() const {
        return connectionState == MeshConnectionState::MeshDisconnecting;
    }
 
    inline MeshConnectionState getConnectionState() const{
        return connectionState;
    }
 
 
    inline bool netScanRunning() const{
        return scanEndTime >= millis() && scanEndTime != 0;
    }
 
 
    inline bool pathExists(uint8_t address) const {
        return RTable.sourceExists(address);
    }
 
    inline bool pathCreating(uint8_t address) const {
        return OIDTable.existsDestAndSysPacketType(address, SPT_PathDiscovery);
    }
 
    inline uint8_t getNeighborNode(uint8_t address) const {
        int16_t ret = RTable.getNeighborFromSource(address);
        if (IS_VALID_MESH_ADDRESS(ret)) {
            return (uint8_t)ret;
        }
        else {
            return UNKNOWN_MESH_ADDRESS;
        }
    }
 
    uint8_t availablePacketsToSend(uint8_t destAddress, bool ACK_R = false) const;
 
    MeshPacketStatus getPacketStatus(uint8_t ID) const;
 
 
    const static MeshVersion Version;
 
    inline bool canBeGateway() const {
        return canBeGateway_;
    }
 
    inline bool isMainGateway() const {
        return canBeGateway_ && AddrPriv == 0;
    }
 
    inline bool isBackupGateway() const {
        return canBeGateway_ && AddrPriv != 0 && AddrPriv <= MESH_GATEWAY_MAX_ADDRESS;
    }
 
    inline MeshMAC getNetworkBSSID() const {
        return NetworkBSSID;
    }
 
    inline MeshMAC getNodeMAC() const {
        return NodeMAC;
    }
 
    inline uint8_t getNodeAddress() const {
        return AddrPriv;
    }
 
    inline RFInterface* getRadioInterfacePtr() const {
        return rf;
    }
 
 
#ifndef MESH_NO_STATISTICS
 
    inline uint32_t getLostFramesTotalCnt() const{
        return lostFramesTotal;
    }
 
    inline uint32_t getLostFramesInNetworkCnt() const{
        return lostFramesInNetwork;
    }
 
    inline uint32_t getLostPacketsTotalCnt() const{
        return lostPacketsTotal;
    }
 
    inline uint32_t getLostPacketsInNetworkCnt() const{
        return lostPacketsInNetwork;
    }
 
    inline uint32_t getLostDataPacketsCnt() const{
        return lostDataPackets;
    }
 
    inline uint32_t getLostRemotePacketsCnt() const{
        return lostRemotePackets;
    }
 
    inline uint32_t getLostRemoteDataPacketsCnt() const{
        return lostRemoteDataPackets;
    }
 
    inline uint32_t getLostRelayiedPacketsCnt() const{
        return lostRelayiedPackets;
    }
 
    inline uint32_t getSentFramesTotalCnt() const{
        return sentFramesTotal;
    }
 
    inline uint32_t getSentFramesInNetworkCnt() const{
        return sentFramesInNetwork;
    }
 
    inline uint32_t getSentPacketsTotalCnt() const{
        return sentPacketsTotal;
    }
 
    inline uint32_t getSentPacketsInNetworkCnt() const{
        return sentPacketsInNetwork;
    }
 
    inline uint32_t getSentDataPacketsCnt() const{
        return sentDataPackets;
    }
 
    inline uint32_t getRelayiedPacketsCnt() const{
        return relayiedPackets;
    }
 
#endif // !MESH_NO_STATISTICS
 
 
    bool printRTable(OSTREAM* stream) const;
 
    bool printIDTable(OSTREAM* stream) const;
 
    bool printFIDTable(OSTREAM* stream) const;
 
    bool printOIDTable(OSTREAM* stream) const;
 
    bool printWaitingFIFO(OSTREAM* stream) const;
 
    bool printOutFIFO(OSTREAM* stream) const;
 
    size_t printMeshNetworkInfo(OSTREAM& stream) const;
 
#ifndef MESH_NO_STATISTICS
 
    size_t printStatistics(OSTREAM& stream) const;
#endif // !MESH_NO_STATISTICS
 
    static size_t printMeshConnectionState(OSTREAM& stream, MeshConnectionState value);
 
    static size_t printMeshDisconnectReason(OSTREAM& stream, MeshDisconnectReason value);
 
    static size_t printMeshPacketError(OSTREAM& stream, MeshPacketError value);
 
 
 
    inline void setOnConnectedCallback(void(*callback)(MeshNet*)) {
        onConnected = callback;
    }
 
    inline void setOnDisconnectedCallback(void(*callback)(MeshNet*, MeshDisconnectReason, MeshMAC, uint8_t)) {
        onDisconnected = callback;
    }
 
    inline void setOnRemoteNodeDisconnectedCallback(void(*callback)(MeshNet*, uint8_t)) {
        onRemDisconnected = callback;
    }
 
 
    inline void setOnPingResponseCallback(void(*callback)(MeshNet*, uint8_t, uint8_t, MeshPacketError, uint8_t, uint32_t, const uint8_t*, int16_t)) {
        onPingResponse = callback;
    }
 
 
    inline void setOnPacketErrorCallback(void(*callback)(MeshNet*, MeshPacketError, uint8_t, uint8_t, const MeshPacket*)) {
        onPacketErrorCallback = callback;
    }
 
    inline void setOnReceive(void(*callback)(MeshNet*, MeshPacket&)) {
        onReceive = callback;
    }
 
 
    inline static MeshNet** getInstances(){
        return instances;
    }
 
#ifndef SIMULATION
 
#if (MESH_IMPL_CONSOLE_ITEM == 1)
 
 
    //Returns pointer to constant char array stored in flash
    const char* getName() override;
 
    bool compareName(char *name, uint8_t nameLength) override;
 
    bool respond(SerialConsole *console, Stream *stream, CommandWords &cmd) override;
 
    void respondRaw(SerialConsole *console, Stream *stream, const char* value) override;
 
    void registerConsole(SerialConsole *console) override;
 
    void unregisterConsole() override;
 
    static void netScanResponse(MeshNet*, const MeshNetScanResult& result);
 
#endif //MESH_IMPL_CONSOLE_ITEM == 1
 
 
#else
 
 
    inline uint32_t millis() const {
        return rf->millis();
    }
 
    inline uint32_t micros() const {
        return rf->micros();
    }
 
    inline uint64_t micros64() const {
        return rf->micros64();
    }
 
    inline void delay(uint32_t time) const {
        return rf->delay(time);
    }
 
    inline void delayMicroseconds(uint32_t time) const {
        return rf->delayMicroseconds(time);
    }
 
    inline std::chrono::nanoseconds PauseSimulationTimer() {
        return rf->PauseSimulationTimer();
    }
 
    inline void ResumeSimulationTimer() {
        rf->ResumeSimulationTimer();
    }
 
    inline std::mutex& GetStreamMutex() {
        return rf->GetStreamMutex();
    }
 
    inline std::mutex& GetMutex() {
        return rf->GetMutex();
    }
 
    inline bool isLogOnly() {
        return rf->isLogOnly();
    }
 
    inline void logTableChange(std::string& descriptor, TableChangeType changeType, const char* data) {
        return rf->logTableChange(descriptor, changeType, data);
    }
 
    static bool allocateInstancesBuffer(int size);
 
    static void deleteInstancesBuffer();
#endif //SIMULATION
 
protected:
 
    MeshNet(bool canBeGateway);
 
    inline uint8_t getNewID() {
        msgIDPriv++;
        return msgIDPriv;
    }
 
    inline uint8_t getLastID() {
        return msgIDPriv;
    }
 
    void handleReceivedInterrupt();
 
#if (MESH_IMPL_CONSOLE_ITEM == 1)
 
    void showHelp(SerialConsole *console, Stream *stream);
#endif //MESH_IMPL_CONSOLE_ITEM
 
    //bool processReceivedOld();
 
    static void onFrameReceiveStatic(MeshPacketBuilder* builder, MeshPacketBuilderStatus status, const MeshFrameHeader& frameHeader, const uint8_t* frameData, uint8_t frameDataSize, int8_t rssi);
 
    void onFrameReceive(MeshPacketBuilder* builder, MeshPacketBuilderStatus status, const MeshFrameHeader& frameHeader, const uint8_t* frameData, uint8_t frameDataSize, int8_t rssi);
 
    static bool checkPacketStatic(MeshPacketBuilder* builder, const MeshPacketHeader& packetHeader, MeshMAC BSSID, SystemPacketType systemPacketType, const uint8_t* frameData, uint8_t frameDataSize, int8_t rssi);
    
    bool checkPacket(MeshPacketBuilder* builder, const MeshPacketHeader& packetHeader, MeshMAC BSSID, SystemPacketType systemPacketType, const uint8_t* frameData, uint8_t frameDataSize, int8_t rssi);
 
    void processReceived();
 
    virtual void processPacket(MeshPacket& packet, MeshMAC BSSID);
 
    void processTransmit();
 
    inline void abortCurrentPacketTransmission(bool packetLost) {
#ifndef MESH_NO_STATISTICS
        if(packetSplittingStarted && frameTranCnt > 0 && packetLost){ //Some frame was sent
            sentFramesTotal--; //Frame was not successfully sent
            lostFramesTotal++;
            if((isConnected() || isDisconnecting() || isMainGateway()) && !sendingPacketIsForeign){
                sentFramesInNetwork--; //Frame was not successfully sent
                lostFramesInNetwork++;
            }
        }
#endif // !MESH_NO_STATISTICS
        onBufferPacketRemove(packetSplitter.GetSplittedPacket(), false, packetLost);
        packetSplittingStarted = false; //Set flag, that nothing is splitting right now
        packetSplitter.Clear();
    }
 
    inline void restartCurrentPacketTransmission() {
        packetSplittingStarted = false;
        packetSplitter.Restart();
    }
 
    inline void restartCurrentPacketTransmission(uint8_t maxFrameSize) {
        packetSplittingStarted = false;
        packetSplitter.Restart(maxFrameSize);
    }
 
    inline bool packetTransmitting() {
        bool headerSent = packetSplitter.GetCurrentFrameIndex() != 0;
        return packetSplittingStarted && (headerSent || frameTranCnt > 0);
    }
 
    inline bool packetSplitting() {
        return packetSplitter.GetRemainingFramesCount() > 0 || packetSplittingStarted;
    }
 
    bool systemNetworkScan(MeshMAC responderBSSID, MeshNetScanFlags flags);
 
    bool sendACK(const MeshACKSetup& setup, bool asDisconnected = false, bool asConnectedToOld = false);
 
    bool sendERR_ACK(const MeshACKSetup& setup, ERR_ACK_ErrorCode ErrorCode, uint8_t RepairValue, bool asDisconnected = false, bool asConnectedToOld = false);
 
    bool PacketToFrame(const MeshPacket& packet, MeshMAC bssid, uint8_t* outBuffer, uint8_t& bufferSize) const;
 
    bool SendPacketAsFrame(MeshPacket& packet, MeshMAC bssid);
 
    static bool isForeignNetworkPacket(const MeshPacket& packet, MeshMAC bssid);
 
    virtual void onNodeLost(uint8_t address, bool nodeLostForever);
 
    bool disconnectPriv(MeshDisconnectReason reason, bool doNotDisconnectImmediatelly, bool forceDisconnect = false);
 
    bool sendDisconnectPacket(MeshNetDisconnectPacketType type);
 
    void onSystemDisconnect(MeshDisconnectReason reason);
 
    static void onOIDTRemoveStatic(MeshOIDTable<OIDTABLE_SIZE>* table, int16_t index, const MeshOIDTableRow& oldRow, uint8_t oldRawLifeTime, MeshOIDTableRemoveReason reason);
 
    virtual void onOIDTRemove(int16_t index, const MeshOIDTableRow& oldRow, uint8_t oldRawLifeTime, MeshOIDTableRemoveReason reason);
 
    static void onNewPathStatic(MeshRouteTable<ROUTETABLE_SIZE>* table, int16_t index, const MeshRouteTableRow& row, uint8_t rawLifeTime);
 
    void onNewPath(int16_t index, const MeshRouteTableRow& row);
 
    void onBufferPacketLost(const MeshPacket& packet, MeshPacketError error);
 
    void onBufferPacketRemove(const MeshPacket& packet, bool ignoreCurrentNetworkPacket, bool packetLost);
 
    virtual void onPacketError(MeshPacketError error, uint8_t packetID, uint8_t packetDest, SystemPacketType packetType, const MeshPacket* packet_ptr);
 
    bool systemPing(uint8_t addr, uint32_t timeout);
 
    void onSystemPingReceived(bool valid, uint32_t duration);
 
    virtual void routeTableUpdate(const MeshPacketHeader& header, MeshMAC BSSID, int8_t rssi);
 
    MeshPacketError pushOutPacket(MeshPacket& packet, uint32_t timeout = 0);
 
    bool createPath(uint8_t address);
 
    void checkWaitingBuffer();
 
 
 
 
    const bool canBeGateway_:1;
 
    bool sentFrameWasACK:1;
 
    bool packetSplittingStarted:1;
 
    bool sendingPacketIsForeign:1;
 
    bool ignoreRSSIThreshold:1;
 
    bool waitingBufferCheck:1;
 
    bool beginCalled:1;
 
    bool receiveInterruptEnabled:1;
 
 
    uint8_t channel;
 
 
    uint8_t AddrPriv = UNKNOWN_MESH_ADDRESS;
    
    MeshMAC NodeMAC;
 
    MeshMAC NetworkBSSID;
 
    char SSID[65];
 
    uint32_t AddrReservedUntil = 0;
 
    uint16_t AddrReservationTime = 0; 
 
    uint8_t oldNodeAddress = UNKNOWN_MESH_ADDRESS;
 
    MeshMAC oldBSSID;
 
 
    RFInterface* rf;
 
    uint64_t CTS_until = 0;
 
    uint64_t lastReceiveTime = 0;
 
    uint32_t lastSentTime = 0;
 
    uint8_t frameTranCnt = 0;
 
 
    MeshConnectionState connectionState = MeshConnectionState::MeshDisconnected;
 
    MeshDisconnectReason lastDisconnectReason = MeshDisconnectReason::MDR_None;
 
    uint8_t currentNetworkPackets = 0;
 
 
    //User scan variables
    uint32_t scanEndTime = 0;
 
    uint32_t lastScanTime = 0;
 
    //System scan variables
    uint8_t lowestHopsToGateway = 255; //Lowest hop-count to gateway found in last scan.
 
    uint8_t lowestHopsToGateway_Addr = INVALID_MESH_ADDRESS; //Address of node, which has lowest hop-count to gateway found in last scan.
 
    MeshMAC lastScanResponderBSSID;
 
    uint32_t connectionStepTime = 0;
 
 
    MeshMAC autoConnectBSSID;
 
    uint32_t nextAutoConnectTime = 0;
 
    uint32_t autoConnectInterval = 0;
 
 
    uint32_t disconnectUntil = 0;
 
 
    int16_t systemPingID = -1;
 
 
    void(*netScanResponseCallback)(MeshNet*, const MeshNetScanResult&);
 
    void(*onConnected)(MeshNet*);
 
    void(*onDisconnected)(MeshNet*, MeshDisconnectReason, MeshMAC, uint8_t);
 
    void(*onRemDisconnected)(MeshNet*, uint8_t);
    
    void(*onReceive)(MeshNet*, MeshPacket&);
 
    void(*onPingResponse)(MeshNet*, uint8_t, uint8_t, MeshPacketError, uint8_t, uint32_t, const uint8_t*, int16_t);
 
    void(*onPacketErrorCallback)(MeshNet*, MeshPacketError, uint8_t, uint8_t, const MeshPacket*);
    
 
#ifndef MESH_NO_STATISTICS
    //All statistic data is restarted when end(), clear() or resetStatistics() is called
    //lostFramesInNetwork, lostPacketsInNetwork, sentFramesInNetwork, sentPacketsInNetwork are restarted also when disconnected from network
 
    //Count of frames, that has been lost. ACK was not received or frame cannot be sent, because of radio error or interference.
    //Retransmitted frames are counted if they are lost.
    uint32_t lostFramesTotal = 0;       //Done
    uint32_t lostFramesInNetwork = 0;   //Done
 
    //Count of lost packets created by current node.
    uint32_t lostPacketsTotal = 0;      //Done - but checks needed
    uint32_t lostPacketsInNetwork = 0;  //Done - but checks needed
 
    //Count of lost packets out of current node created by current node
    uint32_t lostRemotePackets = 0;     //Done - but checks needed
    uint32_t lostRemoteDataPackets = 0; //Done - but checks needed
 
    uint32_t lostDataPackets = 0;       //Done - but checks needed
    uint32_t lostRelayiedPackets = 0;   //Done - but checks needed
 
    //Count of all frames, that has been successfully sent and acknowledged when needed.
    uint32_t sentFramesTotal = 0;       //Done
    uint32_t sentFramesInNetwork = 0;   //Done
 
    //Count of sent packets created by current node. It is not checked if packet is successfully received.
    uint32_t sentPacketsTotal = 0;      //Done
    uint32_t sentPacketsInNetwork = 0;  //Done
 
    uint32_t sentDataPackets = 0;       //Done
    uint32_t relayiedPackets = 0;       //Done
 
    //TODO add count of received packets and frames
    //TODO add duration statistics
 
#endif // !MESH_NO_STATISTICS
 
 
#if MESH_IMPL_CONSOLE_ITEM == 1
 
    SerialConsole* srConsole = NULL;
#endif
 
 
    MeshPacketBuilder packetBuilder;
 
    MeshPacketSplitter packetSplitter;
 
 
    MeshRouteTable<ROUTETABLE_SIZE> RTable;
 
    MeshIDTable<IDTABLE_SIZE> IDTable;
 
    MeshFIDTable<FIDTABLE_SIZE> FIDTable;
 
    MeshOIDTable<OIDTABLE_SIZE> OIDTable;
 
 
    MeshPacketPriorityFIFO<MESH_OFIFO_HIGH_SIZE, MESH_OFIFO_LOW_SIZE> outFIFO;
 
    MeshPacketFIFO<MESH_WFIFO_SIZE> waitingFIFO;
 
private:
 
    uint8_t msgIDPriv = 0xFF;
 
    void addThisToInstArr();
 
    void removeThisFromInstArr();
 
    void clear(bool disconnecting);
 
    
#ifdef SIMULATION
 
    static MeshNet** instances;
 
    static int instArrSize;
#else
 
    static MeshNet* instances[];
#endif // SIMULATION
 
    static uint8_t instCount;
 
};
 
#endif