utils.h

Go to the documentation of this file.

 
#ifndef UTILS_H
#define UTILS_H
 
#include <Arduino.h>
#include <ArduinoJson.h>
 
#include "FastDivision.h"
 
#include "calibration.h"
#include "constants.h"
#include "dualtariff.h"
#include "processing.h"
#include "shared_var.h"
#include "teleinfo.h"
 
#include "utils_rf.h"
#include "utils_temp.h"
 
#include "version.h"

inline void printConfiguration()
{
#ifndef PROJECT_PATH
#define PROJECT_PATH (__FILE__)
#endif
 
#ifndef BRANCH_NAME
#define BRANCH_NAME ("N/A")
#endif
#ifndef COMMIT_HASH
#define COMMIT_HASH ("N/A")
#endif
 
  DBUGLN();
  DBUGLN();
  DBUGLN(F("----------------------------------"));
  DBUG(F("Sketch ID: "));
  DBUGLN(F(PROJECT_PATH));
 
  DBUG(F("From branch '"));
  DBUG(F(BRANCH_NAME));
  DBUG(F("', commit "));
  DBUGLN(F(COMMIT_HASH));
 
  DBUG(F("Build on "));
#ifdef CURRENT_TIME
  DBUGLN(F(CURRENT_TIME));
#else
  DBUG(F(__DATE__));
  DBUG(F(" "));
  DBUGLN(F(__TIME__));
#endif
  DBUGLN(F("ADC mode:       free-running"));
 
  DBUGLN(F("Electrical settings"));
  for (uint8_t phase = 0; phase < NO_OF_PHASES; ++phase)
  {
    DBUG(F("\tf_powerCal for L"));
    DBUG(phase + 1);
    DBUG(F(" =    "));
    DBUGLN(f_powerCal[phase], 6);
 
    DBUG(F("\tf_voltageCal, for Vrms_L"));
    DBUG(phase + 1);
    DBUG(F(" =    "));
    DBUGLN(f_voltageCal[phase], 5);
  }
 
  DBUG(F("\tf_phaseCal for all phases =     "));
  DBUGLN(f_phaseCal);
 
  DBUG(F("\tExport rate (Watts) = "));
  DBUGLN(REQUIRED_EXPORT_IN_WATTS);
 
  DBUG(F("\tzero-crossing persistence (sample sets) = "));
  DBUGLN(PERSISTENCE_FOR_POLARITY_CHANGE);
 
  printParamsForSelectedOutputMode();
 
  DBUG(F("Temperature capability "));
  if constexpr (TEMP_SENSOR_PRESENT)
  {
    DBUGLN(F("is present"));
  }
  else
  {
    DBUGLN(F("is NOT present"));
  }
 
  DBUG(F("Dual-tariff capability "));
  if constexpr (DUAL_TARIFF)
  {
    DBUGLN(F("is present"));
    printDualTariffConfiguration();
  }
  else
  {
    DBUGLN(F("is NOT present"));
  }
 
  DBUG(F("Load rotation feature "));
  if constexpr (PRIORITY_ROTATION != RotationModes::OFF)
  {
    DBUGLN(F("is present"));
  }
  else
  {
    DBUGLN(F("is NOT present"));
  }
 
  DBUG(F("Relay diversion feature "));
  if constexpr (RELAY_DIVERSION)
  {
    DBUGLN(F("is present"));
 
    relays.printRelayEngineConfiguration();
  }
  else
  {
    DBUGLN(F("is NOT present"));
  }
 
  DBUG(F("Override feature "));
  if constexpr (OVERRIDE_PIN_PRESENT)
  {
    DBUGLN(F("is present"));
 
    overridePins.printOverrideConfig();
  }
  else
  {
    DBUGLN(F("is NOT present"));
  }
 
  DBUG(F("RF capability "));
#ifdef RF_PRESENT
  DBUG(F("IS present, Freq = "));
  if (FREQ == RF12_433MHZ)
    DBUGLN(F("433 MHz"));
  else if (FREQ == RF12_868MHZ)
    DBUGLN(F("868 MHz"));
  rf12_initialize(nodeID, FREQ, networkGroup);  // initialize RF
#else
  DBUGLN(F("is NOT present"));
#endif
 
  DBUG(F("Datalogging capability "));
  if constexpr (SERIAL_OUTPUT_TYPE == SerialOutputType::HumanReadable)
  {
    DBUGLN(F("in Human-readable format"));
  }
  else if constexpr (SERIAL_OUTPUT_TYPE == SerialOutputType::IoT)
  {
    DBUGLN(F("in IoT format"));
  }
  else if constexpr (SERIAL_OUTPUT_TYPE == SerialOutputType::JSON)
  {
    DBUGLN(F("in JSON format"));
  }
  else
  {
    DBUGLN(F("is NOT present"));
  }
}

inline void printForJSON(const bool bOffPeak)
{
  ArduinoJson::StaticJsonDocument< 256 > doc;
 
  // Total mean power over a data logging period
  doc["P"] = tx_data.power;
 
  if constexpr (RELAY_DIVERSION)
  {
    doc["R"] = relays.get_average();
  }
 
  if constexpr (NO_OF_PHASES == 3)
  {
    // Mean power for each phase over a data logging period
    doc["P1"] = tx_data.power_L[0];
    doc["P2"] = tx_data.power_L[1];
    doc["P3"] = tx_data.power_L[2];
  }
  else if constexpr (NO_OF_PHASES == 2)
  {
    // Mean power for each phase over a data logging period
    doc["P1"] = tx_data.power_L[0];
    doc["P2"] = tx_data.power_L[1];
  }
  else
    static_assert(NO_OF_PHASES != 1, "Unsupported number of phases");
 
  // Mean power for each load over a data logging period (in %)
  //for (idx = 0; idx < NO_OF_DUMPLOADS; ++idx)
  //{
  //  Serial.print(F(",L"));
  //  Serial.print(idx + 1);
  //  Serial.print(F(":"));
  //  Serial.print(copyOf_countLoadON[idx] * 100 * invDATALOG_PERIOD_IN_MAINS_CYCLES);
  //}
 
  if constexpr (TEMP_SENSOR_PRESENT)
  {  // Current temperature
    for (uint8_t idx = 0; idx < temperatureSensing.size(); ++idx)
    {
      if ((OUTOFRANGE_TEMPERATURE == tx_data.temperature_x100[idx])
          || (DEVICE_DISCONNECTED_RAW == tx_data.temperature_x100[idx]))
      {
        continue;
      }
 
      doc[String("T") + (idx + 1)] = (float)tx_data.temperature_x100[idx] * 0.01F;
    }
  }
 
  if constexpr (DUAL_TARIFF)
  {
    // Current tariff
    doc["TA"] = bOffPeak ? "low" : "high";
  }
 
  serializeJson(doc, Serial);
  Serial.println();
}

inline void printForSerialText()
{
  uint8_t phase{ 0 };
 
  Serial.print(Shared::copyOf_energyInBucket_main * invSUPPLY_FREQUENCY);
  Serial.print(F(", P:"));
  Serial.print(tx_data.power);
 
  if constexpr (RELAY_DIVERSION)
  {
    Serial.print(F("/"));
    Serial.print(relays.get_average());
  }
 
  for (phase = 0; phase < NO_OF_PHASES; ++phase)
  {
    Serial.print(F(", P"));
    Serial.print(phase + 1);
    Serial.print(F(":"));
    Serial.print(tx_data.power_L[phase]);
  }
  for (phase = 0; phase < NO_OF_PHASES; ++phase)
  {
    Serial.print(F(", V"));
    Serial.print(phase + 1);
    Serial.print(F(":"));
    Serial.print((float)tx_data.Vrms_L_x100[phase] * 0.01F);
  }
 
  if constexpr (TEMP_SENSOR_PRESENT)
  {
    for (uint8_t idx = 0; idx < temperatureSensing.size(); ++idx)
    {
      if ((OUTOFRANGE_TEMPERATURE == tx_data.temperature_x100[idx])
          || (DEVICE_DISCONNECTED_RAW == tx_data.temperature_x100[idx]))
      {
        continue;
      }
 
      Serial.print(F(", T"));
      Serial.print(idx + 1);
      Serial.print(F(":"));
      Serial.print((float)tx_data.temperature_x100[idx] * 0.01F);
    }
  }
 
  Serial.print(F(", (minSampleSets/MC "));
  Serial.print(Shared::copyOf_lowestNoOfSampleSetsPerMainsCycle);
  Serial.print(F(", #ofSampleSets "));
  Serial.print(Shared::copyOf_sampleSetsDuringThisDatalogPeriod);
#ifndef DUAL_TARIFF
  if constexpr (PRIORITY_ROTATION != RotationModes::OFF)
  {
    Serial.print(F(", NoED "));
    Serial.print(Shared::absenceOfDivertedEnergyCountInSeconds);
  }
#endif  // DUAL_TARIFF
  Serial.println(F(")"));
}

void sendTelemetryData(const bool bOffPeak)
{
  static TeleInfo teleInfo;
  uint8_t idx{ 0 };
 
  teleInfo.startFrame();  // Start a new telemetry frame
 
  teleInfo.send("P", tx_data.power);  // Send power grid data
 
  if constexpr (NO_OF_PHASES > 1)
  {
    idx = NO_OF_PHASES;
    do
    {
      --idx;
      teleInfo.send("P", tx_data.power_L[idx], idx + 1);      // Send power for each phase
      teleInfo.send("V", tx_data.Vrms_L_x100[idx], idx + 1);  // Send voltage for each phase
    } while (idx);
  }
 
  if constexpr (RELAY_DIVERSION)
  {
    teleInfo.send("R", static_cast< int16_t >(relays.get_average()));  // Send relay average if diversion is enabled
 
    idx = relays.size();
    do
    {
      --idx;
      teleInfo.send("R", relays.get_relay(idx).isRelayON());  // Send state of each relay
    } while (idx);
  }
 
  idx = NO_OF_DUMPLOADS;
  do
  {
    --idx;
    teleInfo.send("D", Shared::copyOf_countLoadON[idx] * 100 * invDATALOG_PERIOD_IN_MAINS_CYCLES, idx + 1);  // Send load ON count for each load
  } while (idx);
 
  if constexpr (TEMP_SENSOR_PRESENT)
  {
    for (uint8_t idx = 0; idx < temperatureSensing.size(); ++idx)
    {
      if ((OUTOFRANGE_TEMPERATURE == tx_data.temperature_x100[idx])
          || (DEVICE_DISCONNECTED_RAW == tx_data.temperature_x100[idx]))
      {
        continue;  // Skip invalid temperature readings
      }
      teleInfo.send("T", tx_data.temperature_x100[idx], idx + 1);  // Send temperature
    }
  }
 
  teleInfo.send("N", static_cast< int16_t >(Shared::absenceOfDivertedEnergyCountInSeconds));  // Send absence of diverted energy count for 50Hz
 
  if constexpr (DUAL_TARIFF)
  {
    teleInfo.send("TA", static_cast< int16_t >(bOffPeak ? 1 : 0));  // Send current tariff state (0=high/on-peak, 1=low/off-peak)
  }
 
  teleInfo.send("S", Shared::copyOf_sampleSetsDuringThisDatalogPeriod);
  teleInfo.send("S_MC", Shared::copyOf_lowestNoOfSampleSetsPerMainsCycle);
 
  teleInfo.endFrame();  // Finalize and send the telemetry frame
}

inline void sendResults(bool bOffPeak)
{
  static bool startup{ true };
 
  if (startup)
  {
    startup = false;
    return;  // reject the first datalogging which is incomplete !
  }
 
#ifdef RF_PRESENT
  send_rf_data();  // *SEND RF DATA*
#endif
 
  if constexpr (SERIAL_OUTPUT_TYPE == SerialOutputType::HumanReadable)
  {
    printForSerialText();
  }
  else if constexpr (SERIAL_OUTPUT_TYPE == SerialOutputType::IoT)
  {
    sendTelemetryData(bOffPeak);
  }
  else if constexpr (SERIAL_OUTPUT_TYPE == SerialOutputType::JSON)
  {
    printForJSON(bOffPeak);
  }
}

inline void logLoadPriorities()
{
#ifdef ENABLE_DEBUG
 
  DBUGLN(F("Load Priorities: "));
  for (const auto& loadPrioAndState : loadPrioritiesAndState)
  {
    DBUG(F("\tload "));
    DBUGLN(loadPrioAndState);
  }
 
#endif
}

inline int freeRam()
{
  extern int __heap_start, *__brkval;
  int v;
  return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
}
 
#endif  // UTILS_H