Settings.h

Go to the documentation of this file.

#pragma once
 
static const uint8_t Version = 16; 
 
 
static const uint8_t MaxWordLength = 32;        
static const uint8_t MaxShotTextLength = 128;   
static const uint16_t MaxLongTextLength = 1280; 
static const uint8_t LogDepth = 4;              
static const uint8_t QueueDepth = 32;           
static const uint8_t MovingAverageDepth = 10;   
 
extern char LongMessage[MaxLongTextLength];  // Temp storage for assembling long messages (REST API - Google Sheets reporting)
extern char ShortMessage[MaxShotTextLength]; // Temp storage for assembling short messages (Log entries, Error messages)
extern char CurrentTime[MaxWordLength];      // Buffer for storing current time in text format
 
static const uint8_t WirelessCSNPin = 49;             
static const uint8_t WirelessCEPin = 53;              
static const uint8_t WirelessDelay = 8;               
static const uint8_t WirelessRetry = 10;              
static const uint8_t WirelessPayloadSize = 32;        
static const uint16_t WirelessMessageTimeout = 500;   
static const uint16_t WirelessReceiveTimeout = 65000; 
 
#define PushingBoxLogRelayID "v755877CF53383E1" 
 
#define MqttPubTopic "Gbox420/"          
#define MqttSubTopic "Gbox420CMD/#"      
#define MqttLwtTopic "Gbox420LWT/"       
#define MqttLwtMessage "Gbox420 Offline" 
 
/*
#define HomeAssistantServerIP "192.168.1.100"               ///< Address of Home Assistant server ip
#define HomeAssistantServerPort 8123                        ///< Address of Home Assistant server port
#define HomeAssistantServerURL "/api/states/sensor.gbox420" ///< Where to send the JSON formatted Log containing sensor readings
#define HomeAssistantServerToken "Authorization: Bearer YOUR-TOKEN" ///< Generate a token in Home Assistant - USERNAME- Security - Long-lived access tokens
*/
 
 
typedef struct
{
  bool Debug = true;  
  bool Metric = true; 
 
  // initialized via Designated initializer https://riptutorial.com/c/example/18609/using-designated-initializers
  struct AeroModuleSettings 
  {
    bool PressureTankPresent; 
    float Duration;           
    uint16_t DayInterval;     
    uint16_t NightInterval;   
    uint8_t PumpSpeed;        
    uint16_t PumpTimeOut;     
    uint16_t PrimingTime;     
    float MaxPressure;        
    float MinPressure;        
  };
  struct AeroModuleSettings AeroModule1 = {.PressureTankPresent = false, .Duration = 3.0, .DayInterval = 6, .NightInterval = 10, .PumpSpeed = 100, .PumpTimeOut = 420, .PrimingTime = 10, .MaxPressure = 7.0, .MinPressure = 5.0};
 
  struct ACMotorModuleSettings 
  {
    uint8_t Speed; 
  };
  struct ACMotorModuleSettings ACMotor1 = {.Speed = 50};
 
  struct AirPumpSettings 
  {
    uint8_t Pin; 
    bool State;  
  };
  struct AirPumpSettings Ap1 = {.Pin = 23, .State = true};
 
  struct DHTSensorSettings 
  {
    uint8_t Pin;  
    uint8_t Type; 
  };
  struct DHTSensorSettings DHT1 = {.Pin = 3, .Type = 22};
 
  struct FanSettings 
  {
    uint8_t OnOffPin; 
    uint8_t SpeedPin; 
    bool State;       
    bool HighSpeed;   
  };
  struct FanSettings FanI = {.OnOffPin = 25, .SpeedPin = 26, .State = true, .HighSpeed = true};
  struct FanSettings FanE = {.OnOffPin = 27, .SpeedPin = 28, .State = true, .HighSpeed = true};
 
  /*
  // PWM adjusted AC signal - Need to move this to a dedicated module, Mega already uses interrupts to talk to ESP-link and it messes with counting the phase zero crossings
  struct Fan_PWMSettings ///< Fan default settings
  {
    uint8_t ZeroCrossingPin; ///< On Arduino Mega2560 and Nano this has to be D2 pin
    uint8_t PWMPin;          ///< PWM capable digital pin
    bool State;              ///< ON or OFF
    uint8_t MinSpeed;        ///< Limit the lowest output (%)
    uint8_t Speed;           ///< Speed between 0-100 (%)  (Real output mapped between MinSpeed - 100)
  };
  struct Fan_PWMSettings FanI = {.Status = true, .ZeroCrossingPin = 2, .PWMPin = 9, .State = true, .MinSpeed = 35, .Speed = 80};
  struct Fan_PWMSettings FanE = {.Status = true, .ZeroCrossingPin = 2, .PWMPin = 10, .State = true, .MinSpeed = 35, .Speed = 80};
  */
 
  struct MainModuleSettings 
  {
    bool SerialReportDate;             
    bool SerialReportMemory;           
    bool SerialReportJSON;             
    bool SerialReportJSONFriendly;     
    bool SerialReportWireless;         
    bool ReportToGoogleSheets;         
    uint16_t SheetsReportingFrequency; 
    bool ReportToMqtt;                 
    uint16_t MQTTReportFrequency;      
  };
  struct MainModuleSettings Main1 = {.SerialReportDate = true, .SerialReportMemory = true, .SerialReportJSON = true, .SerialReportJSONFriendly = true, .SerialReportWireless = true, .ReportToGoogleSheets = false, .SheetsReportingFrequency = 30, .ReportToMqtt = true, .MQTTReportFrequency = 5};
 
  struct HempyModuleSettings 
  {
    float StartWeight_B1;       
    float WateringIncrement_B1; 
    float EvaporationTarget_B1; 
    float DrainTargetWeight_B1; 
    float MaxWeight_B1;         
    uint8_t PumpSpeed_B1;       
    uint16_t PumpTimeOut_B1;    
    uint16_t DrainWaitTime_B1;  
    float StartWeight_B2;       
    float WateringIncrement_B2; 
    float EvaporationTarget_B2; 
    float DrainTargetWeight_B2; 
    float MaxWeight_B2;         
    uint8_t PumpSpeed_B2;       
    uint16_t PumpTimeOut_B2;    
    uint16_t DrainWaitTime_B2;  
  };
  struct HempyModuleSettings HempyModule1 = {.StartWeight_B1 = 16, .WateringIncrement_B1 = 0.3, .EvaporationTarget_B1 = 2.0, .DrainTargetWeight_B1 = 0.1, .MaxWeight_B1 = 20, .PumpSpeed_B1 = 35, .PumpTimeOut_B1 = 60, .DrainWaitTime_B1 = 300, .StartWeight_B2 = 16, .WateringIncrement_B2 = 0.3, .EvaporationTarget_B2 = 2.0, .DrainTargetWeight_B2 = 0.1, .MaxWeight_B2 = 20.0, .PumpSpeed_B2 = 35, .PumpTimeOut_B2 = 60, .DrainWaitTime_B2 = 300};
 
  struct LightSensorSettings 
  {
    uint8_t DigitalPin; 
    uint8_t AnalogPin;  
  };
  struct LightSensorSettings Ls1 = {.DigitalPin = 4, .AnalogPin = A0};
 
  struct LightsSettings 
  {
    bool Status;              
    uint8_t RelayPin;         
    uint8_t DimmingPin;       
    uint8_t DimmingLimit;     
    uint8_t DimmingDuration;  
    uint8_t Brightness;       
    bool TimerEnabled;        
    uint8_t OnHour;           
    uint8_t OnMinute;         
    uint8_t OffHour;          
    uint8_t OffMinute;        
    bool FadingEnabled;       
    uint16_t FadingInterval;  
    uint8_t FadingIncrements; 
  };
  struct LightsSettings Lt1 = {.Status = false, .RelayPin = 29, .DimmingPin = 11, .DimmingLimit = 16, .DimmingDuration = 10, .Brightness = 75, .TimerEnabled = true, .OnHour = 4, .OnMinute = 20, .OffHour = 16, .OffMinute = 20, .FadingEnabled = false, .FadingInterval = 1, .FadingIncrements = 1}; 
  struct LightsSettings Lt2 = {.Status = false, .RelayPin = 24, .DimmingPin = 12, .DimmingLimit = 6, .DimmingDuration = 10, .Brightness = 55, .TimerEnabled = false, .OnHour = 4, .OnMinute = 20, .OffHour = 16, .OffMinute = 20, .FadingEnabled = false, .FadingInterval = 1, .FadingIncrements = 1}; 
 
  struct ReservoirModuleSettings 
  {
    // ReservoirModuleSettings() :  {}
  };
  struct ReservoirModuleSettings ReservoirMod1 = {};
 
  struct SoundSettings 
  {
    uint8_t Pin;  
    bool Enabled; 
  };
  struct SoundSettings Sound1 = {.Pin = 2, .Enabled = true};
 
  uint8_t CompatibilityVersion = Version; 
} Settings;
 
void saveSettings(Settings *ToSave);
Settings *loadSettings(bool ResetEEPROM = false);
void restoreDefaults();