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 "EnigmaIOTRingBuffer.h"
#if ENABLE_REST_API
#include "GatewayAPI.h"
#endif // ENABLE_REST_API
 
#include "helperFunctions.h"
 
#define LED_ON LOW
#define LED_OFF !LED_ON
 
enum gatewayMessageType_t {
    SENSOR_DATA = 0x01, 
    SENSOR_BRCAST_DATA = 0x81, 
    UNENCRYPTED_NODE_DATA = 0x11, 
    DOWNSTREAM_DATA_SET = 0x02, 
    DOWNSTREAM_BRCAST_DATA_SET = 0x82, 
    DOWNSTREAM_DATA_GET = 0x12, 
    DOWNSTREAM_BRCAST_DATA_GET = 0x92, 
    CONTROL_DATA = 0x03, 
    DOWNSTREAM_CTRL_DATA = 0x04, 
    DOWNSTREAM_BRCAST_CTRL_DATA = 0x84, 
    HA_DISCOVERY_MESSAGE = 0x08, 
    CLOCK_REQUEST = 0x05, 
    CLOCK_RESPONSE = 0x06, 
    NODE_NAME_SET = 0x07, 
    NODE_NAME_RESULT = 0x17, 
    BROADCAST_KEY_REQUEST = 0x08, 
    BROADCAST_KEY_RESPONSE = 0x18, 
    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, 
    KICKED = 0x06 
};
 
#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;
#if SUPPORT_HA_DISCOVERY
typedef std::function<void (const char* topic, char *message, size_t len)> onHADiscovery_t;
#endif
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)> simpleEventHandler_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 (*simpleEventHandler_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;
 
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; 
#if SUPPORT_HA_DISCOVERY
    onHADiscovery_t notifyHADiscovery; 
#endif
    onNewNode_t notifyNewNode; 
    onNodeDisconnected_t notifyNodeDisconnection; 
    simpleEventHandler_t notifyRestartRequested; 
    bool useCounter = true; 
    gateway_config_t gwConfig; 
    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; 
    simpleEventHandler_t notifyWiFiManagerStarted; 
 
    friend class GatewayAPI;
 
    static void doSave (void);
    
    static void doResetConfig (void);
 
 
    bool serverHello (const uint8_t* key, Node* node);
 
    bool sendBroadcastKey (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, uint64_t t1, uint64_t t2);
 
    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 ();
    
#if SUPPORT_HA_DISCOVERY
 
    bool sendHADiscoveryJSON (uint8_t* address, uint8_t* data, size_t len, const char* networkName, const char* nodeName);
#endif
    
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 (simpleEventHandler_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;
    }
 
#if SUPPORT_HA_DISCOVERY
 
    void onHADiscovery (onHADiscovery_t handler) {
        notifyHADiscovery = handler;
    }
#endif
 
    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;
    }
 
    void onGatewayRestartRequested (simpleEventHandler_t handler) {
        notifyRestartRequested = 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