EnigmaIOTGateway.h

Go to the documentation of this file.

 
#ifndef _ENIGMAIOTGATEWAY_h
#define _ENIGMAIOTGATEWAY_h
 
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
#include "EnigmaIoTconfig.h"
#include "NodeList.h"
#include "Filter.h"
#include "Comms_hal.h"
#include <ESPAsyncWebServer.h>
#include <ESPAsyncWiFiManager.h>
#include <DNSServer.h>
#include <queue>
 
#include "helperFunctions.h"
 
#define LED_ON LOW
#define LED_OFF !LED_ON
 
enum gatewayMessageType_t {
    SENSOR_DATA = 0x01, 
    UNENCRYPTED_NODE_DATA = 0x11, 
    DOWNSTREAM_DATA_SET = 0x02, 
    DOWNSTREAM_DATA_GET = 0x12, 
    CONTROL_DATA = 0x03, 
    DOWNSTREAM_CTRL_DATA = 0x04, 
    CLOCK_REQUEST = 0x05, 
    CLOCK_RESPONSE = 0x06, 
    NODE_NAME_SET = 0x07, 
    NODE_NAME_RESULT = 0x17, 
    CLIENT_HELLO = 0xFF, 
    SERVER_HELLO = 0xFE, 
    INVALIDATE_KEY = 0xFB 
};
 
enum gatewayPayloadEncoding_t {
    RAW = 0x00, 
    CAYENNELPP = 0x81, 
    PROT_BUF = 0x82, 
    MSG_PACK = 0x83, 
    BSON = 0x84, 
    CBOR = 0x85, 
    SMILE = 0x86, 
    ENIGMAIOT = 0xFF
};
 
enum gwInvalidateReason_t {
    UNKNOWN_ERROR = 0x00, 
    WRONG_CLIENT_HELLO = 0x01, 
    //WRONG_EXCHANGE_FINISHED = 0x02, /**< KeyExchangeFinished message received was invalid. Probably this means an error on shared key */
    WRONG_DATA = 0x03, 
    UNREGISTERED_NODE = 0x04, 
    KEY_EXPIRED = 0x05 
};
 
#if defined ARDUINO_ARCH_ESP8266 || defined ARDUINO_ARCH_ESP32
#include <functional>
typedef std::function<void (uint8_t* mac, uint8_t* buf, uint8_t len, uint16_t lostMessages, bool control, gatewayPayloadEncoding_t payload_type, char* nodeName)> onGwDataRx_t;
typedef std::function<void (uint8_t* mac, uint16_t node_id, char* nodeName)> onNewNode_t;
typedef std::function<void (uint8_t* mac, gwInvalidateReason_t reason)> onNodeDisconnected_t;
typedef std::function<void (boolean status)> onWiFiManagerExit_t;
typedef std::function<void (void)> onWiFiManagerStarted_t;
#else
typedef void (*onGwDataRx_t)(uint8_t* mac, uint8_t* data, uint8_t len, uint16_t lostMessages, bool control, gatewayPayloadEncoding_t payload_type, char* nodeName);
typedef void (*onNewNode_t)(uint8_t* mac, uint16_t node_id, char* nodeName);
typedef void (*onNodeDisconnected_t)(uint8_t* mac, gwInvalidateReason_t reason);
typedef void (*onWiFiManagerExit_t)(boolean status);
typedef void (*onWiFiManagerStarted_t)(void);
#endif
 
typedef struct {
    uint8_t channel = DEFAULT_CHANNEL; 
    uint8_t networkKey[KEY_LENGTH];   
    char networkName[NETWORK_NAME_LENGTH];   
} gateway_config_t;
 
typedef struct {
    uint8_t addr[ENIGMAIOT_ADDR_LEN]; 
    uint8_t data[MAX_MESSAGE_LENGTH]; 
    size_t len; 
} msg_queue_item_t;
 
template <typename Telement>
class EnigmaIOTRingBuffer {
protected:
    int maxSize; 
    int numElements = 0; 
    int readIndex = 0; 
    int writeIndex = 0; 
    Telement* buffer; 
 
public:
    EnigmaIOTRingBuffer <Telement> (int range) : maxSize (range) {
        buffer = new Telement[maxSize];
    }
 
    int size () { return numElements; }
 
    bool isFull () { return numElements == maxSize; }
 
    bool empty () { return (numElements == 0); }
 
    bool push (Telement* item) {
        bool wasFull = isFull ();
        DEBUG_DBG ("Add element. Buffer was %s\n", wasFull ? "full" : "not full");
        DEBUG_DBG ("Before -- > ReadIdx: %d. WriteIdx: %d. Size: %d\n", readIndex, writeIndex, numElements);
        memcpy (&(buffer[writeIndex]), item, sizeof (Telement));
        //Serial.printf ("Copied: %d bytes\n", sizeof (Telement));
        writeIndex++;
        if (writeIndex >= maxSize) {
            writeIndex %= maxSize;
        }
        if (wasFull) { // old value is no longer valid
            readIndex++;
            if (readIndex >= maxSize) {
                readIndex %= maxSize;
            }
        } else {
            numElements++;
        }
        DEBUG_DBG ("After -- > ReadIdx: %d. WriteIdx: %d. Size: %d\n", readIndex, writeIndex, numElements);
        return !wasFull;
    }
 
    bool pop () {
        bool wasEmpty = empty ();
        DEBUG_DBG ("Remove element. Buffer was %s\n", wasEmpty ? "empty" : "not empty");
        DEBUG_DBG ("Before -- > ReadIdx: %d. WriteIdx: %d. Size: %d\n", readIndex, writeIndex, numElements);
        if (!wasEmpty) {
            readIndex++;
            if (readIndex >= maxSize) {
                readIndex %= maxSize;
            }
            numElements--;
        }
        DEBUG_DBG ("After -- > ReadIdx: %d. WriteIdx: %d. Size: %d\n", readIndex, writeIndex, numElements);
        return !wasEmpty;
    }
 
    Telement* front () {
        DEBUG_DBG ("Read element. ReadIdx: %d. WriteIdx: %d. Size: %d\n", readIndex, writeIndex, numElements);
        if (!empty ()) {
            return &(buffer[readIndex]);
        } else {
            return NULL;
        }
    }
};
 
class EnigmaIOTGatewayClass {
protected:
    uint8_t myPublicKey[KEY_LENGTH]; 
    bool flashTx = false; 
    volatile bool flashRx = false; 
    node_t node; 
    NodeList nodelist; 
    Comms_halClass* comm; 
    int8_t txled = -1; 
    int8_t rxled = -1; 
    unsigned long txLedOnTime; 
    unsigned long rxLedOnTime; 
    onGwDataRx_t notifyData; 
    onNewNode_t notifyNewNode; 
    onNodeDisconnected_t notifyNodeDisconnection; 
    bool useCounter = true; 
    gateway_config_t gwConfig; 
    //char networkKey[KEY_LENGTH]; ///< @brief Temporary store for textual network key
    char plainNetKey[KEY_LENGTH];
#ifdef ESP32
    portMUX_TYPE myMutex = portMUX_INITIALIZER_UNLOCKED; 
#endif
    msg_queue_item_t tempBuffer; 
 
    EnigmaIOTRingBuffer<msg_queue_item_t>* input_queue; 
 
    AsyncWebServer* server; 
    DNSServer* dns; 
    AsyncWiFiManager* wifiManager; 
    onWiFiManagerExit_t notifyWiFiManagerExit; 
    onWiFiManagerStarted_t notifyWiFiManagerStarted; 
 
    static void doSave (void);
 
    bool serverHello (const uint8_t* key, Node* node);
 
    bool processClientHello (const uint8_t mac[ENIGMAIOT_ADDR_LEN], const uint8_t* buf, size_t count, Node* node);
 
    bool processClockRequest (const uint8_t mac[ENIGMAIOT_ADDR_LEN], const uint8_t* buf, size_t count, Node* node);
 
    bool clockResponse (Node* node);
 
    bool invalidateKey (Node* node, gwInvalidateReason_t reason);
 
    bool processDataMessage (const uint8_t mac[ENIGMAIOT_ADDR_LEN], uint8_t* buf, size_t count, Node* node, bool encrypted = true);
 
    bool processUnencryptedDataMessage (const uint8_t mac[ENIGMAIOT_ADDR_LEN], uint8_t* buf, size_t count, Node* node);
 
    bool downstreamDataMessage (Node* node, const uint8_t* data, size_t len, control_message_type_t controlData, gatewayPayloadEncoding_t encoding = ENIGMAIOT);
 
    bool processControlMessage (const uint8_t mac[ENIGMAIOT_ADDR_LEN], uint8_t* buf, size_t count, Node* node);
 
    bool processNodeNameSet (const uint8_t mac[ENIGMAIOT_ADDR_LEN], uint8_t* buf, size_t count, Node* node);
 
    bool nodeNameSetRespose (Node* node, int8_t error);
 
    void manageMessage (const uint8_t* mac, uint8_t* buf, uint8_t count);
 
    static void rx_cb (uint8_t* mac_addr, uint8_t* data, uint8_t len);
 
    static void tx_cb (uint8_t* mac_addr, uint8_t status);
 
    void getStatus (uint8_t* mac_addr, uint8_t status);
 
    bool loadFlashData ();
 
    bool saveFlashData ();
 
public:
    bool getShouldSave ();
 
    char* getNetworkName () {
        return gwConfig.networkName;
    }
 
    char* getNetworkKey (bool plain = false) {
        if (plain)
            return (char*)(plainNetKey);
        else
            return (char*)(gwConfig.networkKey);
    }
 
    void addWiFiManagerParameter (AsyncWiFiManagerParameter* p) {
        if (wifiManager) {
            wifiManager->addParameter (p);
        }
    }
 
    void onWiFiManagerExit (onWiFiManagerExit_t handle) {
        notifyWiFiManagerExit = handle;
    }
 
    void onWiFiManagerStarted (onWiFiManagerStarted_t handle) {
        notifyWiFiManagerStarted = handle;
    }
 
    bool configWiFiManager ();
 
    void begin (Comms_halClass* comm, uint8_t* networkKey = NULL, bool useDataCounter = true);
 
    void handle ();
 
    void setTxLed (uint8_t led, time_t onTime = FLASH_LED_TIME);
 
    void setRxLed (uint8_t led, time_t onTime = FLASH_LED_TIME);
 
    void onDataRx (onGwDataRx_t handler) {
        notifyData = handler;
    }
 
    double getPER (uint8_t* address);
 
    uint32_t getTotalPackets (uint8_t* address);
 
    uint32_t getErrorPackets (uint8_t* address);
 
    double getPacketsHour (uint8_t* address);
 
    bool sendDownstream (uint8_t* mac, const uint8_t* data, size_t len, control_message_type_t controlData, gatewayPayloadEncoding_t payload_type = RAW, char* nodeName = NULL);
 
    void onNewNode (onNewNode_t handler) {
        notifyNewNode = handler;
    }
 
    void onNodeDisconnected (onNodeDisconnected_t handler) {
        notifyNodeDisconnection = handler;
    }
 
    bool addInputMsgQueue (const uint8_t* addr, const uint8_t* msg, size_t len);
 
    msg_queue_item_t* getInputMsgQueue (msg_queue_item_t* buffer);
 
    void popInputMsgQueue ();
 
    int getActiveNodesNumber () {
        return nodelist.countActiveNodes ();
    }
 
    NodeList* getNodes () {
        return &nodelist;
    }
 
};
 
extern EnigmaIOTGatewayClass EnigmaIOTGateway;
 
#endif