NodeList.h

Go to the documentation of this file.

 
#ifndef _NODELIST_h
#define _NODELIST_h
 
#if defined(ARDUINO) && ARDUINO >= 100
    #include "Arduino.h"
#else
    #include "WProgram.h"
#endif
#include "EnigmaIoTconfig.h"
#include "Filter.h"
 
enum node_status {
    UNREGISTERED, 
    INIT, 
    WAIT_FOR_SERVER_HELLO, 
    WAIT_FOR_DOWNLINK, 
    REGISTERED, 
    SLEEP 
};
 
typedef enum {
    NAME_OK = 0,
    ALREADY_USED = -1,
    EMPTY_NAME = -2,
    TOO_LONG = -3
}nodeNameStatus_t;
 
typedef enum node_status status_t; 
 
typedef enum {
    RESTART_AFTER_OTA = 1,
    OTA_ERROR_RESTART = 2,
    RESTART_REQUESTED = 3,
    CONFIG_RESET = 4,
    USER_RESET = 5,
    IRRELEVANT = 10,
    UNKNOWN_REASON = 0
}restartReason_t;
 
typedef enum control_message_type {
    VERSION = 0x01,
    VERSION_ANS = 0x81,
    SLEEP_GET = 0x02,
    SLEEP_SET = 0x03,
    SLEEP_ANS = 0x82,
    IDENTIFY = 0x04,
    RESET = 0x05,
    RESET_ANS = 0x85,
    RSSI_GET = 0x06,
    RSSI_ANS = 0x86,
    NAME_GET = 0x07,
    NAME_ANS = 0x08,
    NAME_SET = 0x87,
    RESTART_NODE = 0x09,
    RESTART_CONFIRM = 0x89,
    BRCAST_KEY = 0x10,
    OTA = 0xEF,
    OTA_ANS = 0xFF,
    USERDATA_GET = 0x00,
    USERDATA_SET = 0x20,
    INVALID = 0xF0
    //USERDATA_ANS = 0x90
} control_message_type_t;
 
typedef enum ota_status {
      OTA_STARTED = 0,
      OTA_START_ERROR = 1,
      OTA_CHECK_OK = 2,
      OTA_CHECK_FAIL = 3,
      OTA_OUT_OF_SEQUENCE =4 ,
      OTA_TIMEOUT = 5,
      OTA_FINISHED = 6
} ota_status_t;
 
struct node_instance {
    uint8_t mac[ENIGMAIOT_ADDR_LEN]; 
    uint16_t nodeId; 
    uint8_t key[32]; 
    uint16_t lastMessageCounter; 
    uint16_t lastControlCounter; 
    uint16_t lastDownlinkMsgCounter; 
    time_t keyValidFrom; 
    time_t lastMessageTime; 
    status_t status = UNREGISTERED; 
    bool keyValid = false; 
    bool sleepyNode = true; 
    char nodeName[NODE_NAME_LENGTH]; 
};
 
typedef struct node_instance node_t;
 
class Node {
public:
    Node ();
 
    explicit Node (node_t nodeData);
 
    uint8_t *getMacAddress () {
        return mac;
    }
 
    uint16_t getNodeId () {
        return nodeId;
    }
 
    void setNodeId (uint16_t nodeId) {
        this->nodeId = nodeId;
    }
 
    char* getNodeName () {
        if (strlen (nodeName)) {
            return nodeName;
        } else {
            return NULL;
        }
    }
 
    void setNodeName (const char* name) {
        memset (nodeName, 0, NODE_NAME_LENGTH);
        strncpy (nodeName, name, NODE_NAME_LENGTH);
    }
 
    uint8_t *getEncriptionKey () {
        return key;
    }
 
    void setEncryptionKey (const uint8_t* key);
 
    time_t getKeyValidFrom () {
        return keyValidFrom;
    }
 
    void setKeyValidFrom (time_t keyValidFrom) {
        this->keyValidFrom = keyValidFrom;
    }
 
    time_t getLastMessageTime () {
        return lastMessageTime;
    }
 
    void setLastMessageTime () {
        lastMessageTime = millis ();
    }
 
    uint16_t getLastMessageCounter () {
        return lastMessageCounter;
    }
 
    uint16_t getLastControlCounter () {
        return lastControlCounter;
    }
 
    uint16_t getLastDownlinkMsgCounter () {
        return lastDownlinkMsgCounter;
    }
 
    void setLastMessageCounter (uint16_t counter) {
        lastMessageCounter = counter;
    }
 
    void setLastControlCounter (uint16_t counter) {
        lastControlCounter = counter;
    }
 
    void setLastDownlinkMsgCounter (uint16_t counter) {
        lastDownlinkMsgCounter = counter;
    }
 
    void setMacAddress (const uint8_t *macAddress) {
        if (macAddress) {
            memcpy (mac, macAddress, 6);
        }
    }
 
    bool isKeyValid () {
        return keyValid;
    }
 
    void setKeyValid (bool status) {
        keyValid = status;
    }
 
    bool isRegistered () {
        return status == REGISTERED;
    }
 
    status_t getStatus () {
        return status;
    }
 
    void setStatus (status_t status) {
        this->status = status;
    }
 
    node_t getNodeData ();
 
    void printToSerial (Stream *port = &Serial);
 
    void reset ();
 
    void setSleepy (bool sleepy) {
        if (initAsSleepy) {
            sleepyNode = sleepy;
        } else {
            sleepyNode = false;
        }
    }
 
    void setInitAsSleepy (bool sleepy) {
        initAsSleepy = sleepy;
    }
 
    bool getInitAsSleepy () {
        return initAsSleepy;
    }
 
    bool getSleepy () {
        return sleepyNode;
    }
 
    bool broadcastIsEnabled () {
#ifndef DISABLE_BRCAST
        return broadcastEnabled;
#else
        return false;
#endif
    }
 
    void enableBroadcast (bool broadcast) {
#ifndef DISABLE_BRCAST
        broadcastEnabled = broadcast;
#endif
    }
 
    void setBroadcastKeyRequested (bool request) {
        broadcastKeyRequested = request;
    }
 
    bool isBroadcastKeyRequested () {
        return broadcastKeyRequested;
    }
 
    void updatePacketsRate (float value);
 
    int8_t getRSSI () {
        return rssi;
    }
 
    void setRSSI (int8_t rssi) {
        this->rssi = rssi;
    }
    
    bool useTimeSync () {
        return askedTimeSync;
    }
    
    void setTimeSyncEnabled () {
        askedTimeSync = true;
    }
 
    uint8_t* getVersion () {
        return enigmaIOTVersion;
    }
 
    void setVersion (uint8_t major, uint8_t minor, uint8_t incremental) {
        enigmaIOTVersion[0] = major;
        enigmaIOTVersion[1] = minor;
        enigmaIOTVersion[2] = incremental;
    }
 
    uint8_t queuedMessage[MAX_MESSAGE_LENGTH]; 
    size_t qMessageLength;  
    bool qMessagePending = false; 
 
    uint32_t packetNumber = 0; 
    uint32_t packetErrors = 0; 
    double per = 0;  
    double packetsHour = 0; 
    //int64_t t1, t2, t3, t4;  ///< @brief Timestaps to calculate clock offset
 
protected:
//#define KEYLENGTH 32
    bool keyValid; 
    status_t status; 
    uint16_t lastMessageCounter; 
    uint16_t lastControlCounter; 
    uint16_t lastDownlinkMsgCounter; 
    uint16_t nodeId; 
    timer_t keyValidFrom; 
    bool sleepyNode = true; 
    bool broadcastEnabled = false; 
    bool broadcastKeyRequested = false; 
    bool initAsSleepy; 
    bool askedTimeSync = false; 
    uint8_t mac[ENIGMAIOT_ADDR_LEN]; 
    uint8_t key[KEY_LENGTH]; 
    timer_t lastMessageTime; 
    FilterClass* rateFilter; 
    char nodeName[NODE_NAME_LENGTH]; 
    int8_t rssi; 
    uint8_t enigmaIOTVersion[3]; 
 
    void initRateFilter ();
 
    friend class NodeList;
};
 
 
class NodeList {
public:
 
    NodeList ();
 
    Node *getNodeFromID (uint16_t nodeId);
 
    Node *getNodeFromMAC (const uint8_t* mac);
 
    Node* getNodeFromName (const char* name);
    
    int8_t checkNodeName (const char* name, const uint8_t* address);
 
    Node *findEmptyNode ();
    
    uint16_t countActiveNodes ();
    
    bool unregisterNode (uint16_t nodeId);
    
    bool unregisterNode (const uint8_t* mac);
    
    bool unregisterNode (Node *node);
 
    Node *getNextActiveNode (uint16_t nodeId);
 
    Node *getNextActiveNode (Node* node);
 
    Node *getNewNode (const uint8_t* mac);
 
    void printToSerial (Stream *port);
 
    Node* getBroadcastNode () {
        return &broadcastNode;
    }
 
    void initBroadcastNode ();
 
    uint16_t getLastBroadcastMsgCounter () {
        return lastBroadcastMsgCounter;
    }
 
    void incLastBroadcastMsgCounter () {
        lastBroadcastMsgCounter++;
    }
 
protected:
    Node nodes[NUM_NODES]; 
    Node broadcastNode; 
    uint16_t lastBroadcastMsgCounter; 
 
};
 
 
#endif