Rotating Clock

//Build using WEMOS D1 Mini (Clone)

//Change History
//V1.0  First working version
//V2.0  Changed to use the clock's own display to indicate OTA status and progress. 
//      Added Telnet spy to stream all serial output over Telnet. This saves taking the clock off the wall when debugging!


#define Version 2.0

//#define FIXED_INTERVALS 1  //if set, the 5 sec inteval points are always on, otherwise they only come on when that period is passed

//#define TESTING 1

//Rotating clock using NTP connection to keep track of time
//Uses WiFi Manager to establish initial Wifi credentials.


// Required libraries
#include <ESP8266WiFi.h>
#include <ESP8266mDNS.h>
#include <WiFiUdp.h>
#include <ArduinoOTA.h>
#include <WiFiManager.h>  
#include <time.h>
#include <sys/time.h>                   // struct timeval
#include <sntp.h>                       // sntp_servermode_dhcp()
//#include <TZ.h>
#include <coredecls.h>                  //   required for settimeofday_cb()
#include <TickTwo.h>
#include <TelnetSpy.h>

#include "TZ_Setting.h"
#include "TZones.h"

#include <MD_MAX72xx.h>
#include <SPI.h>


TelnetSpy SerialAndTelnet;
//#define TSerial  Serial  //uncomment this line and comment out the next line for non-Telnet serial
#define TSerial  SerialAndTelnet

#ifdef TESTING
  #define OTA_NETWORK_NAME "RotatingClock_TEST"
  #define WIFI_MANAGER_AP "RotatingClockAP_TEST"
#else
  #define OTA_NETWORK_NAME "RotatingClock"
  #define WIFI_MANAGER_AP "RotatingClockAP"
#endif


#define DELAYTIME 50   //100ms scroll time

#include "Font5x7.h"
#define USE_LOCAL_FONT 1
#define HARDWARE_TYPE MD_MAX72XX::FC16_HW
#define MAX_DEVICES 4

#define CLK_PIN   D5
#define DATA_PIN  D7
#define CS_PIN    D8
#define CS_PIN2    D2

#define COL_HRS_MS 29 
#define COL_HRS_LS 23 
#define COL_MINS_MS 12
#define COL_MINS_LS 6
#define COL_SECS_MS 12 //45
#define COL_SECS_LS 6 //38
#define COL_SEP 16
#define COL_ROTATING_SECS_START 16
#define COL_INTERVALS_SECS_START 24

#define MIN_BRIGHTNESS 0  //0 is minimum brightness, 15 is maximum brightness (brightness also set by Iset resistor)
#define MAX_BRIGHTNESS 3


#define RTC_UTC_TEST 1510592825 // 1510592825 = Monday 13 November 2017 17:07:05 UTC

void ClockTimer();
void ColonOff();
extern "C" int clock_gettime(clockid_t unused, struct timespec *tp);

// Timing parameters
int data_update_seconds = 1;            // measurement interval in seconds
time_t present_timestamp;
time_t previous_timestamp = 0;
int PreviousHours = 66;
int PreviousMinutes = 66;
int PreviousSeconds = 66;
int CurrentBrightness;
bool InitialUpdate = true;
bool DisplayShutdown = false;

MD_MAX72XX MainClockDisplay = MD_MAX72XX(HARDWARE_TYPE, CS_PIN, MAX_DEVICES);
MD_MAX72XX SecondsDisplay = MD_MAX72XX(HARDWARE_TYPE, CS_PIN2,4 );


WiFiManager wm;

static timeval tv;
static timespec tp;
static time_t now;
struct tm *timeinfo;

bool TimeIsInSync = false;

TickTwo ColonTimer(ColonOff, 500,1,MILLIS);
// ....................................................................................
 
void time_is_set (void)
// callback routine - arrive here whenever a successful NTP update has occurred
{
  struct tm *tmp ;                      // NOTE: structure tm is defined in time.h
 
  char UPDATE_TIME[50];                 // buffer for use by strftime()
    
  // display time when NTP update occurred
  time_t tnow = time(nullptr);          // get UNIX timestamp 
  tmp = localtime(&tnow);               // convert to local time and break down
  strftime(UPDATE_TIME, sizeof(UPDATE_TIME), "%T", tmp);  // extract just the 'time' portion
    
  TSerial.print("\n-------- NTP update at ");
  TSerial.print(UPDATE_TIME);
  TSerial.println(" --------");
  if ((tmp->tm_year + 1900) != 2017)
     TimeIsInSync = true;
}


// ....................................................................................
void displayDateAndTime()
{
  TSerial.print(present_timestamp);      // display system time as UNIX timestamp
  
  // use ctime() to convert the system (UNIX) time to a local date and time in readable form
  // NOTE: 'ctime' produces a output in a specific format that looks 
  //        like --> Fri Mar 22 12:11:51 2019  -there is also a newline (\n) appended
  TSerial.print("  ");
  TSerial.print(ctime(&present_timestamp));  // convert timestamp and display
  
  struct tm *tmp ;                          // NOTE: structure tm is defined in time.h
  char FORMATTED_TIME[50];                  //   filled by strftime()
    
  // convert the system (UNIX) time to a local date and time in a configurable format

  tmp = localtime(&present_timestamp);      // break down the timestamp     
      
  // use strftime() to display the date and time in some other formats
  // https://www.geeksforgeeks.org/strftime-function-in-c/ 

  // the following gives output in this form -->  03/22/19 - 12:11 pm EDT
    //   where %x --> writes localized date representation
    //         %I --> writes hour as a decimal number, 12 hour clock (range [01,12])

    //         %M --> writes minute as a decimal number (range [00,59]) 
    //         %P --> writes localized a.m. or p.m. (locale dependent)
    //         %Z --> time zone abbreviation name
  strftime(FORMATTED_TIME, sizeof(FORMATTED_TIME), "%x - %I:%M%P %Z", tmp);  
  TSerial.println(FORMATTED_TIME);
 
  // the following gives output in this form -->  2019-03-22 12:11:51
    //         %F --> equivalent to "%Y-%m-%d" (the ISO 8601 date format)     
    //         %T --> equivalent to "%H:%M:%S" (the ISO 8601 time format) 
  strftime(FORMATTED_TIME, sizeof(FORMATTED_TIME), "%F %T", tmp);
  TSerial.println(FORMATTED_TIME);
    
  TSerial.println();
}

void ClearDisplay()
{

   MainClockDisplay.clear();
   SecondsDisplay.clear();
  
}

void ClockDisplayShutdown()
{
  byte i;
  
  for (i=0;i<=3;i++)
  {
     MainClockDisplay.control(i, MD_MAX72XX::SHUTDOWN, MD_MAX72XX::ON);
     SecondsDisplay.control(i, MD_MAX72XX::SHUTDOWN, MD_MAX72XX::ON);
  }
}

void ClockDisplayTurnOn()
{
  byte i;
  
  for (i=0;i<=3;i++)
  {
     MainClockDisplay.control(i, MD_MAX72XX::SHUTDOWN, MD_MAX72XX::OFF);
     SecondsDisplay.control(i, MD_MAX72XX::SHUTDOWN, MD_MAX72XX::OFF);
  }  
}

void scrollText(const char *p)
{

  uint8_t charWidth;
  uint8_t cBuf[8];  // this should be ok for all built-in fonts

  //PRINTS("\nScrolling text");
  MainClockDisplay.clear();

  while (*p != '\0')
  {
    charWidth = MainClockDisplay.getChar(*p++, sizeof(cBuf) / sizeof(cBuf[0]), cBuf);

    for (uint8_t i=0; i<=charWidth; i++)  // allow space between characters
    {
      MainClockDisplay.transform(MD_MAX72XX::TSL);
      if (i < charWidth)
        MainClockDisplay.setColumn(0, cBuf[i]);
      delay(DELAYTIME);
    }
  }
}



void ColonOff()
{
   MainClockDisplay.setChar(COL_SEP,32);  //blank the colon after 500ms
}


void DisplayFixedIntervals()
{
  SecondsDisplay.update(MD_MAX72XX::OFF); 
  
  SecondsDisplay.clear(3,3);
  SecondsDisplay.setColumn(COL_INTERVALS_SECS_START,0xFF);
  SecondsDisplay.setColumn(COL_INTERVALS_SECS_START+1,0xFF);


        
  SecondsDisplay.update();
  SecondsDisplay.update(MD_MAX72XX::ON);  
}

void SetOuterLEDs(int Seconds)
{
    byte c,r,s;
    
    if (Seconds >= 60)
    {
      Seconds = Seconds % 60;
    }
    SecondsDisplay.clear(2,2);

    
   for (s = 0,r=0,c=0;s<= Seconds;s++)
   {
      SecondsDisplay.setPoint(r,COL_ROTATING_SECS_START + c,true);
      if ( (s+1)%15 == 0)
      {
        c++;
        r=0;
      }
      else
      {
        if ((r+1)%8 == 0)
        {
          c++;
          r=0;
        }
        else
        {
          r++;
        }
      }
   }
}


void SetIntervalLEDs(byte IntervalCount)
{
   byte c,r,s;
   
   for (s = 0,r=0,c=0;s<= IntervalCount;s++)
   {         
      
     SecondsDisplay.setPoint(r,COL_INTERVALS_SECS_START + c,true);
     if ((r+1)%8 == 0)
     {
        c++;
        r=0;
     }
     else
     {
       r++;
     }
   }
}

void UpdateDisplay()
{
    byte col, row;
    int Hours;
    int Minutes;
    int Seconds;
    byte c,r,s,Rows;
    byte IntervalCount;
    
    time(&now);
    timeinfo = localtime(&now);

    Hours = timeinfo->tm_hour;
    Minutes = timeinfo->tm_min;
    Seconds = timeinfo->tm_sec;

    if (InitialUpdate)
    {
      TSerial.print("UpdateDisplay: Time displayed = ");
      if (Hours < 10)
      {
         TSerial.print("0");
      }
      TSerial.print(Hours);
      TSerial.print(":");
      if (Minutes < 10)
      {
         TSerial.print("0");         
      }
      TSerial.print(Minutes);
      TSerial.print(":");
      if (Seconds < 10)
      {
         TSerial.print("0");         
      }
      TSerial.println(Seconds);

      InitialUpdate = false;
    }

    if ((Hours >= 1) && (Hours <= 6))
    {//shut down out of hours
      if (DisplayShutdown == false)
      {
         ClockDisplayShutdown();
         DisplayShutdown = true;
      }
      return;
    }
    else
    {
      if (DisplayShutdown == true)
      {
         ClockDisplayTurnOn();
         DisplayShutdown = false;
      }     
    }



    if ((Hours >= 8) && (Hours <= 17))
    {
       CurrentBrightness = MAX_BRIGHTNESS;   //max brightness during daylight hours
    }
    else
    {
        CurrentBrightness = MIN_BRIGHTNESS;  //min brightness overnight
    }
    

    if ((Hours != PreviousHours) || (Minutes != PreviousMinutes))
    {//only update the main display if required (i.e. every minute...)
      MainClockDisplay.update(MD_MAX72XX::OFF);
  
      MainClockDisplay.setChar(COL_HRS_MS,0x30+(Hours/10));
      MainClockDisplay.setChar(COL_HRS_LS,0x30+(Hours%10));
      MainClockDisplay.setChar(COL_SEP,58);
      MainClockDisplay.setChar(COL_MINS_MS,0x30+(Minutes/10));
      MainClockDisplay.setChar(COL_MINS_LS,0x30+(Minutes%10));


      MainClockDisplay.control(MD_MAX72XX::INTENSITY, CurrentBrightness);
      MainClockDisplay.update();
      MainClockDisplay.update(MD_MAX72XX::ON);

      PreviousHours = Hours;
      PreviousMinutes = Minutes;
    }

    SecondsDisplay.update(MD_MAX72XX::OFF);
    
    SecondsDisplay.setChar(COL_SECS_MS,(Seconds/10));
    SecondsDisplay.setChar(COL_SECS_LS,(Seconds%10));


    //leds around the circumference...
    //col = Seconds/8;
    //row = Seconds%8;


    if (Seconds == 0)
    {
      
       #ifdef FIXED_INTERVALS
          SecondsDisplay.clear(2,2); //clear outer ring only (seconds)
          SecondsDisplay.setPoint(0,COL_ROTATING_SECS_START,true); //set top of the clock seconds
          MainClockDisplay.setChar(COL_SEP,58);
       #else
          SecondsDisplay.clear(2,3);
          SecondsDisplay.setPoint(0,COL_ROTATING_SECS_START,true); //top of the clock seconds
          SecondsDisplay.setPoint(0,COL_INTERVALS_SECS_START,true); //top of the clock Interval 
          MainClockDisplay.setChar(COL_SEP,58);        
       #endif
       
    }
    else
    {
       MainClockDisplay.setChar(COL_SEP,58);
       SetOuterLEDs(Seconds);
       
       //moving intervals....
       #ifndef FIXED_INTERVALS
         SecondsDisplay.clear(3,3);
         IntervalCount = (Seconds/5);
         SetIntervalLEDs(IntervalCount);   
         
       #endif

    
    

    }

    
    SecondsDisplay.control(MD_MAX72XX::INTENSITY, CurrentBrightness);
    
    SecondsDisplay.update();
    SecondsDisplay.update(MD_MAX72XX::ON);

    //put the time of day out to serial port...
    if (Seconds == 0)
    {
      if (Hours < 10)
      {
         TSerial.print("0");
      }
      TSerial.print(Hours);
      TSerial.print(":");
      if (Minutes < 10)
      {
         TSerial.print("0");         
      }
      TSerial.println(Minutes);


    }
}

void configModeCallback(WiFiManager *myWiFiManager)
{
   scrollText("No default WiFi found. Entering AP config mode...    ");
   TSerial.println("Entered Access Point config mode. Connect to 'RotatingClockAP' using phone/iPad");
}



// ....................................................................................
 
void setup()
{
  WiFi.persistent(false);
  WiFi.mode(WIFI_OFF);
  
  TSerial.begin(115200);
  delay(800);
  

  MainClockDisplay.begin();
  SecondsDisplay.begin();

  ClockDisplayTurnOn();
  ClearDisplay();
  
  MainClockDisplay.setFont(FontDigits5x7);
  SecondsDisplay.setFont(FontDigits5x7);
  //P.displayText(M[curM].pMsg, PA_CENTER, P.getSpeed(), PAUSE_TIME, PA_SCROLL_LEFT, PA_SCROLL_LEFT);


  CurrentBrightness = MAX_BRIGHTNESS;
  
  MainClockDisplay.control(MD_MAX72XX::INTENSITY, CurrentBrightness);
  SecondsDisplay.control(MD_MAX72XX::INTENSITY, CurrentBrightness);



  TimeIsInSync = false;
  
  // make sure the ESP8266 WiFi functions are enabled
  WiFi.mode(WIFI_STA);                  // use only the WiFi 'station' mode
  

  bool res;
  scrollText("Connecting to WiFi...    ");

  //wm.setConfigPortalBlocking(false);
  wm.setAPCallback(configModeCallback);
  wm.setTimeout(600);
  
  res = wm.autoConnect(WIFI_MANAGER_AP);
  if (res == false)
  {
    TSerial.println("Failed to connect and hit the timeout. Restarting...");
    delay(1000);
    ESP.restart();
  }

  while (WiFi.status() != WL_CONNECTED) // wait for connection
  {
    //delay(500);
    TSerial.print(".");
    scrollText("Connecting to WiFi...");
    delay(300);
  } 
  ClearDisplay();
 
  TSerial.println("\nWifi Connected");
  scrollText("WiFi Connected OK!"); 

  ClearDisplay(); 



  //ArduinoOTA.setHostname("RotatingClock");
  ArduinoOTA.setHostname(OTA_NETWORK_NAME);

  
  ArduinoOTA.onStart([]() {
    String type;
    ClearDisplay();
    if (ArduinoOTA.getCommand() == U_FLASH) {
      type = "sketch";
    } else { // U_FS
      type = "filesystem";
    }
    scrollText("S/W Update");

    // NOTE: if updating FS this would be the place to unmount FS using FS.end()
    TSerial.println("Start updating " + type);
  });
  ArduinoOTA.onEnd([]() {
    TSerial.println("\nEnd");   
  });
  
  
  ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
    unsigned int OTA_Percent;
    unsigned int OTA_RotProgress;
    OTA_Percent = (progress / (total / 100));
    TSerial.printf("Progress: %u%%\r",OTA_Percent );
    OTA_RotProgress = map(OTA_Percent,0,100,0,59);
    SetOuterLEDs(OTA_RotProgress);
    if (OTA_Percent < 100)
    {
       SecondsDisplay.setChar(COL_SECS_MS,(OTA_Percent/10));
       SecondsDisplay.setChar(COL_SECS_LS,(OTA_Percent%10));
    }
    else
    {
       SecondsDisplay.clear();
       scrollText("Update Completed");
    }
  });
  ArduinoOTA.onError([](ota_error_t error) {
    TSerial.printf("Error[%u]: ", error);
    scrollText("Update Error");
    if (error == OTA_AUTH_ERROR) {
      TSerial.println("Auth Failed");
    } else if (error == OTA_BEGIN_ERROR) {
      TSerial.println("Begin Failed");
    } else if (error == OTA_CONNECT_ERROR) {
      TSerial.println("Connect Failed");
    } else if (error == OTA_RECEIVE_ERROR) {
      TSerial.println("Receive Failed");
    } else if (error == OTA_END_ERROR) {
      TSerial.println("End Failed");
    }
  });
  ArduinoOTA.begin();
  yield();

   // register a callback (execute whenever an NTP update has occurred)
  TSerial.println("Setting NTP callback function");
  settimeofday_cb(time_is_set);
  
  TSerial.println("Manually setting default time for RTC:");
  time_t rtc = RTC_UTC_TEST;
  timeval tv = { rtc, 0 };
  
  settimeofday(&tv, nullptr);

  //time(&now);
  //timeinfo = localtime(&now);

  TSerial.println("Waiting for network time sync...");
  scrollText("Waiting for network time...");


  TSerial.println("Setting config time");
  configTime(MYTZ, "pool.ntp.org");
  
  while (TimeIsInSync == false )
  {
     ArduinoOTA.handle(); 
     scrollText("Waiting...");
     delay(50);
     yield();
  }
  ClearDisplay();
  TSerial.println("Time now in sync with NTP");
  scrollText("Time is in sync");
  delay(1000);
  ClearDisplay();


  #ifdef FIXED_INTERVALS
     DisplayFixedIntervals();
  #endif

}

// ....................................................................................
 
void loop()
{
  unsigned long t1;
  byte i;
  
  ArduinoOTA.handle();
  SerialAndTelnet.handle();

  ColonTimer.update();
  
  present_timestamp = time(nullptr);

  if (present_timestamp >= previous_timestamp + (data_update_seconds)) 
  {
    previous_timestamp = present_timestamp;
    ColonTimer.start();
    UpdateDisplay();

  } 

  //overcomes occasional display shutoffs for no apparent reason!
  if (DisplayShutdown == false)
  {
     //ClockDisplayShutdown();
     //delayMicroseconds(100);
     ClockDisplayTurnOn();   
  }
  
    
}