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'
//

uint16_t getDualTariffForcingBitmask(const int16_t currentTemperature_x100)
{
  if constexpr (!DUAL_TARIFF)
  {
    return 0;
  }
 
  constexpr int16_t iTemperatureThreshold_x100{ iTemperatureThreshold * 100 };
  static bool pinOffPeakState{ HIGH };
  const auto pinNewState{ getPinState(dualTariffPin) };
 
  // Return early if we're not in off-peak period
  if (pinOffPeakState || pinNewState)
  {
    return 0;
  }
 
  // We're in off-peak period - check forcing time windows
  const auto ulElapsedTime{ static_cast< uint32_t >(millis() - ul_TimeOffPeak) };
 
  uint16_t forcingBitmask = 0;
  uint8_t i{ NO_OF_DUMPLOADS };
  do
  {
    --i;
    // Skip if not within the 'force period'
    if ((ulElapsedTime < rg_OffsetForce[i][0]) || (ulElapsedTime >= rg_OffsetForce[i][1]))
    {
      continue;
    }
 
    // Force load ON if temperature condition is met
    if (currentTemperature_x100 <= iTemperatureThreshold_x100)
    {
      bit_set(forcingBitmask, physicalLoadPin[i]);
    }
  } while (i);
 
  return forcingBitmask;
}

uint16_t getOverrideBitmask(const int16_t currentTemperature_x100)
{
  uint16_t overrideBitmask = 0;
 
  // Add external override pins
  if constexpr (OVERRIDE_PIN_PRESENT)
  {
    // Check each configured override pin and combine their bitmasks
    uint8_t i{ overridePins.size() };
    do
    {
      --i;
      const uint8_t pin = overridePins.getPin(i);
      const auto pinState = getPinState(pin);
 
      if (!pinState)  // Pin is LOW (active)
      {
        overrideBitmask |= overridePins.getBitmask(i);
      }
    } while (i);
  }
 
  // Add dual tariff forcing - OR operation handles precedence automatically
  // If a bit is already set by external override, OR won't change it
  // If a bit is not set, OR will apply dual tariff forcing
  overrideBitmask |= getDualTariffForcingBitmask(currentTemperature_x100);
 
  return overrideBitmask;
}

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 proceedDualTariffLogic()
{
  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();
    }
  }
 
  // end of off-peak period
  if (!pinOffPeakState && pinNewState)
  {
    DBUGLN(F("Change to peak period!"));
  }
 
  pinOffPeakState = pinNewState;
 
  return (LOW == pinOffPeakState);
}

bool proceedLoadPriorities(const int16_t &currentTemperature_x100)
{
  // Suppress unused parameter warning when DUAL_TARIFF is disabled
  (void)currentTemperature_x100;
 
  if constexpr (DUAL_TARIFF)
  {
    return proceedDualTariffLogic();
  }
 
  if constexpr ((PRIORITY_ROTATION == RotationModes::PIN) || (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;
    }
  }
 
  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;
  uint8_t phase{ NO_OF_PHASES };
  do
  {
    --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));
    }
  } while (phase);
}

void processTemperatureData()
{
  uint8_t idx{ temperatureSensing.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();
 
  // Get complete override bitmask atomically (external pins + dual tariff forcing)
  uint16_t privateOverrideBitmask = getOverrideBitmask(iTemperature_x100);
 
  if constexpr (RELAY_DIVERSION)
  {
    relays.inc_duration();
    // Pass private bitmask to relay engine, it will filter out relay pins that can be controlled
    relays.proceed_relays(privateOverrideBitmask);
  }
 
  // Copy the filtered bitmask (only triac/load pins) to shared version
  Shared::overrideBitmask = privateOverrideBitmask;
 
  // Only process priority logic if no override pins are active
  if (!Shared::overrideBitmask)
  {
    bOffPeak = proceedLoadPriorities(iTemperature_x100);
  }
}

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()