Gbox420_Mega_Main.ino

Go to the documentation of this file.

 
#include "Arduino.h"
#include <avr/wdt.h>                        // Watchdog timer for detecting a crash and automatically resetting the board
#include <avr/boot.h>                       // Watchdog timer related bug fix
#include <printf.h>                         // Printing the wireless status message from nRF24L01
#include <TimerThree.h>                     // Interrupt handling for the web server
#include "ELClient.h"                       // ESP-link
#include "ELClientWebServer.h"              // ESP-link - WebServer API
#include "ELClientCmd.h"                    // ESP-link - Get current time from the internet using NTP
#include "ELClientRest.h"                   // ESP-link - REST API
#include "ELClientMqtt.h"                          // ESP-link MQTT protocol for IoT messaging
#include <Thread.h>                         // Logic threading for function timing
#include <StaticThreadController.h>         // Grouping multiple threads
#include "SerialLog.h"                      // Logging to Serial and ESP-link console
#include "Settings.h"                       // EEPROM settings management
#include "src/Modules_Web/MainModule_Web.h" // Main box features and web module
#include <SPI.h>                            // Hardware SPI communication
#include <RF24.h>                           // nRF24L01 wireless radio driver - https://github.com/maniacbug/RF24
 
// Global variable initialization
char LongMessage[MaxLongTextLength] = "";  
char ShortMessage[MaxShotTextLength] = ""; 
char CurrentTime[MaxWordLength] = "";      
 
// Component initialization
HardwareSerial &ArduinoSerial = Serial;      
HardwareSerial &ESPSerial = Serial3;         
ELClient ESPLink(&ESPSerial);                
ELClientWebServer WebServer(&ESPLink);       
ELClientCmd ESPCmd(&ESPLink);                
ELClientRest PushingBoxRestAPI(&ESPLink);    
ELClientRest HomeAssistantRestAPI(&ESPLink); 
ELClientMqtt MqttAPI(&ESPLink);              
Settings *ModuleSettings;                    
bool &Debug = *new bool;                     
bool &Metric = *new bool;                    
bool MqttConnected = false;                  
MainModule *Main1;                           
 
RF24 Wireless(WirelessCEPin, WirelessCSNPin); 
 
// Thread initialization
Thread OneSecThread = Thread();
Thread FiveSecThread = Thread();
Thread MinuteThread = Thread();
StaticThreadController<3> ThreadControl(&OneSecThread, &FiveSecThread, &MinuteThread);
 
void setup()
{                                                       
  ArduinoSerial.begin(115200);                          
  ESPSerial.begin(115200);                              
  pinMode(LED_BUILTIN, OUTPUT);                         
  printf_begin();                                       
  logToSerials(F(""), true, 0);                         
  logToSerials(F("Main module initializing"), true, 0); 
  wdt_enable(WDTO_8S);                                  
  boot_rww_enable();                                    
 
  // Loading settings from EEPROM
  logToSerials(F("Loading settings"), true, 0);
  ModuleSettings = loadSettings();
  Debug = ModuleSettings->Debug;
  Metric = &ModuleSettings->Metric;
 
  logToSerials(F("Setting up ESP-link connection"), true, 0);
  ESPLink.resetCb = &resetWebServer; 
  resetWebServer();                  
  setSyncProvider(getNtpTime);       
  setSyncInterval(86400);            
  if ((ModuleSettings->Main1).ReportToMqtt)
  {
    setupMqtt(); // MQTT message relay setup. Logs "ConnectedCB is XXXX" to serial if successful
  }
  // Threads - Setting up how often threads should be triggered and what functions to call when the trigger fires
  logToSerials(F("Setting up refresh threads"), false, 0);
  OneSecThread.setInterval(1000);
  OneSecThread.onRun(run1sec);
  FiveSecThread.setInterval(5000);
  FiveSecThread.onRun(run5sec);
  MinuteThread.setInterval(60000);
  MinuteThread.onRun(run1min);
  logToSerials(F("done"), true, 3);
 
  // Start interrupts to handle request from ESP-link firmware
  logToSerials(F("Setting up interrupt handler"), false, 0);
  Timer3.initialize(500); 
  Timer3.attachInterrupt(processTimeCriticalStuff);
  Timer3.start();
  logToSerials(F("done"), true, 3);
 
  // Initialize wireless communication with remote Modules
  logToSerials(F("Setting up wireless transceiver"), false, 0);
  Wireless.begin();                                  
  Wireless.setDataRate(RF24_250KBPS);                
  Wireless.setCRCLength(RF24_CRC_16);                
  Wireless.setPALevel(RF24_PA_MAX);                  
  Wireless.setPayloadSize(WirelessPayloadSize);      
  Wireless.enableDynamicPayloads();                  
  Wireless.enableAckPayload();                       
  Wireless.setRetries(WirelessDelay, WirelessRetry); 
  Wireless.stopListening();
  logToSerials(F("done"), true, 3);
 
  // Create the Module objects
  logToSerials(F("Creating Main module"), true, 0);
  Main1 = new MainModule(F("Main1"), &ModuleSettings->Main1, &Wireless); 
 
  //   sendEmailAlert(F("Grow%20box%20(re)started"));
  logToSerials(F("Setup ready, starting loops:"), true, 0);
}
 
void loop()
{
  ThreadControl.run(); 
}
 
void processTimeCriticalStuff()
{
  ESPLink.Process(); 
}
 
// Threads
 
void run1sec()
{
  wdt_reset(); 
  heartBeat(); 
  Main1->run1sec();
}
 
void run5sec()
{
  wdt_reset();
  Main1->run5sec();
}
 
void run1min()
{
  wdt_reset();
  Main1->run1min();
  getWirelessStatus();
}
 
void heartBeat()
{
  static bool ledStatus;
  ledStatus = !ledStatus;
  digitalWrite(LED_BUILTIN, ledStatus);
}
 
// Website related functions
 
void resetWebServer()
{ 
  logToSerials(F("(re)Connecting ESP-link"), false, 1);
  while (!ESPLink.Sync())
  {
    logToSerials(F("."), false, 0);
    delay(1000);
  };
  logToSerials(F(""), true, 0);                           
  if (PushingBoxRestAPI.begin("api.pushingbox.com") == 0) 
  {
    logToSerials(F("PushingBox RestAPI ready"), true, 2);
  }
  else
    logToSerials(F("PushingBox RestAPI failed"), true, 2); 
  /*
  if (HomeAssistantRestAPI.begin(HomeAssistantServerIP, HomeAssistantServerPort, true) == 0) ///< Pre-setup RestAPI with Home Assistant (Not actual connection)
  {
    HomeAssistantRestAPI.setContentType("application/json");
    HomeAssistantRestAPI.setHeader(HomeAssistantServerToken);
 
    logToSerials(F("HomeAssistant RestAPI ready"), true, 2);
  }
  else
    logToSerials(F("HomeAssistant RestAPI failed"), true, 2); ///< If begin returns a negative number the initialization failed
  */
  WebServer.setup();
  URLHandler *GrowBoxHandler = WebServer.createURLHandler("/Main.html.json");      
  GrowBoxHandler->loadCb.attach(&loadCallback);                                    
  GrowBoxHandler->refreshCb.attach(&refreshCallback);                              
  GrowBoxHandler->buttonCb.attach(&buttonCallback);                                
  GrowBoxHandler->setFieldCb.attach(&fieldCallback);                               
  URLHandler *SettingsHandler = WebServer.createURLHandler("/Settings.html.json"); 
  SettingsHandler->loadCb.attach(&settingsLoadCallback);                           
  SettingsHandler->refreshCb.attach(&settingsRefreshCallback);                     
  SettingsHandler->buttonCb.attach(&settingsButtonCallback);                       
  SettingsHandler->setFieldCb.attach(&settingsFieldCallback);                      
  URLHandler *HempyHandler = WebServer.createURLHandler("/Hempy.html.json");       
  HempyHandler->loadCb.attach(&ignoreCallback);                                    
  HempyHandler->refreshCb.attach(&ignoreCallback);                                 
 
  logToSerials(F("ESP-link ready"), true, 1);
}
 
void setupMqtt()
{
 
  MqttAPI.connectedCb.attach(mqttConnected);
  MqttAPI.disconnectedCb.attach(mqttDisconnected);
  MqttAPI.publishedCb.attach(mqttPublished);
  MqttAPI.dataCb.attach(mqttReceived);
 
  memset(&ShortMessage[0], 0, MaxShotTextLength); // reset variable to store the Publish to path
  strcat(ShortMessage, MqttLwtTopic);
  MqttAPI.lwt(ShortMessage, MqttLwtMessage, 0, 1); //(topic,message,qos,retain) declares what message should be sent on it's behalf by the broker after Gbox420 has gone offline.
  MqttAPI.setup();
}
 
void mqttConnected(__attribute__((unused)) void *response)
{
  MqttAPI.subscribe(MqttSubTopic);
  MqttConnected = true;
  // if(Debug) logToSerials(F("MQTT connected"), true);
}
 
void mqttDisconnected(__attribute__((unused)) void *response)
{
  // if(Debug) logToSerials(F("MQTT disconnected"), true);
  MqttConnected = false;
}
 
void mqttPublished(__attribute__((unused)) void *response)
{
  // if(Debug) logToSerials(F("MQTT published"), true);
}
 
void mqttReceived(void *response)
{
  static uint8_t MqttSubTopicLength = strlen(MqttSubTopic) - 1; // Get length of the command topic
  static char command[MaxShotTextLength];
  static char data[MaxShotTextLength];
  ELClientResponse *res = (ELClientResponse *)response;
  String mqttTopic = (*res).popString();
  String mqttData = (*res).popString();
  logToSerials(F("MQTT"), false, 0);
  logToSerials(&mqttTopic, false, 1);
  mqttTopic.remove(0, MqttSubTopicLength); // Cut the known command topic from the arrived topic
  mqttTopic.toCharArray(command, MaxShotTextLength);
  mqttData.toCharArray(data, MaxShotTextLength);
  Main1->commandEventTrigger(command, data);
  Main1->reportToMqttTrigger(true); // send out a fresh report
}
 
static bool SyncInProgress = false; 
 
time_t getNtpTime()
{
  time_t NTPResponse = 0;
  if (!SyncInProgress)
  { // block calling the sync again inside an interrupt while already waiting for a sync to finish
    SyncInProgress = true;
    uint32_t LastRefresh = millis();
    logToSerials(F("Waiting for NTP time"), false, 0);
    while (NTPResponse == 0 && millis() - LastRefresh < 15000)
    {
      NTPResponse = ESPCmd.GetTime();
      if (NTPResponse == 0) {
          delay(1000);
          logToSerials(F("."), false, 0);
          wdt_reset(); 
      }
    }
    SyncInProgress = false;
    if (NTPResponse == 0)
    {
      logToSerials(F("sync failed"), true, 3); // FORCE the library to try again in 60 seconds instead of 1 day
      setSyncInterval(60); 
    }
    else
    {
      logToSerials(F("synchronized"), true, 3); // SUCCESS: Set the interval back to 1 day
      setSyncInterval(86400); 
    }
  }
  return NTPResponse;
}
 
void loadCallback(__attribute__((unused)) char *Url)
{
  Main1->websiteLoadEventTrigger(Url); // Runs through all components that are subscribed to this event
}
 
void refreshCallback(__attribute__((unused)) char *Url)
{
  Main1->websiteRefreshEventTrigger(Url);
}
 
void buttonCallback(char *Button)
{
  logToSerials(F("ESP button:"), false, 0);
  if (strcmp_P(Button, (PGM_P)F("RestoreDef")) == 0)
  {
    restoreDefaults();
  }
  else
  {
    Main1->commandEventTrigger(Button, NULL);
  }
  saveSettings(ModuleSettings);
}
 
void fieldCallback(char *Field)
{ 
  logToSerials(F("ESP field:"), false, 0);
  Main1->commandEventTrigger(Field, WebServer.getArgString());
  saveSettings(ModuleSettings);
}
 
void settingsLoadCallback(__attribute__((unused)) char *Url)
{
  Main1->settingsEvent_Load(Url); // Runs through all components that are subscribed to this event
}
 
void settingsRefreshCallback(__attribute__((unused)) char *Url)
{
  Main1->settingsEvent_Refresh(Url);
}
 
void settingsButtonCallback(char *Button)
{
  if (Debug)
  {
    logToSerials(F("Settings button:"), false, 0);
    logToSerials(&Button, true, 1);
  }
  if (strcmp_P(Button, (PGM_P)F("RestoreDef")) == 0)
  {
    restoreDefaults();
  }
  else
  {
    Main1->settingsEvent_Command(Button, NULL);
  }
  saveSettings(ModuleSettings);
}
 
void settingsFieldCallback(char *Field)
{
  if (Debug)
  {
    logToSerials(F("Settings field:"), false, 0);
    logToSerials(&Field, true, 1);
  }
  Main1->settingsEvent_Command(Field, WebServer.getArgString());
  saveSettings(ModuleSettings);
}
 
void getWirelessStatus()
{
  if (Debug)
  {
    logToSerials(F("Wireless report:"), true, 0);
    Wireless.printPrettyDetails();
    logToSerials(F(""), true, 0);
  }
}
 
void ignoreCallback(__attribute__((unused)) char *Url)
{
}