usermod_v2_16x16_word_clock.h

#pragma once

#include "wled.h"



class WordClock16x16Usermod : public Usermod
{

// defines for mask sizes
#define maskSizeLeds 256
#define maskSizeTheTimeIs 9
#define maskSizePast 4
#define maskSizeTo 2
#define maskSizeMins 7
#define maskSizeMin 6
#define maskSizeOClock 6
#define maskSizeQuarter 7
#define maskSizeHalf 4
#define maskSizeHours 6
#define maskSizeMinutes 9
#define maskSizeInThe 5
#define maskSizeAt 2
#define maskSizeMorning 7
#define maskSizeAfternoon 9
#define maskSizeEvening 7
#define maskSizeNight 5
#define maskSize1021 4

private:
  unsigned long lastTime = 0;
  uint8_t lastTimeMinutes = -1;
  bool playedTransition = false;
  uint8_t playTransitionAfter = 59;


  bool usermodActive = true;
  bool usermodOnlyClock = true;
  bool usermodShowCustomColor = false;
  uint32_t usermodCustomColor = 0xFFFFFF;


  const uint8_t PROGMEM theTimeIs[maskSizeTheTimeIs] = {15, 14, 13, 11, 10, 9, 8, 6, 5};


  const uint8_t PROGMEM maskPast[maskSizePast] = {119, 118, 117, 116};


  const uint8_t maskTo[maskSizeTo] = {116, 115};


  const uint8_t maskMins[maskSizeMins] = {127, 126, 125, 124, 123, 122, 121};


  const uint8_t maskMin[maskSizeMin] = {127, 126, 125, 124, 123, 122};


  const uint8_t maskOClock[maskSizeOClock] = {191, 190, 189, 188, 187, 186};


  const uint8_t maskQuarter[maskSizeQuarter] = {31, 30, 29, 28, 27, 26, 25};


  const uint8_t maskHalf[maskSizeHalf] = {3, 2, 1, 0};


  const uint8_t maskInThe[maskSizeInThe] = {184, 183, 203, 202, 201};


  const uint8_t maskAt[maskSizeAt] = {182, 181};


  const uint8_t maskMorning[maskSizeMorning] = {199, 198, 197, 196, 195, 194, 193};


  const uint8_t maskAfternoon[maskSizeAfternoon] = {216, 215, 214, 213, 212, 211, 210, 209, 208};


  const uint8_t maskEvening[maskSizeEvening] = {223, 222, 221, 220, 219, 218, 217};


  const uint8_t maskNight[maskSizeNight] = {207, 206, 205, 204, 203};


  const uint8_t morningStartsAt = 7;
  const uint8_t afternoonStartsAt = 13;
  const uint8_t eveningStartsAt = 17;
  const uint8_t nightStartsAt = 20;


  const int16_t minutes[20][maskSizeMinutes] =
      {
          {35,  34,  33,  -1,  -1,  -1,  -1, -1, -1},
          {37,  36,  35,  -1,  -1,  -1,  -1, -1, -1},
          {100, 99,  98,  97,  96,  -1,  -1, -1, -1},
          {95,  94,  93,  92,  -1,  -1,  -1, -1, -1},
          {55,  54,  53,  52,  -1,  -1,  -1, -1, -1},
          {44,  43,  42,  -1,  -1,  -1,  -1, -1, -1},
          {79,  78,  77,  76,  75,  -1,  -1, -1, -1},
          {63,  62,  61,  60,  59,  -1,  -1, -1, -1},
          {71,  70,  69,  68,  -1,  -1,  -1, -1, -1},
          {47,  46,  45,  -1,  -1,  -1,  -1, -1, -1},
          {106, 105, 104, 103, 102, 101, -1, -1, -1},
          {111, 110, 109, 108, 107, 106, -1, -1, -1},
          {87,  86,  85,  84,  83,  82,  81, 80, -1},
          {95,  94,  93,  92,  91,  90,  89, 88, -1},
          {31,  30,  29,  28,  27,  26,  25, -1, -1},
          {44,  43,  42,  41,  40,  39,  38, -1, -1},
          {79,  78,  77,  76,  75,  74,  73, 72, 71},
          {63,  62,  61,  60,  59,  58,  57, 56, -1},
          {71,  70,  69,  68,  67,  66,  65, 64, -1},
          {24,  23,  22,  21,  20,  19,  -1, -1, -1},
      };


  const int16_t hours[12][maskSizeHours] =
      {
          {141, 140, 139, -1, -1, -1},
          {143, 142, 141, -1, -1, -1},
          {154, 153, 152, 151, 150, -1},
          {175, 174, 173, 172, -1, -1},
          {170, 169, 168, 167, -1, -1},
          {130, 129, 128, -1, -1, -1},
          {159, 158, 157, 156, 155, -1},
          {167, 166, 165, 164, 163, -1},
          {134, 133, 132, 131, -1, -1},
          {163, 162, 161, -1, -1, -1},
          {139, 138, 137, 136, 135, 134},
          {149, 148, 147, 146, 145, 144}
      };


  int8_t maskLedsOn[maskSizeLeds] = {0};

  String colorToHexString(const uint32_t c)
  {
    char buffer[9];
    sprintf(buffer, "%06X", c);
    return buffer;
  }

  bool hexStringToColor(const String &s, uint32_t &c, const uint32_t def)
  {
    char *ep;
    unsigned long long r = strtoull(s.c_str(), &ep, 16);
    if (*ep == 0)
    {
      c = r;
      return true;
    }
    else
    {
      c = def;
      return false;
    }
  }


  void updateLedMask(const int16_t wordMask[], uint8_t arraySize)
  {

    for (uint8_t x = 0; x < arraySize; x++)
    {

      if (wordMask[x] >= 0 && wordMask[x] < maskSizeLeds)
      {

        DEBUG_PRINTF("%d, ", wordMask[x]);
        maskLedsOn[wordMask[x]] = 1;
      }
    }
    DEBUG_PRINTLN("");
  }


  void updateLedMask(const uint8_t wordMask[], uint8_t arraySize)
  {

    for (uint8_t x = 0; x < arraySize; x++)
    {

      if (wordMask[x] < maskSizeLeds)
      {


        maskLedsOn[wordMask[x]] = 1;
      }
    }

  }


  void setHours(uint8_t currentHour)
  {
    uint8_t hourToShow = (currentHour == 0) ? 12 : currentHour;
    hourToShow += (minute(localTime) > 30) ? 1 : 0;
    hourToShow = (hourToShow > 12) ? hourToShow - 12 : hourToShow;
    DEBUG_PRINTF("Current Hour: %d - Hour to show: %d", currentHour, hourToShow);
    updateLedMask(hours[hourToShow - 1], maskSizeHours);
  }


  void setMinutes(uint8_t currentMinute)
  {

    uint8_t minuteToShow = currentMinute;

    switch (currentMinute)
    {
    case 15:
    case 45:
      updateLedMask(maskQuarter, maskSizeQuarter);
      break;
    case 30:
      updateLedMask(maskHalf, maskSizeHalf);
      break;
    }
    if (currentMinute != 0)
    {
      if (currentMinute < 31)
      {
        updateLedMask(maskPast, maskSizePast);
      }
      else
      {
        updateLedMask(maskTo, maskSizeTo);
        minuteToShow = 60 - currentMinute;
      }
    }

    switch (minuteToShow)
    {
    case 0:
      updateLedMask(maskOClock, maskSizeOClock);
      return;
    case 1:
      updateLedMask(maskMin, maskSizeMin);
      break;
    case 15:
    case 30:
      break;
    default:
      updateLedMask(maskMins, maskSizeMins);
    }

    if ((currentMinute > 0) && (currentMinute < 21))
    {
      updateLedMask(minutes[minuteToShow - 1], maskSizeMinutes);
    }

    if ((minuteToShow > 20) && (minuteToShow < 30))
    {
      minuteToShow = minuteToShow - 20;
      updateLedMask(minutes[19], maskSizeMinutes);
    }

    updateLedMask(minutes[minuteToShow - 1], maskSizeMinutes);
  }


  void showPeriod(uint8_t currentHour)
  {
    if (currentHour >= nightStartsAt)
    {
      updateLedMask(maskAt, maskSizeAt);
      updateLedMask(maskNight, maskSizeNight);
      return;
    }
    if (currentHour >= eveningStartsAt)
    {
      updateLedMask(maskInThe, maskSizeInThe);
      updateLedMask(maskEvening, maskSizeEvening);
      return;
    }
    if (currentHour >= afternoonStartsAt)
    {
      updateLedMask(maskInThe, maskSizeInThe);
      updateLedMask(maskAfternoon, maskSizeAfternoon);
      return;
    }
    if (currentHour == 12)
    {
      return;
    }
    if (currentHour >= morningStartsAt)
    {
      updateLedMask(maskInThe, maskSizeInThe);
      updateLedMask(maskMorning, maskSizeMorning);
      return;
    }
    updateLedMask(maskAt, maskSizeAt);
    updateLedMask(maskNight, maskSizeNight);
  }


  void updateDisplay(uint8_t currentHour, uint8_t currentMinutes)
  {

    memset(maskLedsOn, 0, maskSizeLeds);
    updateLedMask(theTimeIs, maskSizeTheTimeIs);
    showPeriod(currentHour);
    setMinutes(currentMinutes);
    setHours(currentHour);
  }

public:
  void setup()
  {
  }

  void connected()
  {
  }

  void loop()
  {
    if (millis() - lastTime > 250)
    {
      uint8_t nowMinutes = minute(localTime);
      if (lastTimeMinutes != nowMinutes)
      {
        if (playTransitionAfter == lastTimeMinutes)
        {
          if (!playedTransition)
          {
            playedTransition = true;
            applyPreset(50);
          }
        }
        else
        {
          playedTransition = false;
        }
        updateDisplay(hour(localTime), minute(localTime));
        lastTimeMinutes = nowMinutes;
      }
      lastTime = millis();
    }
  }

  void addToJsonState(JsonObject &root)
  {
    root[F("mc16")] = usermodActive;
  }

  void readFromJsonState(JsonObject &root)
  {
    usermodActive = root[F("mc16")] | usermodActive;

  }

  void addToConfig(JsonObject &root)
  {
    JsonObject top = root.createNestedObject(F("WordClock16X16Usermod"));
    top[F("Clock Active")] = usermodActive;
    top[F("Show Clock Only")] = usermodOnlyClock;
    top[F("Show Custom Color")] = usermodShowCustomColor;
    top[F("Clock Custom Color (RRGGBB)")] = colorToHexString(usermodCustomColor);
  }

  bool readFromConfig(JsonObject &root)
  {
    JsonObject top = root[F("WordClock16X16Usermod")];

    String color;
    bool configComplete = !top.isNull();

    configComplete &= getJsonValue(top[F("Clock Active")], usermodActive);
    configComplete &= getJsonValue(top[F("Show Clock Only")], usermodOnlyClock);
    configComplete &= getJsonValue(top[F("Show Custom Color")], usermodShowCustomColor);
    configComplete &= getJsonValue(top[F("Clock Custom Color (RRGGBB)")], color, F("FFFFFF")) && hexStringToColor(color, usermodCustomColor, 0xFFFFFF);
    return configComplete;
  }

  void handleOverlayDraw()
  {
    if (usermodActive == true)
    {
      for (int x = 0; x < maskSizeLeds; x++)
      {
        if ((maskLedsOn[x] == 0) && (usermodOnlyClock))
        {
          strip.setPixelColor(x, RGBW32(0, 0, 0, 0));
        }
        if ((maskLedsOn[x] == 1) && (usermodShowCustomColor))
        {
          strip.setPixelColor(x, usermodCustomColor);
        }
      }
    }
  }

  uint16_t getId()
  {
    return USERMOD_ID_16X16_WORDCLOCK;
  }
};