| 
									
										
										
										
											2017-12-15 23:04:04 +00:00
										 |  |  | /*
 | 
					
						
							| 
									
										
										
										
											2018-03-06 22:47:08 +00:00
										 |  |  |  * Used to draw clock overlays over the strip | 
					
						
							| 
									
										
										
										
											2017-12-15 23:04:04 +00:00
										 |  |  |  */ | 
					
						
							| 
									
										
										
										
											2020-01-02 21:10:59 +00:00
										 |  |  |   | 
					
						
							| 
									
										
										
										
											2018-03-06 22:47:08 +00:00
										 |  |  | void initCronixie() | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2018-09-22 20:49:24 +00:00
										 |  |  |   if (overlayCurrent == 3 && !cronixieInit) | 
					
						
							| 
									
										
										
										
											2018-03-06 22:47:08 +00:00
										 |  |  |   { | 
					
						
							| 
									
										
										
										
											2018-03-13 23:25:54 +00:00
										 |  |  |     setCronixie(); | 
					
						
							| 
									
										
										
										
											2020-03-22 16:45:09 +00:00
										 |  |  |     strip.getSegment(0).grouping = 10; //10 LEDs per digit
 | 
					
						
							| 
									
										
										
										
											2018-03-06 22:47:08 +00:00
										 |  |  |     cronixieInit = true; | 
					
						
							| 
									
										
										
										
											2018-09-22 20:49:24 +00:00
										 |  |  |   } else if (cronixieInit && overlayCurrent != 3) | 
					
						
							| 
									
										
										
										
											2018-03-06 22:47:08 +00:00
										 |  |  |   { | 
					
						
							| 
									
										
										
										
											2020-03-22 16:45:09 +00:00
										 |  |  |     strip.getSegment(0).grouping = 1; | 
					
						
							| 
									
										
										
										
											2018-03-06 22:47:08 +00:00
										 |  |  |     cronixieInit = false;  | 
					
						
							|  |  |  |   } | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2018-09-17 09:15:08 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2016-12-30 23:38:51 +00:00
										 |  |  | void handleOverlays() | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  |   if (millis() - overlayRefreshedTime > overlayRefreshMs) | 
					
						
							|  |  |  |   { | 
					
						
							| 
									
										
										
										
											2018-03-06 22:47:08 +00:00
										 |  |  |     initCronixie(); | 
					
						
							|  |  |  |     updateLocalTime(); | 
					
						
							| 
									
										
										
										
											2018-09-22 20:49:24 +00:00
										 |  |  |     checkTimers(); | 
					
						
							| 
									
										
										
										
											2020-01-02 21:10:59 +00:00
										 |  |  |     checkCountdown(); | 
					
						
							|  |  |  |     if (overlayCurrent == 3) _overlayCronixie();//Diamex cronixie clock kit
 | 
					
						
							| 
									
										
										
										
											2018-03-06 22:47:08 +00:00
										 |  |  |     overlayRefreshedTime = millis(); | 
					
						
							| 
									
										
										
										
											2017-12-02 22:58:22 +00:00
										 |  |  |   } | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							| 
									
										
										
										
											2019-12-10 23:59:15 +00:00
										 |  |  | 
 | 
					
						
							| 
									
										
										
										
											2017-12-02 22:58:22 +00:00
										 |  |  | void _overlayAnalogClock() | 
					
						
							|  |  |  | { | 
					
						
							|  |  |  |   int overlaySize = overlayMax - overlayMin +1; | 
					
						
							| 
									
										
										
										
											2018-03-13 23:25:54 +00:00
										 |  |  |   if (countdownMode) | 
					
						
							| 
									
										
										
										
											2017-12-27 23:37:13 +00:00
										 |  |  |   { | 
					
						
							| 
									
										
										
										
											2018-03-06 22:47:08 +00:00
										 |  |  |     _overlayAnalogCountdown(); return; | 
					
						
							| 
									
										
										
										
											2017-12-27 23:37:13 +00:00
										 |  |  |   } | 
					
						
							| 
									
										
										
										
											2017-12-02 22:58:22 +00:00
										 |  |  |   double hourP = ((double)(hour(local)%12))/12; | 
					
						
							|  |  |  |   double minuteP = ((double)minute(local))/60; | 
					
						
							|  |  |  |   hourP = hourP + minuteP/12; | 
					
						
							|  |  |  |   double secondP = ((double)second(local))/60; | 
					
						
							| 
									
										
										
										
											2017-12-27 23:37:13 +00:00
										 |  |  |   int hourPixel = floor(analogClock12pixel + overlaySize*hourP); | 
					
						
							|  |  |  |   if (hourPixel > overlayMax) hourPixel = overlayMin -1 + hourPixel - overlayMax; | 
					
						
							|  |  |  |   int minutePixel = floor(analogClock12pixel + overlaySize*minuteP); | 
					
						
							|  |  |  |   if (minutePixel > overlayMax) minutePixel = overlayMin -1 + minutePixel - overlayMax;  | 
					
						
							|  |  |  |   int secondPixel = floor(analogClock12pixel + overlaySize*secondP); | 
					
						
							|  |  |  |   if (secondPixel > overlayMax) secondPixel = overlayMin -1 + secondPixel - overlayMax; | 
					
						
							| 
									
										
										
										
											2017-12-02 22:58:22 +00:00
										 |  |  |   if (analogClockSecondsTrail) | 
					
						
							|  |  |  |   { | 
					
						
							| 
									
										
										
										
											2018-03-06 22:47:08 +00:00
										 |  |  |     if (secondPixel < analogClock12pixel) | 
					
						
							|  |  |  |     { | 
					
						
							| 
									
										
										
										
											2018-03-14 10:41:24 +00:00
										 |  |  |       strip.setRange(analogClock12pixel, overlayMax, 0xFF0000); | 
					
						
							|  |  |  |       strip.setRange(overlayMin, secondPixel, 0xFF0000); | 
					
						
							| 
									
										
										
										
											2018-03-06 22:47:08 +00:00
										 |  |  |     } else | 
					
						
							|  |  |  |     { | 
					
						
							|  |  |  |       strip.setRange(analogClock12pixel, secondPixel, 0xFF0000); | 
					
						
							|  |  |  |     } | 
					
						
							| 
									
										
										
										
											2018-03-14 10:41:24 +00:00
										 |  |  |   } | 
					
						
							|  |  |  |   if (analogClock5MinuteMarks) | 
					
						
							| 
									
										
										
										
											2017-12-02 22:58:22 +00:00
										 |  |  |   { | 
					
						
							| 
									
										
										
										
											2018-03-14 10:41:24 +00:00
										 |  |  |     int pix; | 
					
						
							|  |  |  |     for (int i = 0; i <= 12; i++) | 
					
						
							|  |  |  |     { | 
					
						
							| 
									
										
										
										
											2018-10-24 00:06:07 +00:00
										 |  |  |       pix = analogClock12pixel + round((overlaySize / 12.0) *i); | 
					
						
							|  |  |  |       if (pix > overlayMax) pix -= overlaySize; | 
					
						
							| 
									
										
										
										
											2020-01-02 21:10:59 +00:00
										 |  |  |       strip.setPixelColor(pix, 0x00FFAA); | 
					
						
							| 
									
										
										
										
											2018-03-14 10:41:24 +00:00
										 |  |  |     } | 
					
						
							| 
									
										
										
										
											2017-12-02 22:58:22 +00:00
										 |  |  |   } | 
					
						
							| 
									
										
										
										
											2020-01-02 21:10:59 +00:00
										 |  |  |   if (!analogClockSecondsTrail) strip.setPixelColor(secondPixel, 0xFF0000); | 
					
						
							|  |  |  |   strip.setPixelColor(minutePixel, 0x00FF00); | 
					
						
							|  |  |  |   strip.setPixelColor(hourPixel, 0x0000FF); | 
					
						
							| 
									
										
										
										
											2017-12-02 22:58:22 +00:00
										 |  |  |   overlayRefreshMs = 998; | 
					
						
							|  |  |  | } | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | void _overlayAnalogCountdown() | 
					
						
							|  |  |  | { | 
					
						
							| 
									
										
										
										
											2020-01-02 21:10:59 +00:00
										 |  |  |   if (now() < countdownTime) | 
					
						
							| 
									
										
										
										
											2017-12-02 22:58:22 +00:00
										 |  |  |   { | 
					
						
							|  |  |  |     long diff = countdownTime - now(); | 
					
						
							|  |  |  |     double pval = 60; | 
					
						
							|  |  |  |     if (diff > 31557600L) //display in years if more than 365 days
 | 
					
						
							|  |  |  |     { | 
					
						
							|  |  |  |       pval = 315576000L; //10 years
 | 
					
						
							|  |  |  |     } else if (diff > 2592000L) //display in months if more than a month
 | 
					
						
							|  |  |  |     { | 
					
						
							|  |  |  |       pval = 31557600L; //1 year
 | 
					
						
							|  |  |  |     } else if (diff > 604800) //display in weeks if more than a week
 | 
					
						
							|  |  |  |     { | 
					
						
							|  |  |  |       pval = 2592000L; //1 month
 | 
					
						
							|  |  |  |     } else if (diff > 86400) //display in days if more than 24 hours
 | 
					
						
							|  |  |  |     { | 
					
						
							|  |  |  |       pval = 604800; //1 week
 | 
					
						
							|  |  |  |     } else if (diff > 3600) //display in hours if more than 60 minutes
 | 
					
						
							|  |  |  |     { | 
					
						
							|  |  |  |       pval = 86400; //1 day
 | 
					
						
							|  |  |  |     } else if (diff > 60) //display in minutes if more than 60 seconds
 | 
					
						
							|  |  |  |     { | 
					
						
							|  |  |  |       pval = 3600; //1 hour
 | 
					
						
							|  |  |  |     } | 
					
						
							|  |  |  |     int overlaySize = overlayMax - overlayMin +1; | 
					
						
							|  |  |  |     double perc = (pval-(double)diff)/pval; | 
					
						
							|  |  |  |     if (perc > 1.0) perc = 1.0; | 
					
						
							| 
									
										
										
										
											2018-03-14 12:16:28 +00:00
										 |  |  |     byte pixelCnt = perc*overlaySize; | 
					
						
							| 
									
										
										
										
											2017-12-02 22:58:22 +00:00
										 |  |  |     if (analogClock12pixel + pixelCnt > overlayMax) | 
					
						
							|  |  |  |     { | 
					
						
							| 
									
										
										
										
											2019-02-05 20:53:39 +00:00
										 |  |  |       strip.setRange(analogClock12pixel, overlayMax, ((uint32_t)colSec[3] << 24)| ((uint32_t)colSec[0] << 16) | ((uint32_t)colSec[1] << 8) | colSec[2]); | 
					
						
							|  |  |  |       strip.setRange(overlayMin, overlayMin +pixelCnt -(1+ overlayMax -analogClock12pixel), ((uint32_t)colSec[3] << 24)| ((uint32_t)colSec[0] << 16) | ((uint32_t)colSec[1] << 8) | colSec[2]); | 
					
						
							| 
									
										
										
										
											2017-12-02 22:58:22 +00:00
										 |  |  |     } else | 
					
						
							|  |  |  |     { | 
					
						
							| 
									
										
										
										
											2019-02-05 20:53:39 +00:00
										 |  |  |       strip.setRange(analogClock12pixel, analogClock12pixel + pixelCnt, ((uint32_t)colSec[3] << 24)| ((uint32_t)colSec[0] << 16) | ((uint32_t)colSec[1] << 8) | colSec[2]); | 
					
						
							| 
									
										
										
										
											2017-12-02 22:58:22 +00:00
										 |  |  |     } | 
					
						
							|  |  |  |   } | 
					
						
							|  |  |  |   overlayRefreshMs = 998; | 
					
						
							|  |  |  | } | 
					
						
							| 
									
										
										
										
											2020-01-02 21:10:59 +00:00
										 |  |  | 
 | 
					
						
							|  |  |  | 
 | 
					
						
							|  |  |  | void handleOverlayDraw() { | 
					
						
							| 
									
										
										
										
											2020-03-22 16:45:09 +00:00
										 |  |  |   if (!overlayCurrent) return; | 
					
						
							|  |  |  |   switch (overlayCurrent) | 
					
						
							|  |  |  |   { | 
					
						
							|  |  |  |     case 1: _overlayAnalogClock(); break; | 
					
						
							|  |  |  |     case 3: _drawOverlayCronixie(); break; | 
					
						
							|  |  |  |   } | 
					
						
							| 
									
										
										
										
											2020-01-02 21:10:59 +00:00
										 |  |  | } |