HCesp/Config.h

# ifndef __CONFIG_H
# define __CONFIG_H

#include <Preferences.h>
#include "HermitCrab.h"


extern const char *strDeviceType[];


enum ENUM_DEVICE_TYPE {
    TYPE_NONE = 0,
    TYPE_TEST,
    TYPE_ESP8266,
    TYPE_ON_OFF,
    TYPE_ZCD,
    TYPE_CAM,
    TYPE_BETA,
    TYPE_BETA_BLE,
    TYPE_DEVICE_END,
    TYPE_CLIENT = 1000,
    TYPE_CLIENT_WIN,
    TYPE_CLIENT_ANDROID
};

enum HEATER_TYPE {
    TYPE_BULB,
    TYPE_IR,
    TYPE_CERAMIC,
    TYPE_ZCD3,
    TYPE_ZCD4,
    TYPE_ZCD5,
    TYPE_ZCD6,
    TYPE_ZCD_CONTROL,
    TYPE_FLUORESCENT = 16,
    TYPE_LED,
    TYPE_UAV,
    TYPE_HEATER_END
};

enum DEVICE_CONTROL_TYPE {
    CONTROL_NONE,
    CONTROL_TEMP_HEAT,
    CONTROL_TEMP_COOL,
    CONTROL_HUMIDITY_INC,
    CONTROL_HUMIDITY_DEC,
    CONTROL_DAY_NIGHT,
    CONTROL_TIME,
    CONTROL_PERIOD,
    CONTROL_TEMP_HEAT_PID,
    CONTROL_TEMP_COOL_PID,
    CONTROL_HUMIDITY_INC_PID,
    CONTROL_HUMIDITY_DEC_PID
};

// Enumeration for the sensor
enum TEMP_SENSOR_TYPE {
    SENSOR_NONE = 0, 
    AHT20,          // AHT20 on 0x38 - default
    AHT2x,          // AHT25 on 0x38 - default
    AHT10_0x39,     // AHT10 on 0x39 - altanative
    NTC,
    BLE_TUYA,
    BLE_XIAOMI_MIJIA,
    BLE_INKBIRD
  };

#pragma pack(push)  /* push current alignment to stack */
#pragma pack(1)     /* set alignment to 1 byte boundary */

typedef struct CONFIG_STRUCT {
    uint16_t m_nSignature1;
    // Block 1 -  Control and EnvironMent
    // Offset 2
    bool  bSmartControl;
    bool  bNightControl;
    bool  bControlTemperature;
    bool  bControlHumidity;
    bool  bCheckAC;
    bool  bAC2_OnOff;
    uint8_t  nNightStartHour, nNightStartMin, nNightEndHour, nNightEndMin;
    float       Kp_Temp2;                   // Load Kp for Temperature control
    float       Kd_Temp2;                   // Load Kd for Temperature control
    float       LR_Temp2;                   // Load learning rate for Temperature
    float       Kp_Temp3;                   // Load Kp for Temperature control
    float       Kd_Temp3;                   // Load Kd for Temperature control
    float       LR_Temp3;                   // Load learning rate for Temperature
    uint8_t ac1ControlMode, ac2ControlMode; // ZCD_CONTROL || PHASE_CONTROL
    uint8_t bPadding1[2]; 
    union {
        uint64_t    nBLESensorAddr2;
        uint8_t     nBLESensorAddrBytes2[8];
    };
    float       Kp_Humid2;
    float       Kd_Humid2;
    float       LR_Humid2;
    char  bExtra[64 - 6 * sizeof(bool) - 8 * sizeof(uint8_t) - 9 * sizeof(float) - sizeof(uint64_t)];
    
    // Block 2 - Sensor and TargetTemperature and Himidity
    // Offset 64 + 2
    int16_t     nTempTarget, nTempTargetNight;    // Target Temperature
    int16_t     nTemp1Offset, nTemp2Offset, nTemp3Offset;
    uint16_t    nHumidTarget, nHumidTargetNight;
    int16_t     nHumid1Offset, nHumid2Offset;
    uint8_t     nTemp1SensorType;               // TempSensor Type enum
    uint8_t     nTemp2SensorType;               // TempSensor Type enum
    int16_t     nTempSafety;
    
    float       Kp_Temp1;                       // Load Kp for Temperature control
    float       Kd_Temp1;                       // Load Kd for Temperature control
    float       LR_Temp1;                       // Load learning rate for Temperature
    float       Kp_Humidity;                    // Load Kp for humidity control
    float       Kd_Humidity;                    // Load Kd for humidity control
    float       LR_Humidity;                    // Load learning rate for humidity
    union {
        uint64_t    nBLESensorAddr;
        uint8_t     nBLESensorAddrBytes[8];
    };
    uint8_t     bNTCNegativePolarity;
    uint8_t     nBLEScanInterval;
    uint8_t     bBLETest;
    char nTempExtra[64 - 10 * sizeof(int16_t) - 6 * sizeof(float) - 5 * sizeof(uint8_t) - sizeof(uint64_t)];

    union {
        struct {
            // Block 3 - AC1 and AC2
            // Offset 128 + 2
            DEVICE_PARAM_TYPE ac1;
            DEVICE_PARAM_TYPE ac2;
            
            // Block 4 - Mist and Fan
            // Offset 192 + 2
            DEVICE_PARAM_TYPE mist;
            DEVICE_PARAM_TYPE fan;
            
            // Block 5 - Motor and Light
            // Offset 256 + 2
            DEVICE_PARAM_TYPE motor;
            DEVICE_PARAM_TYPE light;
        };
        DEVICE_PARAM_TYPE deviceParamArray[6];
    };
    
    // Block 6 - Environment and Operations
    // Offset 320 + 2
    bool   bConfigSaved;
    bool   bStatusSaved;
    float  Kp_Humid3;                    // Load Kd for humidity control
    float  Kd_Humid3;                    // Load Kp for humidity control
    float  LR_Humid3;                    // Load learning rate for humidity
    bool   bSendStatusSerial;
    char   nEnvExtra[32 - 3 * sizeof(bool) - 3*sizeof(float)];
    // Offset 352 + 2
    STATUS_TYPE statusSave;

    // Block 7 - ID and Client Display
    // Offset 384 + 2
    uint32_t m_nChipId;
    uint16_t m_nDeviceType;
    uint16_t m_nPublicPort;
    uint16_t m_nExtraTBD[4];
    // WiFi Client Only
    uint16_t m_nDisplayTime;
    int16_t m_nDisplayTempHigh;
    int16_t m_nDisplayTempLow;
    int16_t m_nTempHigh;
    uint16_t m_fShowRealTime;
    uint16_t m_fShowHistory;
    uint32_t m_nEpochTime;
    uint32_t m_nTimeOffset;
    uint8_t  m_bFahrenheit;
    char   nLongExtra[64 - 3 * sizeof(uint32_t) - 12 * sizeof(uint16_t)- 1 * sizeof(uint8_t)];

    // Block 8 and 9 - WiFi AP ssid and pw
    // Offset 448 + 2 & 512 + 2
    char ssid[64], pw[64];
    
    // Block 10
    // Offset 576 + 2
    char m_sDeviceName[32];
    char m_sMake[32];

    // Block 11
    // Offset 640 + 2
    char m_sModel[32];
    char m_sVersion[12];
    char nModelExtra[64 - 44];

    // Offset 704 + 2
    char padAlign8[4];
    uint16_t m_nSignature2;

#ifdef ESP32    
    // ConfigStruct Size: 712
public:
    void init();
    bool load();
    void save();
    //bool saveToServer();
#endif    
} __attribute__((aligned(8))) CONFIG_TYPE;
#pragma pack(pop)  // Restore previous alignment setting

extern class Preferences preferences;
extern CONFIG_TYPE config;
extern char BLE_SSID[32];
extern char BLE_PW[32];

#endif