Gbox420_Nano_Hempy.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"                    
#include "RF24.h"                   // https://github.com/maniacbug/RF24
#include "SerialLog.h"              // Logging messages to Serial
#include "Settings.h"
#include "src/Modules/HempyModule.h"
#include "src/WirelessCommands_Hempy.h" // Structs for wireless communication via the nRF24L01 chip, defines the messages exchanged with the main modul
 
// Global variable initialization
bool &Debug = *new bool;                      // Placeholder reference, to be initialized in setup()
bool &Metric = *new bool;                     // Placeholder reference, to be initialized in setup()
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
uint8_t ReceivedMessage[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
HempyModule *HempyMod1;                       // Represents a Hempy bucket with weight sensors and pumps
RF24 Wireless(WirelessCEPin, WirelessCSNPin); // Initialize the NRF24L01 wireless chip (CE, CSN pins are hard wired on the Arduino Nano RF)
 
Thread OneSecThread = Thread();
Thread FiveSecThread = Thread();
Thread MinuteThread = Thread();
StaticThreadController<3> ThreadControl(&OneSecThread, &FiveSecThread, &MinuteThread);
 
void setup()
{                              // put your setup code here, to run once:
  ArduinoSerial.begin(115200); // Nano console output
  pinMode(LED_BUILTIN, OUTPUT);
  printf_begin();
  logToSerials(F(""), true, 0);                          
  logToSerials(F("Hempy module initializing"), true, 0); 
  wdt_enable(WDTO_8S);                                   
  boot_rww_enable();                                     
  struct HempyModuleCommand BlankCommand = {HempyMessages::HempyModuleCommand1};
  memcpy(ReceivedMessage, &BlankCommand, sizeof(struct HempyModuleCommand)); 
  setSyncProvider(updateTime);
  setSyncInterval(3600);           // Sync time every hour with the main module
  ModuleSettings = loadSettings(); 
  Debug = ModuleSettings->Debug;
  Metric = &ModuleSettings->Metric;
  InitializeWireless();           
  OneSecThread.setInterval(1000); 
  OneSecThread.onRun(run1sec);
  FiveSecThread.setInterval(5000);
  FiveSecThread.onRun(run5sec);
  MinuteThread.setInterval(60000);
  MinuteThread.onRun(run1min);
  HempyMod1 = new HempyModule(F("Hempy1"), ModuleSettings->Hemp1); 
  getFreeMemory();
  logToSerials(F("Setup ready, starting loops:"), true, 0);
}
 
void InitializeWireless()
{
  if (Debug)
  {
    logToSerials(F("(re)Initializing wireless transceiver"), 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(); 
  if (Debug)
  {
    logToSerials(F("done"), true, 3);
  }
  ReceivedMessageTimestamp = millis(); 
}
 
void loop()
{                      
  ThreadControl.run(); 
  getWirelessData();   
}
 
 
void run1sec()
{
  wdt_reset(); 
  heartBeat(); 
  HempyMod1->run1sec();
}
 
void run5sec()
{
  wdt_reset();
  HempyMod1->run5sec();
}
 
void run1min()
{
  wdt_reset();
  HempyMod1->run1min();
  // getWirelessStatus();   ///< USES TOO MUCH MEMORY, causes crash
}
 
void heartBeat()
{
  static bool ledStatus;
  ledStatus = !ledStatus;
  digitalWrite(LED_BUILTIN, ledStatus);
}
 
 
void getWirelessData()
{
  if (Wireless.available())
  {
    Wireless.read(ReceivedMessage, WirelessPayloadSize);
    if (timeStatus() != timeSet && ((HempyCommonTemplate *)ReceivedMessage)->SequenceID == HempyMessages::HempyModuleCommand1)
    {
      updateTime(); 
    }
    if (HempyMod1->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);
    wdt_reset();
    Wireless.printPrettyDetails();
    logToSerials(F(""), true, 0);
  }
}
 
time_t updateTime()
{
  time_t ReceivedTime = ((HempyModuleCommand *)ReceivedMessage)->Time;
  if (ReceivedTime > 0)
  {
    setTime(ReceivedTime);
    logToSerials(F("Clock synced"), true, 0);
  }
  return ReceivedTime;
}