utils_override.h

Go to the documentation of this file.

 
#ifndef UTILS_OVERRIDE_H
#define UTILS_OVERRIDE_H
 
#include "config.h"
#include "type_traits.hpp"

constexpr uint8_t LOAD(uint8_t loadNum)
{
  return physicalLoadPin[loadNum];
}

constexpr uint8_t RELAY(uint8_t relayNum)
{
  return relays.get_relay(relayNum).get_pin();
}

constexpr uint16_t ALL_LOADS()
{
  uint16_t mask{ 0 };
  for (uint8_t i = 0; i < NO_OF_DUMPLOADS; ++i)
  {
    bit_set(mask, physicalLoadPin[i]);
  }
  return mask;
}

constexpr uint16_t ALL_RELAYS()
{
  uint16_t mask{ 0 };
  for (uint8_t i = 0; i < relays.size(); ++i)
  {
    bit_set(mask, relays.get_relay(i).get_pin());
  }
  return mask;
}

constexpr uint16_t ALL_LOADS_AND_RELAYS()
{
  return ALL_LOADS() | ALL_RELAYS();
}
 
// Valid pins: 2-13, so valid mask is 0b11111111111100
constexpr uint16_t validPinMask{ 0b11111111111100 };

template< uint8_t... Pins >
constexpr bool are_pins_valid()
{
  return ((validPinMask & (1U << Pins)) && ...);
}

#define VALIDATE_PINS(...) static_assert(are_pins_valid< __VA_ARGS__ >(), "Invalid pin(s) specified")

template< uint8_t... Pins >
constexpr uint16_t indicesToBitmask()
{
  return ((1U << Pins) | ...);
}

template< uint8_t MaxPins >
struct PinList
{
  uint8_t pins[MaxPins];
  uint8_t count;

  constexpr PinList()
    : pins{}, count(0) {}

  constexpr PinList(uint16_t bitmask)
    : pins{}, count(0)
  {
    for (uint8_t pin = 0; pin < 16 && count < MaxPins; ++pin)
    {
      if (bitmask & (1U << pin))
      {
        pins[count++] = pin;  // Store the pin number
      }
    }
  }

  template< typename... Args >
  constexpr PinList(Args... args)
    : pins{ static_cast< uint8_t >(args)... }, count(sizeof...(args)) {}

  constexpr uint16_t toBitmask() const
  {
    uint16_t result = 0;
    for (uint8_t i = 0; i < count; ++i)
    {
      result |= (1U << pins[i]);
    }
    return result;
  }
};

template< uint8_t MaxPins >
struct KeyIndexPair
{
  uint8_t pin;
  PinList< MaxPins > indexList;

  constexpr KeyIndexPair(uint8_t k, const PinList< MaxPins >& list)
    : pin(k), indexList(list) {}

  constexpr uint16_t getBitmask() const
  {
    return indexList.toBitmask();
  }
};

template< uint8_t N, uint8_t MaxPins = NO_OF_DUMPLOADS + relays.size() >
class OverridePins
{
private:
  struct Entry
  {
    uint8_t pin;      
    uint16_t bitmask; 
  };
 
  const Entry entries_[N]; 
 
public:
  constexpr OverridePins(const KeyIndexPair< MaxPins > (&pairs)[N])
    : entries_{}  // default initialize
  {
    Entry temp[N]{};
    for (uint8_t i = 0; i < N; ++i)
    {
      temp[i] = { pairs[i].pin, pairs[i].getBitmask() };
    }
    for (uint8_t i = 0; i < N; ++i)
    {
      const_cast< Entry& >(entries_[i]) = temp[i];
    }
  }

  constexpr uint8_t size() const
  {
    return N;
  }

  constexpr uint8_t getPin(uint8_t index) const
  {
    return index < N ? entries_[index].pin : 0;
  }

  constexpr uint16_t getBitmask(uint8_t index) const
  {
    return index < N ? entries_[index].bitmask : 0;
  }

  constexpr uint16_t findBitmask(uint8_t pin) const
  {
    for (uint8_t i = 0; i < N; ++i)
    {
      if (entries_[i].pin == pin)
      {
        return entries_[i].bitmask;
      }
    }
    return 0;
  }

  void printOverrideConfig() const
  {
    Serial.println(F("*** Override Pins Configuration ***"));
    for (uint8_t i = 0; i < N; ++i)
    {
      Serial.print(F("\tPin: "));
      Serial.print(entries_[i].pin);
      Serial.print(F("\tBitmask: 0b"));
      Serial.println(entries_[i].bitmask, BIN);
    }
  }
};

template< uint8_t MaxPins, uint8_t N >
OverridePins(const KeyIndexPair< MaxPins > (&)[N])
  -> OverridePins< N, MaxPins >;
 
#endif /* UTILS_OVERRIDE_H */