Gbox420_Nano_Aero_Tank.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"
#include "Thread.h"                 // Splitting functions to threads for timing
#include "StaticThreadController.h" // Grouping threads
#include "SPI.h"                    // Communication with SPI devices
#include "RF24.h"                   // https://github.com/maniacbug/RF24
#include "SerialLog.h"              // Logging messages to Serial
#include "Settings.h"
#include "src/Modules/AeroModule_Tank.h"
#include "src/WirelessCommands_Aero.h" // Structs for wireless communication via the nRF24L01 chip, defines the messages exchanged with the main modul
 
// Global variable initialization
bool &Debug = *new bool;   
bool &Metric = *new bool;
char LongMessage[MaxLongTextLength] = "";            // Temp storage for assembling long messages (REST API - Google Sheets reporting)
char ShortMessage[MaxShotTextLength] = "";           // Temp storage for assembling short messages (Log entries, Error messages)
char CurrentTime[MaxWordLength] = "";                // Buffer for storing current time in text format
void *ReceivedMessage = malloc(WirelessPayloadSize); // Stores a pointer to the latest received data. A void pointer is a pointer that has no associated data type with it. A void pointer can hold address of any type and can be typcasted to any type. Malloc allocates a fixed size memory section and returns the address of it.
uint32_t ReceivedMessageTimestamp = millis();        // Stores the timestamp when the last wireless package was received
 
HardwareSerial &ArduinoSerial = Serial;       // Reference to the Arduino Serial
Settings *ModuleSettings;                     // settings loaded from the EEPROM. Persistent between reboots, defaults are in Settings.h
AeroModule *AeroMod1;                         
RF24 Wireless(WirelessCEPin, WirelessCSNPin); 
 
Thread TimeCriticalThread = Thread();
Thread OneSecThread = Thread();
Thread FiveSecThread = Thread();
Thread MinuteThread = Thread();
StaticThreadController<4> ThreadControl(&TimeCriticalThread, &OneSecThread, &FiveSecThread, &MinuteThread);
 
void setup()
{                              
  ArduinoSerial.begin(115200); 
  pinMode(13, OUTPUT);         
  printf_begin();
  logToSerials(F(""), true, 0);                               
  logToSerials(F("Aeroponics module initializing"), true, 0); 
  wdt_enable(WDTO_8S);                                        
  boot_rww_enable();                                          
  struct AeroModuleCommand BlankCommand = {AeroMessages::AeroModuleCommand1};
  memcpy(ReceivedMessage, &BlankCommand, sizeof(struct AeroModuleCommand)); 
  setSyncProvider(updateTime);
  setSyncInterval(3600); //Sync time every hour with the main module
 
  ModuleSettings = loadSettings();
  Debug = ModuleSettings->Debug;
  Metric = &ModuleSettings->Metric;
 
  InitializeWireless();
 
  TimeCriticalThread.setInterval(100); 
  TimeCriticalThread.onRun(processTimeCriticalStuff);
  OneSecThread.setInterval(1000); 
  OneSecThread.onRun(run1sec);
  FiveSecThread.setInterval(5000);
  FiveSecThread.onRun(run5sec);
  MinuteThread.setInterval(60000);
  MinuteThread.onRun(run1min);
 
  AeroMod1 = new AeroModule(F("Aero1"), &ModuleSettings->Aero1); 
 
  //logToSerials(F("Starting loops:"), true, 0);
}
 
void InitializeWireless()
{
  logToSerials(F("(re)Initializing wireless"), false, 0);
  pinMode(WirelessCSNPin, OUTPUT);
  digitalWrite(WirelessCSNPin, HIGH);
  pinMode(WirelessCEPin, OUTPUT);
  digitalWrite(WirelessCEPin, HIGH);
  Wireless.begin();
  Wireless.powerDown();
  Wireless.setDataRate(RF24_250KBPS);           
  Wireless.setCRCLength(RF24_CRC_16);           
  Wireless.setPALevel(RF24_PA_MAX);             
  Wireless.setPayloadSize(WirelessPayloadSize); 
  Wireless.enableDynamicPayloads();
  Wireless.enableAckPayload();
  Wireless.openReadingPipe(1, WirelessChannel);
  Wireless.startListening();
  Wireless.powerUp();  
  Wireless.flush_tx(); 
  Wireless.flush_rx(); 
  logToSerials(F("done"), true, 3);
  ReceivedMessageTimestamp = millis(); 
}
 
void loop()
{                      
  ThreadControl.run(); 
  getWirelessData();
}
 
 
void processTimeCriticalStuff() 
{
  AeroMod1->processTimeCriticalStuff();
}
 
void run1sec()
{
  wdt_reset(); 
  heartBeat(); 
  AeroMod1->run1sec();
}
 
void run5sec()
{
  wdt_reset();
  AeroMod1->run5sec();
}
 
void run1min()
{
  wdt_reset();
  AeroMod1->run1min();
  getWirelessStatus();
}
 
void heartBeat()
{
  static bool ledStatus;
  ledStatus = !ledStatus;
  digitalWrite(LED_BUILTIN, ledStatus);
}
 
 
void getWirelessData()
{
  if (Wireless.available())
  {
    Wireless.read(ReceivedMessage, WirelessPayloadSize);
    if (timeStatus() != timeSet && ((AeroCommonTemplate *)ReceivedMessage)->SequenceID == AeroMessages::AeroModuleCommand1)
    {
      updateTime(); 
    }
    if (AeroMod1->processCommand(ReceivedMessage))
    {
      ReceivedMessageTimestamp = millis(); //< Reset the timer after the last message was exchanged
    }
  }
  if (millis() - ReceivedMessageTimestamp > WirelessReceiveTimeout)
  {
    InitializeWireless();
  }
}
 
void getWirelessStatus()
{
  if (Debug)
  {
    //logToSerials(F("Wireless report:"), true, 0);
    Wireless.printPrettyDetails();
    logToSerials(F(""), true, 0);
  }
}
 
time_t updateTime()
{
  time_t ReceivedTime = ((AeroModuleCommand *)ReceivedMessage)->Time;
  if (ReceivedTime > 0)
  {
    setTime(ReceivedTime);
    //logToSerials(F("Clock synced"), true, 0);
  }
  else
  {
    //logToSerials(F("Clock out of sync"), true, 0);
  }
  return ReceivedTime;
}