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_3phase_RFdatalog_temp/Readme.md");
 
#include <Arduino.h>  // may not be needed, but it's probably a good idea to include this
 
#include "config.h"
 
// In this sketch, the ADC is free-running with a cycle time of ~104uS.
 
#include "calibration.h"
#include "processing.h"
#include "shared_var.h"
#include "types.h"
#include "utils.h"
#include "utils_relay.h"
#include "validation.h"
#include "main.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 checkDiversionOnOff()
{
  if constexpr (DIVERSION_PIN_PRESENT)
  {
    const auto pinState{ getPinState(diversionPin) };
 
#ifdef ENABLE_DEBUG
    static auto previousState{ HIGH };
    if (previousState != pinState)
    {
      DBUGLN(!pinState ? F("Trigger diversion OFF!") : F("End diversion OFF!"));
    }
 
    previousState = pinState;
#endif
 
    Shared::b_diversionEnabled = pinState;
  }
}

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{ OVERRIDE_PIN_PRESENT ? getPinState(forcePin) : HIGH };
 
    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 constexpr (PRIORITY_ROTATION == RotationModes::AUTO)
  {
    if (ROTATION_AFTER_SECONDS < Shared::absenceOfDivertedEnergyCountInSeconds)
    {
      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 setup()
{
  delay(initialDelay);  // allows time to open the 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();
 
  // 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 updatePowerAndVoltageData()
{
  tx_data.power = 0;
  for (uint8_t phase = 0; phase < NO_OF_PHASES; ++phase)
  {
    tx_data.power_L[phase] = Shared::copyOf_sumP_atSupplyPoint[phase] / Shared::copyOf_sampleSetsDuringThisDatalogPeriod * f_powerCal[phase];
    tx_data.power_L[phase] *= -1;
 
    tx_data.power += tx_data.power_L[phase];
 
    if constexpr (DATALOG_PERIOD_IN_SECONDS > 10)
    {
      tx_data.Vrms_L_x100[phase] = static_cast< uint32_t >((100U << 2) * f_voltageCal[phase] * sqrt(Shared::copyOf_sum_Vsquared[phase] / Shared::copyOf_sampleSetsDuringThisDatalogPeriod));
    }
    else
    {
      tx_data.Vrms_L_x100[phase] = static_cast< uint32_t >(100U * f_voltageCal[phase] * sqrt(Shared::copyOf_sum_Vsquared[phase] / Shared::copyOf_sampleSetsDuringThisDatalogPeriod));
    }
  }
}

void processTemperatureData()
{
  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 handlePerSecondTasks(bool &bOffPeak, int16_t &iTemperature_x100)
{
  if constexpr (WATCHDOG_PIN_PRESENT)
  {
    togglePin(watchDogPin);
  }
 
  checkDiversionOnOff();
 
  if (!forceFullPower())
  {
    bOffPeak = proceedLoadPrioritiesAndOverriding(iTemperature_x100);  // called every second
  }
 
  if constexpr (RELAY_DIVERSION)
  {
    relays.inc_duration();
    relays.proceed_relays();
  }
}

void loop()
{
  static uint8_t perSecondTimer{ 0 };
  static bool bOffPeak{ false };
  static int16_t iTemperature_x100{ 0 };
 
  if (Shared::b_newMainsCycle)  // flag is set after every pair of ADC conversions
  {
    Shared::b_newMainsCycle = false;  // reset the flag
    ++perSecondTimer;
 
    if (perSecondTimer >= SUPPLY_FREQUENCY)
    {
      perSecondTimer = 0;
      handlePerSecondTasks(bOffPeak, iTemperature_x100);
    }
  }
 
  if (Shared::b_datalogEventPending)
  {
    Shared::b_datalogEventPending = false;
 
    updatePowerAndVoltageData();
 
    if constexpr (RELAY_DIVERSION)
    {
      relays.update_average(tx_data.power);
    }
 
    if constexpr (TEMP_SENSOR_PRESENT)
    {
      processTemperatureData();
    }
 
    sendResults(bOffPeak);
  }
}  // end of loop()