HCesp/WiFiHost.h

#ifndef __WIFI_HOST_H
#define __WIFI_HOST_H
#include "HermitCrab.h"
#ifdef ESP8266
#include <ESP8266WiFi.h>
#else
#include <WiFi.h>
#endif
#include <WiFiUdp.h>

#define UDP_PORT	    4949
#define SERVER_PORT		3939
#define UDP_EXTERNAL_PORT (UDP_PORT + 1)
#define TCP_EXTERNAL_PORT (SERVER_PORT + 1)
#define CONNECT_TIMEOUT_MS 5000

enum UDP_MESSAGE {
    MESSAGE_HEARTBEAT,
    MESSAGE_IP,
    MESSAGE_NOTFOUND,
    MESSAGE_CONFIG_SAVE,
    MESSAGE_CONFIG_SEND,
    MESSAGE_AP,
    MESSAGE_QUERY_IP,
    MESSAGE_UPDATE_STATUS,
    MESSAGE_UPDATE_CONFIG,



    MESSAGE_COUNT,
    MESSAGE_RESET = UDP_EXTERNAL_PORT,
};

enum OPCODE_TYPE {
  OP_RECV_ONLY,
  OP_RECV_SAVE,
};

enum OPERATION_MODE {
    MODE_WAITING,
    MODE_PACKET,
    MODE_SEND,
    MODE_RECV,
    MODE_EXTERNAL_SERVER
};

enum ENUM_COMMAND
{
    // Connection & control
    CMD_HEARTBEAT = 1,  // 1 HeartBeat - prevents disconnect from the host
    CMD_HELLO,       // 0 Hello
    CMD_DROP_CONNECTION,
    CMD_RESET_REASON,
    CMD_RESTART,
    CMD_SEND_HISTORY,
    CMD_RESET_SENSOR,
    CMD_RESET_DISPLAY,
	
    // Config
    CMD_INIT_CONFIG,
    CMD_LOAD_CONFIG,
    CMD_SAVE_CONFIG,
    CMD_SEND_CONFIG,
    CMD_RECV_CONFIG,
    CMD_SET_DEVICE_PARAM,
    CMD_GET_DEVICE_PARAM,
   
    // control
    CMD_SET_CONTROL,
    CMD_GET_CONTROL,

    // Set
    CMD_SET_TEMP_TARGET,
    CMD_SET_TEMP_TARGET_NIGHT,
    CMD_SET_HUMID_TARGET,
    CMD_SET_SENSOR_OFFSET,
    CMD_SET_HEATER1_DUTY,
    CMD_SET_MANUAL_HEATER1,
    CMD_SET_HEATER2_DUTY,
    CMD_SET_MANUAL_HEATER2,
    CMD_SET_MIST_DUTY,
    CMD_SET_MANUAL_MIST,
    CMD_SET_FAN_DUTY,
    CMD_SET_MANUAL_FAN,
    CMD_SET_MOTOR_DUTY,
    CMD_SET_MANUAL_MOTOR,
    CMD_SET_LIGHT_DUTY,
    CMD_SET_MANUAL_LIGHT,
    CMD_SET_TIME_NIGHT,
    CMD_SET_WIFI_CLIENT_DISPLAY, // Graph TempHigh, TempLow, TimeScale etc.
    
    // PID
    CMD_INIT_PID_PARAM,
    CMD_LOAD_PID_PARAM,
    CMD_SAVE_PID_PARAM,
    CMD_SET_PID,
    CMD_GET_PID,
   
    // End of valid command
    CMD_COUNT
};

#pragma pack(push)  /* push current alignment to stack */
#pragma pack(1)     /* set alignment to 1 byte boundary */
// TCP Packet
typedef struct TCP_PACKET_STRUCT
{
    uint16_t        sig1;
    uint16_t        len;
    uint16_t        cmd;
    uint16_t        op;    // 8
    uint32_t        time;  // 4 : 12
    union {
        char     ch[40];
        uint8_t  by[40];
        int16_t  n16[20];
        uint16_t u16[20];
        int32_t  n32[10];
        uint32_t u32[10];
        float    f[10];
        float   f16[20];
        STATUS_TYPE  status;
        DEVICE_PARAM_TYPE device;
    };                      //40 : 52
    uint16_t        sig2;   // 2 : 54
} TCP_PACKET;

// UDP Packet
typedef struct UDP_PACKET_STRUCT
{
    uint16_t        sig1;
    uint16_t        m_nSize;
    uint16_t        m_nMessage;
    uint16_t        m_nDeviceType;
    uint16_t        m_nResetReason; 
    // 10
    uint32_t        m_nChipID;
    uint32_t        m_nDeviceID;  
    // 18
    union {
        uint32_t    m_nVersion;
        uint32_t    clock;
    };
    // 22
    union {
        uint32_t    dwIPAddress;
        uint8_t     byIPAddress[4];
    };
    // 26
    uint16_t        m_nPort;
    // 28
    uint8_t         m_MACAddress[20]; 
    // 48
    char            m_sDeviceName[32]; 
    // 80
    union {
        char    m_sService[32];
        STATUS_TYPE status;             // 
    };
    // 112
    char    m_sCompanyName[32];
    // 144
    uint16_t        sig2;
    // Size: 146
} UDP_PACKET;

typedef struct {
    UDP_PACKET udp;
    CONFIG_TYPE con;
} UDP_CONFIG_TYPE;

#pragma pack(pop)   /* restore original alignment from stack */

class CWiFiHost
{
public:
	void Setup();
    void Stop();
	void Loop(unsigned long clock);
	inline bool isConnected() { return m_bClientConnected; }
	void CloseConnection();
    void SendHeartBeat(unsigned long clock);
    void MonitorUDP();
    //inline void setPublicIPPort(uint32_t ip, uint16_t port) { m_dwPublicIP = ip; m_nPublicPort = port; }

private:
    //void setupUDP();
    //void loopUDP(unsigned long clock);
    //bool checkOTA(bool bForceUpdate);

	void CheckClient(unsigned long clock);
	void ProcessPacket(TCP_PACKET& pkt);
    void SendHeartBeat();
	int  SendConfig();
    //void FillPacket();

private:
	int  SendPacket(TCP_PACKET& pkt);
	size_t  SendData(const uint8_t* data, size_t size);
    bool SendData(unsigned long clockMills);
	size_t  ReceiveData(uint8_t* data, size_t size);
    bool  ReceiveData(unsigned long clockMills);
    void Restart();

    // Data Send/Receive Mode
    char   *m_pDataSend_data;
    size_t  m_nDataSend_size;
    size_t  m_nDataSend_sent;

    char   *m_pDataReceive_data;
    size_t  m_nDataReceive_size;
    size_t  m_nDataReceive_received;

    bool    m_bReceiveConfigPending;
    bool    m_bSaveReceivedConfig;
    bool    m_bSendHistoryPending;
    int16_t m_nPendingHistoryCount;

    // SocketConnection
    IPAddress externalServerIP;
    //int sockfd = -1;
    //unsigned long connectStartTime = 0;
    //bool isConnecting = false;

    //bool initiateConnection(unsigned long clock);
    //bool checkConnection(unsigned long clock);

    // Operation
    uint8_t         m_nMode;
    bool            m_bHelloSent;
	unsigned long m_nLastReceivedTime;
    unsigned long m_nLastHeartBeatSentTime;
    unsigned long m_nLastUDPBroadcastTime;
	volatile bool m_bClientConnected;
    //uint32_t    m_dwPublicIP;
    //uint16_t    m_nPublicPort;

    // Send Status to VisionSoft HeartBeat service
    IPAddress   m_cExternalServerIPAddress;
    
    WiFiUDP     udpLocal, udpExternal;
    WiFiServer  wifiServer; //, wifiExternal;
    WiFiClient  wifiClient;
    UDP_PACKET  packetUDP;
	TCP_PACKET  hostPacket;
	TCP_PACKET  clientPacket;
};

extern CWiFiHost host;
#endif