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 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,
    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; 
    time_t keyValidFrom; 
    time_t lastMessageTime; 
    status_t status = UNREGISTERED; 
    bool keyValid = false; 
    bool sleepyNode = true; 
};
 
typedef struct node_instance node_t;
 
class Node {
public:
    Node ();
 
    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;
    }
 
    void setLastMessageCounter (uint16_t counter) {
        lastMessageCounter = counter;
    }
 
    void setMacAddress (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;
    }
 
    void updatePacketsRate (float value);
 
    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;  
 
protected:
//#define KEYLENGTH 32
    bool keyValid; 
    status_t status; 
    uint16_t lastMessageCounter; 
    uint16_t nodeId; 
    timer_t keyValidFrom; 
    bool sleepyNode = true; 
    bool initAsSleepy; 
    uint8_t mac[ENIGMAIOT_ADDR_LEN]; 
    uint8_t key[KEY_LENGTH]; 
    timer_t lastMessageTime; 
    FilterClass* rateFilter; 
    char nodeName[NODE_NAME_LENGTH]; 
 
    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);
 
protected:
    Node nodes[NUM_NODES]; 
 
};
 
 
#endif