validation.h

Go to the documentation of this file.

 
#ifndef VALIDATION_H
#define VALIDATION_H
 
#include "config_system.h"
#include "utils_pins.h"
#include "utils_rf.h"
 
#include "config.h"

 
static_assert(SUPPLY_FREQUENCY == 50 || SUPPLY_FREQUENCY == 60, "******** SUPPLY_FREQUENCY must be 50 or 60 Hz ! ********");
 
static_assert(DATALOG_PERIOD_IN_SECONDS <= 40, "**** Data log duration is too long and will lead to overflow ! ****");
 
static_assert(TEMP_SENSOR_PRESENT ^ (temperatureSensing.get_pin() == unused_pin), "******** Wrong pin value for temperature sensor(s). Please check your config.h ! ********");
static_assert(DIVERSION_PIN_PRESENT ^ (diversionPin == unused_pin), "******** Wrong pin value for diversion command. Please check your config.h ! ********");
static_assert((PRIORITY_ROTATION == RotationModes::PIN) ^ (rotationPin == unused_pin), "******** Wrong pin value for rotation command. Please check your config.h ! ********");
static_assert(WATCHDOG_PIN_PRESENT ^ (watchDogPin == unused_pin), "******** Wrong pin value for watchdog. Please check your config.h ! ********");
 
static_assert(DUAL_TARIFF ^ (dualTariffPin == unused_pin), "******** Wrong pin value for dual tariff. Please check your config.h ! ********");
static_assert(!(DUAL_TARIFF & (ul_OFF_PEAK_DURATION == 0)), "******** Off-peak duration cannot be zero. Please check your config.h ! ********");
static_assert(!(DUAL_TARIFF & (ul_OFF_PEAK_DURATION > 12)), "******** Off-peak duration cannot last more than 12 hours. Please check your config.h ! ********");
 
static_assert(!EMONESP_CONTROL || (DIVERSION_PIN_PRESENT && (PRIORITY_ROTATION == RotationModes::PIN) && OVERRIDE_PIN_PRESENT), "******** Wrong configuration. Please check your config.h ! ********");
 
static_assert(!RELAY_DIVERSION | (60 / DATALOG_PERIOD_IN_SECONDS * DATALOG_PERIOD_IN_SECONDS == 60), "******** Wrong configuration. DATALOG_PERIOD_IN_SECONDS must be a divider of 60 ! ********");
 
static_assert(NO_OF_DUMPLOADS > 0, "Number of dump loads must be greater than 0");
static_assert(iTemperatureThreshold > 0, "Temperature threshold must be greater than 0");
static_assert(iTemperatureThreshold <= 100, "Temperature threshold must be lower than 100");
 
static_assert(REQUIRED_EXPORT_IN_WATTS >= -32768 && REQUIRED_EXPORT_IN_WATTS <= 32767, "******** REQUIRED_EXPORT_IN_WATTS out of range ! ********");
static_assert(DIVERSION_START_THRESHOLD_WATTS >= 0 && DIVERSION_START_THRESHOLD_WATTS <= 32767, "******** DIVERSION_START_THRESHOLD_WATTS must be positive ! ********");
 
static_assert(sizeof(physicalLoadPin) / sizeof(physicalLoadPin[0]) == NO_OF_DUMPLOADS, "******** physicalLoadPin array size mismatch ! ********");
static_assert(sizeof(loadPrioritiesAtStartup) / sizeof(loadPrioritiesAtStartup[0]) == NO_OF_DUMPLOADS, "******** loadPrioritiesAtStartup array size mismatch ! ********");
static_assert(sizeof(rg_ForceLoad) / sizeof(rg_ForceLoad[0]) == NO_OF_DUMPLOADS, "******** rg_ForceLoad array size mismatch ! ********");
 
static_assert(ROTATION_AFTER_SECONDS > 0, "******** ROTATION_AFTER_SECONDS must be greater than 0 ! ********");
static_assert(ROTATION_AFTER_SECONDS <= 86400UL, "******** ROTATION_AFTER_SECONDS cannot exceed 24 hours ! ********");
 
static_assert(!TEMP_SENSOR_PRESENT || (temperatureSensing.size() > 0), "******** No temperature sensors configured but TEMP_SENSOR_PRESENT is true ! ********");
static_assert(TEMP_RANGE_LOW < TEMP_RANGE_HIGH, "******** Invalid temperature range ! ********");
 
constexpr uint16_t check_pins()
{
  uint16_t used_pins{ 0 };
 
  if constexpr (TEMP_SENSOR_PRESENT)
  {
    if (temperatureSensing.get_pin() != unused_pin)
      bit_set(used_pins, temperatureSensing.get_pin());
  }
 
  if (diversionPin != unused_pin)
  {
    if (bit_read(used_pins, diversionPin))
      return 0;
 
    bit_set(used_pins, diversionPin);
  }
 
  if (rotationPin != unused_pin)
  {
    if (bit_read(used_pins, rotationPin))
      return 0;
 
    bit_set(used_pins, rotationPin);
  }
 
  // Check override pins from the flexible override system
  if constexpr (OVERRIDE_PIN_PRESENT)
  {
    for (uint8_t i = 0; i < overridePins.size(); ++i)
    {
      const uint8_t pin = overridePins.getPin(i);
      if (pin != unused_pin)
      {
        if (bit_read(used_pins, pin))
          return 0;
 
        bit_set(used_pins, pin);
      }
    }
  }
 
  if (watchDogPin != unused_pin)
  {
    if (bit_read(used_pins, watchDogPin))
      return 0;
 
    bit_set(used_pins, watchDogPin);
  }
 
  //physicalLoadPin for the TRIACS
  for (const auto &loadPin : physicalLoadPin)
  {
    if (loadPin == unused_pin)
      return 0;
 
    if (bit_read(used_pins, loadPin))
      return 0;
 
    bit_set(used_pins, loadPin);
  }
 
  if constexpr (RELAY_DIVERSION)
  {
    for (uint8_t idx = 0; idx < relays.size(); ++idx)
    {
      const auto relayPin = relays.get_relay(idx).get_pin();
 
      if (relayPin != unused_pin)
      {
        if (bit_read(used_pins, relayPin))
          return 0;
 
        bit_set(used_pins, relayPin);
      }
    }
  }
 
  return used_pins;
}
 
constexpr bool check_load_priorities()
{
  uint8_t _sum{ 0 };
  uint16_t _enum_val{ 0 };
 
  for (const auto &loadPrio : loadPrioritiesAtStartup)
  {
    // we check if a prio is used twice
    if (bit_read(_enum_val, loadPrio))
      return 0;
 
    bit_set(_enum_val, loadPrio);
 
    _sum += loadPrio;
  }
 
  // check if we have all prio between 0 and (NO_OF_DUMPLOADS - 1)
  return _sum == ((NO_OF_DUMPLOADS * (NO_OF_DUMPLOADS - 1)) >> 1);
}
 
constexpr uint16_t check_relay_pins()
{
  bool pins_ok{ true };
 
  for (uint8_t idx = 0; idx < relays.size(); ++idx)
  {
    const auto relayPin = relays.get_relay(idx).get_pin();
 
    if constexpr (RELAY_DIVERSION)
    {
      pins_ok &= (relayPin != unused_pin);
    }
    else
    {
      pins_ok &= (relayPin == unused_pin);
    }
  }
 
  return pins_ok;
}
 
static_assert(check_load_priorities(), "******** Load Priorities wrong ! Please check your config ! ********");
static_assert(check_pins(), "******** Duplicate pin definition ! Please check your config ! ********");
static_assert((check_pins() & B00000011) == 0, "******** Pins 0 & 1 are reserved for RX/TX ! Please check your config ! ********");
static_assert((check_pins() & 0xC000) == 0, "******** Pins 14 and/or 15 do not exist ! Please check your config ! ********");
static_assert(!(RF_CHIP_PRESENT && ((check_pins() & 0x3C04) != 0)), "******** Pins from RF chip are reserved ! Please check your config ! ********");
static_assert(check_relay_pins(), "******** Wrong pin(s) configuration for relay(s) ********");
 
#ifdef RF_PRESENT
static_assert((nodeID >= 1 && nodeID <= 30), "******** RF nodeID must be between 1 and 30 ! ********");
static_assert(networkGroup >= 1 && networkGroup <= 250, "******** RF networkGroup must be between 1 and 250 ! ********");
#endif
 
#endif /* VALIDATION_H */