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 "teleinfo.h"
 
#include "utils_temp.h"
 
#include "version.h"
 
#include "utils_temp.h"
 
#include "version.h"
 
inline PayloadTx_struct< TEMP_SENSOR_PRESENT ? temperatureSensing.get_size() : 0 > tx_data; 

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"));
 
  DBUG(F("\tf_powerCal for Grid"));
  DBUG(F(" =    "));
  DBUGLN(powerCal_grid, 6);
  DBUG(F("\tf_powerCal for Diversion"));
  DBUG(F(" =    "));
  DBUGLN(powerCal_diverted, 6);
 
  DBUG("\tAnti-creep limit (Joules / mains cycle) = ");
  DBUGLN(ANTI_CREEP_LIMIT);
  DBUG("\tExport rate (Watts) = ");
  DBUGLN(REQUIRED_EXPORT_IN_WATTS);
 
  printParamsForSelectedOutputMode();
 
  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 printForSerialText()
{
  Serial.print(Shared::copyOf_energyInBucket_long * invSUPPLY_FREQUENCY);
  Serial.print(F(", P:"));
  Serial.print(tx_data.powerGrid);
 
  if constexpr (RELAY_DIVERSION)
  {
    Serial.print(F("/"));
    Serial.print(relays.get_average());
  }
 
  Serial.print(F(", D:"));
  Serial.print(tx_data.powerDiverted);
 
  Serial.print(F(", E:"));
  Serial.print(Shared::copyOf_divertedEnergyTotal_Wh_forDL);
 
  Serial.print(F(", V"));
  Serial.print(F(":"));
  Serial.print((float)tx_data.Vrms_L_x100 * 0.01f);
 
  if constexpr (TEMP_SENSOR_PRESENT)
  {
    for (uint8_t idx = 0; idx < temperatureSensing.get_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(")"));
}

inline void printForJSON(const bool bOffPeak)
{
  ArduinoJson::StaticJsonDocument< 256 > doc;
 
  doc["P"] = tx_data.powerGrid;
 
  if constexpr (RELAY_DIVERSION)
  {
    doc["R"] = relays.get_average();
  }
 
  doc["D"] = tx_data.powerDiverted;
  doc["E"] = Shared::copyOf_divertedEnergyTotal_Wh_forDL;
  doc["V"] = (float)tx_data.Vrms_L_x100 * 0.01f;
 
  if constexpr (TEMP_SENSOR_PRESENT)
  {
    for (uint8_t idx = 0; idx < temperatureSensing.get_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;
    }
  }
 
  doc["NoED"] = Shared::absenceOfDivertedEnergyCountInSeconds;
 
  serializeJson(doc, Serial);
  Serial.println();
}

void sendTelemetryData()
{
  static TeleInfo teleInfo;
 
  teleInfo.startFrame();  // Start a new telemetry frame
 
  teleInfo.send("P", tx_data.powerGrid);  // Send power grid data
 
  if constexpr (RELAY_DIVERSION)
  {
    teleInfo.send("R", static_cast< int16_t >(relays.get_average()));  // Send relay average if diversion is enabled
 
    uint8_t idx = 0;
    do
    {
      teleInfo.send("R", relays.get_relay(idx).isRelayON());  // Send diverted energy count for each relay
    } while (++idx < relays.get_size());
  }
 
  teleInfo.send("V", tx_data.Vrms_L_x100);  // Send voltage in volts
 
  teleInfo.send("D", tx_data.powerDiverted);                                                // Send power diverted
  teleInfo.send("E", static_cast< int16_t >(Shared::copyOf_divertedEnergyTotal_Wh_forDL));  // Send diverted energy in Wh
 
  if constexpr (TEMP_SENSOR_PRESENT)
  {
    for (uint8_t idx = 0; idx < temperatureSensing.get_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
 
  teleInfo.send("S_MC", Shared::copyOf_lowestNoOfSampleSetsPerMainsCycle);
  teleInfo.send("S", Shared::copyOf_sampleSetsDuringThisDatalogPeriod);
 
  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();
  }
  else if constexpr (SERIAL_OUTPUT_TYPE == SerialOutputType::JSON)
  {
    printForJSON(bOffPeak);
  }
}

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