EnigmaIOTNode.h

Go to the documentation of this file.

 
#ifndef _ENIGMAIOTNODE_h
#define _ENIGMAIOTNODE_h
//#ifdef ESP8266
 
#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif
 
#include "EnigmaIoTconfig.h"
#include "cryptModule.h"
#include "helperFunctions.h"
#include "Comms_hal.h"
#include "NodeList.h"
#include <cstddef>
#include <cstdint>
#include <ESPAsyncWebServer.h>
#include <ESPAsyncWiFiManager.h>
 
#define LED_ON LOW
#define LED_OFF !LED_ON
 
enum nodeMessageType {
    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, 
    HA_DISCOVERY_MESSAGE = 0x08, 
    DOWNSTREAM_BRCAST_CTRL_DATA = 0x84, 
    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 nodePayloadEncoding_t {
    RAW = 0x00, 
    CAYENNELPP = 0x81, 
    PROT_BUF = 0x82, 
    MSG_PACK = 0x83, 
    BSON = 0x84, 
    CBOR = 0x85, 
    SMILE = 0x86 
};
 
enum dataMessageType_t {
    DATA_TYPE,      
    CONTROL_TYPE,   
    HA_DISC_TYPE    
};
 
 
enum nodeInvalidateReason_t {
    UNKNOWN_ERROR = 0x00, 
    WRONG_CLIENT_HELLO = 0x01, 
    WRONG_DATA = 0x03, 
    UNREGISTERED_NODE = 0x04, 
    KEY_EXPIRED = 0x05 
};
 
typedef struct {
    uint32_t crc32; 
    uint8_t nodeKey[KEY_LENGTH]; 
    uint16_t nodeId; 
    uint8_t channel /*= DEFAULT_CHANNEL*/; 
    uint8_t gateway[ENIGMAIOT_ADDR_LEN]; 
    int8_t rssi; 
    uint8_t networkKey[KEY_LENGTH]; 
    char networkName[NETWORK_NAME_LENGTH]; 
    bool sleepy; 
    uint32_t sleepTime /*= 0*/; 
    char nodeName[NODE_NAME_LENGTH + 1]; 
    uint8_t commErrors /*= 0*/; 
    bool nodeKeyValid /* = false*/; 
    uint8_t broadcastKey[KEY_LENGTH]; 
    bool broadcastKeyValid /* = false*/; 
    bool broadcastKeyRequested /* = false*/; 
    status_t nodeRegisterStatus /*= UNREGISTERED*/; 
    uint16_t lastMessageCounter; 
    uint16_t lastControlCounter; 
    uint16_t lastDownlinkMsgCounter; 
} rtcmem_data_t;
 
typedef nodeMessageType nodeMessageType_t;
 
#if defined ARDUINO_ARCH_ESP8266 || defined ARDUINO_ARCH_ESP32
#include <functional>
typedef std::function<void (const uint8_t* mac, const uint8_t* buf, uint8_t len, nodeMessageType_t command, nodePayloadEncoding_t payloadEncoding)> onNodeDataRx_t;
typedef std::function<void ()> onConnected_t;
typedef std::function<void (nodeInvalidateReason_t reason)> onDisconnected_t;
typedef std::function<void (bool status)> onWiFiManagerExit_t;
typedef std::function<void (void)> simpleEventHandler_t;
#else
typedef void (*onNodeDataRx_t)(const uint8_t* mac, const uint8_t* buf, uint8_t len, nodeMessageType_t command, nodePayloadEncoding_t payloadEncoding);
typedef void (*onConnected_t)();
typedef void (*onDisconnected_t)(nodeInvalidateReason_t reason);
typedef void (*onWiFiManagerExit_t)(bool status);
typedef void (*onWiFiManagerStarted_t)(void);
#endif
 
class EnigmaIOTNodeClass {
protected:
    Node node; 
    bool flashBlue = false; 
    int8_t led = -1; 
    unsigned int ledOnTime; 
    Comms_halClass* comm; 
    onNodeDataRx_t notifyData; 
    onConnected_t notifyConnection; 
    onDisconnected_t notifyDisconnection; 
    bool useCounter = true; 
    rtcmem_data_t rtcmem_data; 
    bool sleepRequested = false; 
    uint64_t sleepTime; 
    uint8_t dataMessageSent[MAX_MESSAGE_LENGTH]; 
    uint8_t dataMessageSentLength = 0; 
    bool dataMessageSendPending = false; 
    nodePayloadEncoding_t dataMessageSendEncoding = RAW; 
    bool dataMessageEncrypt = true; 
    nodeInvalidateReason_t invalidateReason = UNKNOWN_ERROR; 
    bool otaRunning = false; 
    bool otaError = false; 
    bool protectOTA = false; 
    time_t lastOTAmsg; 
    boolean indentifying = false; 
    time_t identifyStart; 
    clock_t timeSyncPeriod = QUICK_SYNC_TIME; 
    bool clockSyncEnabled = false; 
    bool shouldRestart = false; 
    restartReason_t restartReason; 
    bool gatewaySearchStarted = false; 
    bool requestSearchGateway = false; 
    bool requestReportRSSI = false; 
    bool configCleared = false; 
    int resetPin = -1; 
    AsyncWiFiManager* wifiManager; 
    onWiFiManagerExit_t notifyWiFiManagerExit; 
    simpleEventHandler_t notifyWiFiManagerStarted; 
    time_t cycleStartedTime; 
    int16_t lastBroadcastMsgCounter; 
 
    bool checkCRC (const uint8_t* buf, size_t count, uint32_t* crc);
 
    void startIdentifying (time_t period);
 
    void stopIdentifying ();
 
    bool loadRTCData ();
 
    bool loadFlashData ();
 
    bool saveFlashData (bool fsOpen = false);
 
    bool configWiFiManager (rtcmem_data_t* data);
 
    void sendRestart ();
 
    bool clientHello ();
 
    bool clockRequest ();
 
    bool processClockResponse (const uint8_t* mac, const uint8_t* buf, size_t count);
 
    bool processServerHello (const uint8_t* mac, const uint8_t* buf, size_t count);
 
    nodeInvalidateReason_t processInvalidateKey (const uint8_t* mac, const uint8_t* buf, size_t count);
 
    bool processBroadcastKeyMessage (const uint8_t* mac, const uint8_t* buf, size_t count);
 
    bool dataMessage (const uint8_t* data, size_t len, dataMessageType_t dataMsgType = DATA_TYPE, bool encrypt = true, nodePayloadEncoding_t payloadEncoding = CAYENNELPP);
 
    bool unencryptedDataMessage (const uint8_t* data, size_t len, dataMessageType_t dataMsgType = DATA_TYPE, nodePayloadEncoding_t payloadEncoding = CAYENNELPP);
 
    bool processOTACommand (const uint8_t* mac, const uint8_t* data, uint8_t len);
 
    bool processControlCommand (const uint8_t* mac, const uint8_t* data, size_t len, bool broadcast);
 
    bool processDownstreamData (const uint8_t* mac, const uint8_t* buf, size_t count, bool control = false);
 
    void manageMessage (const uint8_t* mac, const uint8_t* buf, uint8_t count);
 
    void getStatus (uint8_t* mac_addr, uint8_t status);
 
    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);
 
    bool processGetSleepTimeCommand (const uint8_t* mac, const uint8_t* buf, uint8_t len);
 
    bool processSetSleepTimeCommand (const uint8_t* mac, const uint8_t* buf, uint8_t len);
 
    bool processSetIdentifyCommand (const uint8_t* mac, const uint8_t* buf, uint8_t len);
 
    bool processSetResetConfigCommand (const uint8_t* mac, const uint8_t* buf, uint8_t len);
 
    bool processSetRestartCommand (const uint8_t* mac, const uint8_t* buf, uint8_t len);
 
    bool processVersionCommand (const uint8_t* mac, const uint8_t* buf, uint8_t len);
 
    bool sendData (const uint8_t* data, size_t len, dataMessageType_t dataMsgType, bool encrypt = true, nodePayloadEncoding_t payloadEncoding = CAYENNELPP);
 
    bool searchForGateway (rtcmem_data_t* data, bool shouldStoreData = false);
 
    void clearRTC ();
 
    void clearFlash ();
 
    bool saveRTCData ();
 
    void checkResetButton ();
 
    bool reportRSSI ();
 
    bool processGetRSSICommand (const uint8_t* mac, const uint8_t* data, uint8_t len);
 
    bool processGetNameCommand (const uint8_t* mac, const uint8_t* data, uint8_t len);
 
    bool processSetNameResponse (const uint8_t* mac, const uint8_t* data, uint8_t len);
 
    bool processSetNameCommand (const uint8_t* mac, const uint8_t* data, uint8_t len);
 
    bool sendNodeNameSet (const char* name);
 
public:
    void begin (Comms_halClass* comm, uint8_t* gateway = NULL, uint8_t* networkKey = NULL, bool useCounter = true, bool sleepy = true);
 
    void stop ();
 
    void restart (restartReason_t reason, bool reboot = true);
 
    void setSleepTime (uint32_t sleepTime, bool forceSleepForever = false);
 
    bool setNodeAddress (uint8_t address[ENIGMAIOT_ADDR_LEN]);
 
    uint32_t getSleepTime ();
 
    bool broadcastIsEnabled () {
        return node.broadcastIsEnabled ();
    }
 
    void enableBroadcast (bool broadcast = true) {
#ifndef DISABLE_BRCAST
        node.enableBroadcast (broadcast);
        rtcmem_data.broadcastKeyValid = false;
        rtcmem_data.broadcastKeyRequested = false; // Key is not requested yet
#endif
    }
 
    void handle ();
 
    void enableClockSync (bool clockSync = true) {
        setenv ("TZ", TZINFO, 1);
        tzset ();
        clockSyncEnabled = clockSync;
    }
 
    void setLed (uint8_t led, time_t onTime = FLASH_LED_TIME);
 
    void setResetPin (int pin);
 
    bool sendData (const uint8_t* data, size_t len, nodePayloadEncoding_t payloadEncoding = CAYENNELPP) {
        return sendData (data, len, DATA_TYPE, true, payloadEncoding);
    }
 
    bool sendHADiscoveryMessage (const uint8_t* data, size_t len);
 
 
    bool sendUnencryptedData (const uint8_t* data, size_t len, nodePayloadEncoding_t payloadEncoding = CAYENNELPP) {
        return sendData (data, len, DATA_TYPE, false, payloadEncoding);
    }
 
    void onDataRx (onNodeDataRx_t handler) {
        notifyData = handler;
    }
 
    void onConnected (onConnected_t handler) {
        notifyConnection = handler;
    }
 
    void onDisconnected (onDisconnected_t handler) {
        notifyDisconnection = handler;
    }
 
    void onWiFiManagerExit (onWiFiManagerExit_t handle) {
        notifyWiFiManagerExit = handle;
    }
 
    void onWiFiManagerStarted (simpleEventHandler_t handle) {
        notifyWiFiManagerStarted = handle;
    }
 
    void addWiFiManagerParameter (AsyncWiFiManagerParameter* p) {
        if (wifiManager) {
            wifiManager->addParameter (p);
        }
    }
 
    void sleep ();
 
    int64_t clock ();
 
    time_t unixtime ();
 
    bool hasClockSync ();
 
    bool isRegistered () {
        return node.isRegistered ();
    }
 
    int8_t getRSSI ();
 
    void resetConfig ();
 
    bool getOTArunning () {
        return otaRunning;
    }
 
    Node* getNode () {
        return &node;
    }
 
};
 
extern EnigmaIOTNodeClass EnigmaIOTNode;
 
//#endif // ESP8266
#endif // _ENIGMAIOTNODE_h