main.cpp

Go to the documentation of this file.

 
static_assert(__cplusplus >= 201703L, "**** Please define 'gnu++17' in 'platform.txt' ! ****");
static_assert(__cplusplus >= 201703L, "See also : https://github.com/FredM67/PVRouter-3-phase/blob/main/Mk2_fasterControl_Full/README.md");
 
#include <Arduino.h>  // may not be needed, but it's probably a good idea to include this
 
#include "config.h"
#include "calibration.h"
#include "processing.h"
#include "types.h"
#include "utils.h"
#include "utils_relay.h"
#include "utils_display.h"
#include "utils_oled.h"
#include "utils_temp.h"
#include "validation.h"
 
// --------------  general global variables -----------------
//
// Some of these variables are used in multiple blocks so cannot be static.
// For integer maths, some variables need to be 'int32_t'
//

bool forceFullPower()
{
  if constexpr (OVERRIDE_PIN_PRESENT)
  {
    const auto pinState{ getPinState(forcePin) };
 
#ifdef ENABLE_DEBUG
    static uint8_t previousState{ HIGH };
    if (previousState != pinState)
    {
      DBUGLN(!pinState ? F("Trigger override!") : F("End override!"));
    }
 
    previousState = pinState;
#endif
 
    for (auto &bOverrideLoad : Shared::b_overrideLoadOn)
    {
      bOverrideLoad = !pinState;
    }
 
    return !pinState;
  }
  else
  {
    return false;
  }
}

void proceedRotation()
{
  Shared::b_reOrderLoads = true;
 
  // waits till the priorities have been rotated from inside the ISR
  do
  {
    delay(10);
  } while (Shared::b_reOrderLoads);
 
  // prints the (new) load priorities
  logLoadPriorities();
}

bool proceedLoadPrioritiesAndOverridingDualTariff(const int16_t currentTemperature_x100)
{
  constexpr int16_t iTemperatureThreshold_x100{ iTemperatureThreshold * 100 };
  static bool pinOffPeakState{ HIGH };
  const auto pinNewState{ getPinState(dualTariffPin) };
 
  if (pinOffPeakState && !pinNewState)
  {
    // we start off-peak period
    DBUGLN(F("Change to off-peak period!"));
 
    ul_TimeOffPeak = millis();
 
    if constexpr (PRIORITY_ROTATION == RotationModes::AUTO)
    {
      proceedRotation();
    }
  }
  else
  {
    const auto ulElapsedTime{ static_cast< uint32_t >(millis() - ul_TimeOffPeak) };
    const auto pinState{ getPinState(forcePin) };
 
    for (uint8_t i = 0; i < NO_OF_DUMPLOADS; ++i)
    {
      // for each load, if we're inside off-peak period and within the 'force period', trigger the ISR to turn the load ON
      if (!pinOffPeakState && !pinNewState && (ulElapsedTime >= rg_OffsetForce[i][0]) && (ulElapsedTime < rg_OffsetForce[i][1]))
      {
        Shared::b_overrideLoadOn[i] = !pinState || (currentTemperature_x100 <= iTemperatureThreshold_x100);
      }
      else
      {
        Shared::b_overrideLoadOn[i] = !pinState;
      }
    }
  }
  // end of off-peak period
  if (!pinOffPeakState && pinNewState)
  {
    DBUGLN(F("Change to peak period!"));
  }
 
  pinOffPeakState = pinNewState;
 
  return (LOW == pinOffPeakState);
}

bool proceedLoadPrioritiesAndOverriding(const int16_t currentTemperature_x100)
{
  if constexpr (DUAL_TARIFF)
  {
    return proceedLoadPrioritiesAndOverridingDualTariff(currentTemperature_x100);
  }
 
  if constexpr (EMONESP_CONTROL)
  {
    static uint8_t pinRotationState{ HIGH };
    const auto pinNewState{ getPinState(rotationPin) };
 
    if (pinRotationState && !pinNewState)
    {
      DBUGLN(F("Trigger rotation!"));
 
      proceedRotation();
    }
    pinRotationState = pinNewState;
  }
  else if (ROTATION_AFTER_SECONDS < Shared::absenceOfDivertedEnergyCountInSeconds)
  {
    if constexpr (PRIORITY_ROTATION == RotationModes::AUTO)
    {
      proceedRotation();
    }
    Shared::absenceOfDivertedEnergyCountInSeconds = 0;
  }
  if constexpr (OVERRIDE_PIN_PRESENT)
  {
    const auto pinState{ getPinState(forcePin) };
 
    for (auto &bOverrideLoad : Shared::b_overrideLoadOn)
    {
      bOverrideLoad = !pinState;
    }
  }
 
  return false;
}

void checkDiversionOnOff()
{
  if constexpr (DIVERSION_PIN_PRESENT)
  {
    const auto pinState{ getPinState(diversionPin) };
 
#ifdef ENABLE_DEBUG
    static auto previousState{ HIGH };
    if (previousState != pinState)
    {
      DBUG(F("Trigger - diversion turned "));
      DBUGLN(!pinState ? F("'OFF'!") : F("'ON'!"));
    }
 
    previousState = pinState;
#endif
 
    Shared::b_diversionEnabled = pinState;
  }
}

void updateTemperature()
{
  if constexpr (TEMP_SENSOR_PRESENT)
  {
    uint8_t idx{ temperatureSensing.get_size() };
    do
    {
      auto tmp = temperatureSensing.readTemperature(--idx);
 
      // if read temperature is 85 and the delta with previous is greater than 5, skip the value
      if (8500 == tmp && (abs(tmp - tx_data.temperature_x100[idx]) > 500))
      {
        tmp = DEVICE_DISCONNECTED_RAW;
      }
 
      tx_data.temperature_x100[idx] = tmp;
    } while (idx);
 
    temperatureSensing.requestTemperatures();  // for use next time around
  }
}

void processCalculationsForLogging()
{
  tx_data.powerGrid = Shared::copyOf_sumP_grid_overDL_Period / Shared::copyOf_sampleSetsDuringThisDatalogPeriod * powerCal_grid;
  tx_data.powerGrid *= -1;
 
  tx_data.powerDiverted = Shared::copyOf_sumP_diverted_overDL_Period / Shared::copyOf_sampleSetsDuringThisDatalogPeriod * powerCal_diverted;
 
  if constexpr (DATALOG_PERIOD_IN_SECONDS > 10)
  {
    tx_data.Vrms_L_x100 = static_cast< int32_t >((100 << 2) * f_voltageCal * sqrtf(Shared::copyOf_sum_Vsquared / Shared::copyOf_sampleSetsDuringThisDatalogPeriod));
  }
  else
  {
    tx_data.Vrms_L_x100 = static_cast< int32_t >(100 * f_voltageCal * sqrtf(Shared::copyOf_sum_Vsquared / Shared::copyOf_sampleSetsDuringThisDatalogPeriod));
  }
}

void setup()
{
  delay(delayBeforeSerialStarts);  // allow time to open Serial monitor
 
  DEBUG_PORT.begin(9600);
  Serial.begin(9600, SERIAL_OUTPUT_TYPE == SerialOutputType::IoT ? SERIAL_7E1 : SERIAL_8N1);  // initialize Serial interface, Do NOT set greater than 9600
 
  // On start, always display config info in the serial monitor
  printConfiguration();
 
  setupOLED();
 
  initializeDisplay();
 
  // initializes all loads to OFF at startup
  initializeProcessing();
 
  logLoadPriorities();
 
  if constexpr (TEMP_SENSOR_PRESENT)
  {
    temperatureSensing.initTemperatureSensors();
  }
 
  DBUG(F(">>free RAM = "));
  DBUGLN(freeRam());  // a useful value to keep an eye on
  DBUGLN(F("----"));
}

void handlePerSecondTasks(bool &bOffPeak, int16_t iTemperature_x100)
{
  if constexpr (WATCHDOG_PIN_PRESENT)
  {
    togglePin(watchDogPin);
  }
 
  updateWatchdog();
  checkDiversionOnOff();
 
  if (!forceFullPower())
  {
    bOffPeak = proceedLoadPrioritiesAndOverriding(iTemperature_x100);
  }
 
  if constexpr (RELAY_DIVERSION)
  {
    relays.inc_duration();
    relays.proceed_relays();
  }
}

void loop()
{
  static bool initLoop{ true };
  static uint8_t perSecondTimer{ 0 };
  static bool bOffPeak{ false };
  static uint8_t timerForDisplayUpdate{ 0 };
  static int16_t iTemperature_x100{ 0 };
 
  if (Shared::b_newCycle)  // flag is set after each main cycle
  {
    Shared::b_newCycle = false;  // reset the flag
 
    if (++timerForDisplayUpdate >= UPDATE_PERIOD_FOR_DISPLAYED_DATA)
    {  // the 4-digit display needs to be refreshed every few mS. For convenience,
      // this action is performed every N times around this processing loop.
      timerForDisplayUpdate = 0;
 
      configureValueForDisplay(Shared::EDD_isActive, Shared::copyOf_divertedEnergyTotal_Wh, Shared::b_diversionEnabled, Shared::b_overrideLoadOn[0]);
    }
 
    if (++perSecondTimer >= SUPPLY_FREQUENCY)
    {
      perSecondTimer = 0;
      handlePerSecondTasks(bOffPeak, iTemperature_x100);
    }
  }
 
  if (Shared::b_datalogEventPending)
  {
    if (initLoop)
    {
      initLoop = false;
      clearDisplay();
    }
 
    Shared::b_datalogEventPending = false;  // Reset the flag
 
    processCalculationsForLogging();
 
    if constexpr (RELAY_DIVERSION)
    {
      relays.update_average(tx_data.powerGrid);
    }
 
    updateOLED(Shared::copyOf_divertedEnergyTotal_Wh_forDL);
 
    sendResults(bOffPeak);
 
    updateTemperature();
  }
}  // end of loop()