Telephone Activation Clock

Clock to activate and de-activate a regular telephone wall connection to allow telephone calls only during selected hours.

Mar 10, 2019

•

4009 views

•

3 respects

clocks

disability reduction

Devices & Components

Arduino Uno Rev3

5 mm LED: Yellow

Rotary potentiometer (generic)

RTC DS3231 ZS-042

Resistor 1k ohm

Resistor 10k ohm

Standard LCD - 16x2 White on Blue

Relais VMA406 (Velleman)

Pushbutton momentary ON

Resistor 220 ohm

Hardware & Tools

Laser cutter (generic)

Soldering iron (generic)

Software & Tools

Inkscape

Box Designer

Arduino IDE

Project description

Code

TELEPHONECLOCK.ino

arduino

Sketch for the Arduino Uno (a few Dutch words used as variables, sorry)

1/*
2 * Telephone activation clock
3 * This is a clock to activate  a telephone for a programmed time.
4 * I use the DS3231 real time clock, this  is more accurate than the DS1302 version from Velleman (VMA 301). 
5 * The 16/2  LCD screen is the one that came with the Genuino Starter kit.
6 * For the relais  I used the Velleman VMA406. For safety reasons i use the normally closed contacts  to have
7 * an active telephone een when power supply to the unit fails.
8 *  
9 * Erik Luyten 
10 * March 11th, 2019
11 */
12
13
14#include <DS3231.h>                     //for clock
15#include <LiquidCrystal.h>              //for  LCD display
16#include <EEPROM.h>                     //for EEPROM on UNO to store  phone activation time settings during power failure
17DS3231  rtc(SDA, SCL);
18LiquidCrystal  lcd(12, 11, 5, 4, 3, 2);
19
20
21
22const int RelayPin = 7;       //activation  relay for telephone (normally closed is used so phone is active if unit is without  power)
23const int LedTel = 6;         //signal LED for phonerelay
24
25//************Buttons  for setclock*****************//
26int P1=8;   // Button SELECT to cycle through  possible MENU settings (0 = display actual date/time TO 10 = store changed values)
27int  P2=9;   // Button + 
28int P3=10;  // Button -
29
30//************Variables for  setclock **************//
31int hourupg;      //upgrade setting for hours
32int  minupg;       //upgrade setting for minutes
33int yearupg;      //upgrade setting  for year (will be set to actual year in SETUP so we don't have to start from zero)
34int  monthupg;     //upgrade setting for month(number)
35int dayupg;       //upgrade  setting for day(number)
36int menu = 0;     //cycles from 0 to 10
37int starthourupg  = 00;   //starting hour for telephone
38int startminupg = 00;    //starting minutes  for telephone
39int stophourupg = 00;    //stop hour for telephone
40int stopminupg  = 00;     //stop minutes for telephone
41unsigned long BreakSetClock;  //breakout  from menu settings after 10 seconds (each buttonpress resets BreakSetClock time)
42
43//************Time  to set phone on and off **********//
44Time PhoneOn;             // Time to activate  telephone
45Time PhoneOff;            // Time to deactivate telephone
46Time ClockTijd;           // Actual DayTime from Real Time Clock
47
48int DST;  //Daylight Saving  Time (read from EEPROM address 0: 0 = winter, 1 = Summer ) (not implemented yet)
49
50unsigned  long StartPhoneSec;        // time to activate telephone in seconds from midnight
51unsigned  long StopPhoneSec;         // time to deactivate telephone in seconds from midnight
52unsigned  long DagSeconden;          // actual seconds since midnight 
53
54Time t;                             //the  actual time/date info
55
56  
57void setup() {
58  Serial.begin(9600);
59  pinMode(RelayPin,  OUTPUT);
60  pinMode(LedTel, OUTPUT);
61
62  pinMode(P1,INPUT);
63  pinMode(P2,INPUT);
64  pinMode(P3,INPUT);
65
66  rtc.begin();
67  lcd.begin(16,2);
68  // ***********  Time and Date (no day of week) can now be set with setup buttons (P1= Menu, P2=  +, P3= -)
69  //rtc.setDOW(SATURDAY);     // Set Day-of-Week to SUNDAY
70  //rtc.setTime(11,19,30);     // Set the time to 12:00:00 (24hr format)
71  //rtc.setDate(23, 2, 2019);   // Day, Month, Year
72  //*******
73  //Default activation time for telephone  (can be changed with setup buttons)
74  /* //not needed anymore since activation  can be set with buttons
75  PhoneOn.hour =  18;
76  PhoneOn.min  =  00;
77  PhoneOn.sec  =  00;
78  
79  //State deactivation time for telephone
80  PhoneOff.hour =  20;
81  PhoneOff.min  =  00;
82  PhoneOff.sec  =  00;
83  //store default activation  and de-activation time to EEPROM in UNO
84  EEPROM.write(1,PhoneOn.hour);
85  EEPROM.write(2,PhoneOn.min);
86  EEPROM.write(3,PhoneOff.hour);
87  EEPROM.write(4,PhoneOff.min);
88  */
89
90//Read  activation and deactivation time from EEPROM at powerup
91  PhoneOn.hour =  EEPROM.read(1);
92  PhoneOn.min  =  EEPROM.read(2);
93  PhoneOff.hour =  EEPROM.read(3);
94  PhoneOff.min  =  EEPROM.read(4);
95
96  StartPhoneSec = seconden(PhoneOn);    //recalculate  Phone starttime to number of seconds since midnight
97  StopPhoneSec = seconden(PhoneOff);    //recalculate Phone stoptime to number of seconds since midnight
98  
99  //  ??? no idea why we have to add 5 years but it works like this ????
100  yearupg  = t.year + 5;     //yearupg is set to actual year to allow easy setup (we do not  have to start from the beginning of (unix) time)
101  
102}
103
104
105void loop()  {
106  
107// check if you press the SET button and increase the menu index
108  if(digitalRead(P1))
109  {
110   menu=menu+1;
111   BreakSetClock = DagSeconden;           //store keypress time to allow breakout after 10 seconds
112  }
113  if  (DagSeconden > (BreakSetClock + 10)) //display time and date after 10 seconds without  keypress
114    {
115      menu = 0;      
116    }
117// in which subroutine should  we go?
118/*
119 * Since clock time settings should be as accurate as possible we  will perform them last in the cycle (just before storing the values).
120 * You  cannot set seconds. This is always 0. Set minutes 1 higher and press select when  the reference clock is at 59 seconds.
121 * This has to be done in the 10 seconds  timeout frame so you might have to press the + and - a few times to cancel the breakout  routine. 
122 */
123  switch (menu) {
124    case 0:
125      DisplayDateTime();      // void DisplayDateTime
126      break;
127    case 1:
128      DisplaySetStartHour();  // void DisplaySetStartHour (for telephone activation)
129      break;
130    case  2:
131      DisplaySetStartMin();   // void DisplaySetStartMin (for telephone activation)
132      break;
133    case 3:
134      DisplaySetStopHour();   // void DisplaySetStopHour  (for telephone De-activation)
135      break;
136    case 4:
137      DisplaySetStopMin();    // void DisplaySetStopMin (for telephone De-activation)
138      break;
139    case 5:
140      DisplaySetYear();       // void DisplaySetYear
141      break;
142    case 6:
143      DisplaySetMonth();      // void DisplaySetMonth
144      break;
145    case 7:
146      DisplaySetDay();        // void DisplaySetDay
147      break;
148    case 8:
149      DisplaySetHour();       // void DisplaySetHour
150      break;
151    case 9:
152      DisplaySetMinute();     // void DisplaySetMinute
153      break;
154    case 10:
155      StoreSettings();        // void StoreSettings (only for the  settings that changed: Time - Date - PhoneOn - PhoneOff)
156      menu=0;
157      break;
158  }
159  
160
161  
162  t = rtc.getTime(); // Read current time and date.
163  DagSeconden  = seconden(t);    //calculate seconds since midnight
164
165// print control info  to Serial Monitor (commented out for better LCD clock response) 
166/*  Serial.print("Uur:  ");
167  Serial.print(t.hour);
168  Serial.print(" Min: ");
169  Serial.print(t.min);
170  Serial.print(" Sec: ");
171  Serial.print(t.sec);
172  Serial.print("  Menupressed:  ");
173  Serial.println(menu);
174
175  Serial.print("Seconden sinds middernacht:  ");
176  Serial.print(DagSeconden);
177  Serial.print(" Start telephone: ");
178  Serial.print(StartPhoneSec);
179  Serial.print(" Stop telephone: ");
180  Serial.println(StopPhoneSec);
181
182
183  Serial.print("Starttijd: ");
184  Serial.print(PhoneOn.hour);
185  Serial.print(":");
186  if (PhoneOn.min < 10)
187    {
188    Serial.print("0");
189    }
190  Serial.print(PhoneOn.min);
191  Serial.print("  Stoptijd: ");
192  Serial.print(PhoneOff.hour);
193  Serial.print(":");
194  if (PhoneOff.min < 10)
195    {
196    Serial.print("0");
197    }
198  Serial.println(PhoneOff.min);
199*/
200  
201  if (StartPhoneSec < StopPhoneSec)   //no activation possible at midnight  - stoptime is larger than starttime
202    {
203      if ((DagSeconden > StartPhoneSec)  && (DagSeconden < StopPhoneSec)) //ClockTime is between start and stop times - activate  phone
204        {
205        digitalWrite(RelayPin, LOW);      
206        digitalWrite(LedTel,  HIGH);  
207        }
208      else                                // Clocktime  is outside start and stoptimes - deactivate phone
209        {
210        digitalWrite(RelayPin,  HIGH);
211        digitalWrite(LedTel, LOW);  
212        }
213    }
214  else if  (StartPhoneSec > StopPhoneSec)  //we are running over midnight to the next day -  phone active at midnight
215    {
216      if (DagSeconden > StartPhoneSec)    //activate  phone
217        {
218        digitalWrite(RelayPin, LOW);  
219        digitalWrite(LedTel,  HIGH);    
220        }
221      else if (DagSeconden > StopPhoneSec)  //deactivate  phone
222        {
223        digitalWrite(RelayPin, HIGH);
224        digitalWrite(LedTel,  LOW);   
225        }
226    }
227   
228
229 delay(500);  //wait 0.5 seconds (keypress  reaction time is 0.5 second)
230
231}
232
233
234unsigned long seconden(Time dezetijd){    //calculate seconds sinds midnight for: ClockTime, PhoneStart and PhoneStop  
235  unsigned long result;
236  unsigned long mijnuur = dezetijd.hour;
237  unsigned  long uurseconden = 3600;
238  result = (dezetijd.sec + dezetijd.min * 60 + mijnuur  * uurseconden);
239  return result;
240}
241
242void DisplayDateTime ()   //show  Time, Date, PhoneStartTime and PhoneStopTime on LCD screen
243{
244 lcd.clear();
245  lcd.setCursor(1,0);
246 lcd.print(rtc.getTimeStr());
247 lcd.print("  ");
248  lcd.print(PhoneOn.hour);
249 lcd.print(":");
250 if (PhoneOn.min < 10)
251  {
252    lcd.print("0");
253  }
254 lcd.print(PhoneOn.min);
255 lcd.setCursor(0,1);
256  lcd.print(rtc.getDateStr());
257 lcd.print(" ");
258 lcd.print(PhoneOff.hour);
259  lcd.print(":");
260 if (PhoneOff.min < 10)
261  {
262    lcd.print("0");
263  }
264  lcd.print(PhoneOff.min);
265}
266
267void DisplaySetHour()   //set clock  hours
268{
269// time setting
270  lcd.clear();  
271  if(digitalRead(P2)==HIGH)
272    {
273      BreakSetClock = DagSeconden;   //store menupress time to allow breakout  after 10 seconds
274      if(hourupg==23)
275      {
276        hourupg=0;
277      }
278      else
279      {
280        hourupg=hourupg+1;
281      }
282    }
283  if(digitalRead(P3)==HIGH)
284    {
285      BreakSetClock = DagSeconden;   //store menupress time to allow breakout  after 10 seconds
286      if(hourupg==0)
287      {
288        hourupg=23;
289      }
290      else
291      {
292        hourupg=hourupg-1;
293      }
294    }
295  lcd.setCursor(0,0);
296  lcd.print("Set hour:");
297  lcd.setCursor(0,1);
298  lcd.print(hourupg,DEC);
299  delay(200);
300}
301
302void DisplaySetMinute() //set clock minutes
303{
304//  Setting the minutes
305  lcd.clear();
306  if(digitalRead(P2)==HIGH)
307  {
308    BreakSetClock = DagSeconden;   //store menupress time to allow breakout after  10 seconds
309    if (minupg==59)
310    {
311      minupg=0;
312    }
313    else
314    {
315      minupg=minupg+1;
316    }
317  }
318   if(digitalRead(P3)==HIGH)
319  {
320    BreakSetClock = DagSeconden;   //store menupress time to allow breakout  after 10 seconds
321    if (minupg==0)
322    {
323      minupg=59;
324    }
325    else
326    {
327      minupg=minupg-1;
328    }
329  }
330  lcd.setCursor(0,0);
331  lcd.print("Set Minutes:");
332  lcd.setCursor(0,1);
333  lcd.print(minupg,DEC);
334  delay(200);
335}
336  
337void DisplaySetYear() //set clock year (allready filled  with year in clockmemory)
338{
339// setting the year
340  lcd.clear();
341  if(digitalRead(P2)==HIGH)
342  {    
343    BreakSetClock = DagSeconden;   //store menupress time to allow breakout  after 10 seconds
344    yearupg=yearupg+1;
345  }
346   if(digitalRead(P3)==HIGH)
347  {
348    BreakSetClock = DagSeconden;   //store menupress time to allow breakout  after 10 seconds
349    yearupg=yearupg-1;
350  }
351  lcd.setCursor(0,0);
352  lcd.print("Set  Year:");
353  lcd.setCursor(0,1);
354  lcd.print(yearupg,DEC);
355  delay(200);
356}
357
358void  DisplaySetMonth()  //set clock month
359{
360// Setting the month
361  lcd.clear();
362  if(digitalRead(P2)==HIGH)
363  {
364    BreakSetClock = DagSeconden;   //store  menupress time to allow breakout after 10 seconds
365    if (monthupg==12)
366    {
367      monthupg=1;
368    }
369    else
370    {
371      monthupg=monthupg+1;
372    }
373  }
374   if(digitalRead(P3)==HIGH)
375  {
376    BreakSetClock = DagSeconden;   //store menupress time to allow breakout after 10 seconds
377    if (monthupg==1)
378    {
379      monthupg=12;
380    }
381    else
382    {
383      monthupg=monthupg-1;
384    }
385  }
386  lcd.setCursor(0,0);
387  lcd.print("Set Month:");
388  lcd.setCursor(0,1);
389  lcd.print(monthupg,DEC);
390  delay(200);
391}
392
393void DisplaySetDay()  //set  clock day
394{
395// Setting the day
396  lcd.clear();
397  if(digitalRead(P2)==HIGH)
398  {
399    BreakSetClock = DagSeconden;   //store menupress time to allow breakout  after 10 seconds
400    if (dayupg==31)
401    {
402      dayupg=1;
403    }
404    else
405    {
406      dayupg=dayupg+1;
407    }
408  }
409   if(digitalRead(P3)==HIGH)
410  {
411    BreakSetClock = DagSeconden;   //store menupress time to allow breakout  after 10 seconds
412    if (dayupg==1)
413    {
414      dayupg=31;
415    }
416    else
417    {
418      dayupg=dayupg-1;
419    }
420  }
421  lcd.setCursor(0,0);
422  lcd.print("Set Day:");
423  lcd.setCursor(0,1);
424  lcd.print(dayupg,DEC);
425  delay(200);
426
427}
428
429void DisplaySetStartHour()  //set phone starthour
430{
431//  time setting
432  lcd.clear();  
433  lcd.setCursor(0,0);
434  lcd.print("Set starthour:");
435  lcd.setCursor(0,1);
436  lcd.print(starthourupg,DEC);
437  if(digitalRead(P2)==HIGH)
438    {
439      BreakSetClock = DagSeconden;   //store menupress time to allow breakout  after 10 seconds
440      if(starthourupg==23)
441      {
442        starthourupg=0;
443      }
444      else
445      {
446        starthourupg=starthourupg+1;
447      }
448    }
449  if(digitalRead(P3)==HIGH)
450    {
451      BreakSetClock = DagSeconden;   //store menupress time to allow breakout after 10 seconds
452      if(starthourupg==0)
453      {
454        starthourupg=23;
455      }
456      else
457      {
458        starthourupg=starthourupg-1;
459      }
460    }
461  delay(200);
462}
463
464void DisplaySetStartMin() //set phonestartminutes
465{
466//  time setting
467  lcd.clear();  
468  lcd.setCursor(0,0);
469  lcd.print("Set startminutes:");
470  lcd.setCursor(0,1);
471  lcd.print(startminupg,DEC);
472  if(digitalRead(P2)==HIGH)
473    {
474      BreakSetClock = DagSeconden;   //store menupress time to allow breakout  after 10 seconds
475      if(startminupg==59)
476      {
477        startminupg=0;
478      }
479      else
480      {
481        startminupg=startminupg+1;
482      }
483    }
484  if(digitalRead(P3)==HIGH)
485    {
486      BreakSetClock = DagSeconden;   //store menupress time to allow breakout after 10 seconds
487      if(startminupg==0)
488      {
489        startminupg=59;
490      }
491      else
492      {
493        startminupg=startminupg-1;
494      }
495    }
496  delay(200);
497}
498
499void DisplaySetStopHour()   //set  phonestophour
500{
501// time setting
502  lcd.clear();  
503  lcd.setCursor(0,0);
504  lcd.print("Set stophour:");
505  lcd.setCursor(0,1);
506  lcd.print(stophourupg,DEC);
507  if(digitalRead(P2)==HIGH)
508    {
509      BreakSetClock = DagSeconden;   //store  menupress time to allow breakout after 10 seconds
510      if(stophourupg==23)
511      {
512        stophourupg=0;
513      }
514      else
515      {
516        stophourupg=stophourupg+1;
517      }
518    }
519  if(digitalRead(P3)==HIGH)
520    {
521      BreakSetClock  = DagSeconden;   //store menupress time to allow breakout after 10 seconds
522      if(stophourupg==0)
523      {
524        stophourupg=23;
525      }
526      else
527      {
528        stophourupg=stophourupg-1;
529      }
530    }
531  delay(200);
532}
533
534void DisplaySetStopMin()  //set phonestopminutes
535{
536//  time setting
537  lcd.clear();  
538  lcd.setCursor(0,0);
539  lcd.print("Set stopminutes:");
540  lcd.setCursor(0,1);
541  lcd.print(stopminupg,DEC);
542  if(digitalRead(P2)==HIGH)
543    {
544      BreakSetClock = DagSeconden;   //store menupress time to allow breakout  after 10 seconds
545      if(stopminupg==59)
546      {
547        stopminupg=0;
548      }
549      else
550      {
551        stopminupg=stopminupg+1;
552      }
553    }
554  if(digitalRead(P3)==HIGH)
555    {
556      BreakSetClock = DagSeconden;   //store menupress time to allow breakout after 10 seconds
557      if(stopminupg==0)
558      {
559        stopminupg=59;
560      }
561      else
562      {
563        stopminupg=stopminupg-1;
564      }
565    }
566  delay(200);
567}
568
569void StoreSettings()    //store the  results depending on values in variables
570{
571// Saving Time, Date, StopTime  and StartTime only if they are changed
572// Disabled message to LCD to allow more  accurate time setting 
573
574  lcd.clear();
575  lcd.setCursor(0,0);
576  if ((hourupg  == 0) && (minupg == 0))    //do not set time if both hours and minutes are zero  (cannot set clock to midnight time)
577    {
578      lcd.print("TIME not saved  !");  
579      delay(2000);
580    }
581  else
582    {
583      lcd.print("Saving  TIME");
584      rtc.setTime(hourupg,minupg,00);     // Set the time (24hr format)
585      hourupg = 0;
586      minupg = 0;
587      delay(2000); 
588    }
589  lcd.clear();
590  lcd.setCursor(0,0);
591  if ((dayupg == 0) || (monthupg == 0) || (yearupg == 0))  //do not set date if any of these values is zero
592    {
593      lcd.print("DATE  not saved !");
594      delay(2000);
595    }
596  else 
597    {
598      lcd.print("Saving  DATE");
599      rtc.setDate(dayupg, monthupg, yearupg);   // Day, Month, Year
600      dayupg = 0;
601      monthupg = 0;
602      delay(2000);
603    }
604  
605    
606//First Check if start and stoptime are not the same (should be at least  one minute difference)  
607  lcd.clear();
608  lcd.setCursor(0,0);
609  if ((starthourupg  == stophourupg) && (startminupg == stopminupg) && ((starthourupg + startminupg +  stophourupg + stopminupg) != 0))
610    {
611      lcd.print("START & STOPTIME");
612      lcd.setCursor(0,1);
613      lcd.print("Cant be the same");
614      delay(2000);
615    }
616  else 
617    {  
618    //check to see if starttime should be saved
619      if ((starthourupg == 0) && (startminupg == 0))  //don't set starttime if both  hours and minutes are zero(cannot set starttime to midnight)
620        {
621          lcd.print("STARTTIME  ");  
622          lcd.setCursor(0,1);  
623          lcd.print("not saved !");
624          delay(2000);
625        }
626      else
627        {
628          lcd.print("Saving  STARTTIME");
629          PhoneOn.hour =  starthourupg;
630          PhoneOn.min  =  startminupg;
631          PhoneOn.sec  =  00;
632          StartPhoneSec =  seconden(PhoneOn);    //recalculate Phone starttime to number of seconds since midnight
633          EEPROM.write(1,PhoneOn.hour);         //write activation time to EEPROM  on UNO 
634          EEPROM.write(2,PhoneOn.min);          //write activation time  to EEPROM on UNO 
635          lcd.setCursor(0,1);
636          lcd.print(PhoneOn.hour);
637          lcd.print(":");
638          if (PhoneOn.min < 10)
639            {
640              lcd.print("0");
641            }
642          lcd.print(PhoneOn.min);
643          starthourupg = 0;
644          startminupg = 0;
645          delay(2000);  
646        }
647      
648      lcd.clear();
649      lcd.setCursor(0,0);
650    //check to aee if stoptime should be changed  
651      if ((stophourupg ==  0) && (stopminupg == 0))  //don't set stoptime if both hours and minutes are zero(cannot  set stoptime to midnight)
652        {
653          lcd.print("STOPTIME ");
654          lcd.setCursor(0,1);  
655          lcd.print("not saved !");
656          delay(2000);
657        }
658      else
659        {
660          lcd.print("Saving STOPTIME");
661          PhoneOff.hour =  stophourupg;
662          PhoneOff.min  =  stopminupg;
663          PhoneOff.sec  =  00;
664          StopPhoneSec = seconden(PhoneOff);    //recalculate  Phone stoptime to number of seconds since midnight
665          EEPROM.write(3,PhoneOff.hour);        //write de-activation time to EEPROM on UNO 
666          EEPROM.write(4,PhoneOff.min);         //write de-activation time to EEPROM on UNO
667          lcd.setCursor(0,1);
668          lcd.print(PhoneOff.hour);
669          lcd.print(":");
670          if  (PhoneOff.min < 10)
671            {
672              lcd.print("0");
673            }
674          lcd.print(PhoneOff.min);
675          stophourupg = 0;
676          stopminupg  = 0;
677          delay(2000);
678        }
679    }
680  //delay(200);
681}
682

/*
 * Telephone activation clock
 * This is a clock to activate  a telephone for a programmed time.
 * I use the DS3231 real time clock, this  is more accurate than the DS1302 version from Velleman (VMA 301). 
 * The 16/2  LCD screen is the one that came with the Genuino Starter kit.
 * For the relais  I used the Velleman VMA406. For safety reasons i use the normally closed contacts  to have
 * an active telephone een when power supply to the unit fails.
 *  
 * Erik Luyten 
 * March 11th, 2019
 */


#include <DS3231.h>                     //for clock
#include <LiquidCrystal.h>              //for  LCD display
#include <EEPROM.h>                     //for EEPROM on UNO to store  phone activation time settings during power failure
DS3231  rtc(SDA, SCL);
LiquidCrystal  lcd(12, 11, 5, 4, 3, 2);



const int RelayPin = 7;       //activation  relay for telephone (normally closed is used so phone is active if unit is without  power)
const int LedTel = 6;         //signal LED for phonerelay

//************Buttons  for setclock*****************//
int P1=8;   // Button SELECT to cycle through  possible MENU settings (0 = display actual date/time TO 10 = store changed values)
int  P2=9;   // Button + 
int P3=10;  // Button -

//************Variables for  setclock **************//
int hourupg;      //upgrade setting for hours
int  minupg;       //upgrade setting for minutes
int yearupg;      //upgrade setting  for year (will be set to actual year in SETUP so we don't have to start from zero)
int  monthupg;     //upgrade setting for month(number)
int dayupg;       //upgrade  setting for day(number)
int menu = 0;     //cycles from 0 to 10
int starthourupg  = 00;   //starting hour for telephone
int startminupg = 00;    //starting minutes  for telephone
int stophourupg = 00;    //stop hour for telephone
int stopminupg  = 00;     //stop minutes for telephone
unsigned long BreakSetClock;  //breakout  from menu settings after 10 seconds (each buttonpress resets BreakSetClock time)

//************Time  to set phone on and off **********//
Time PhoneOn;             // Time to activate  telephone
Time PhoneOff;            // Time to deactivate telephone
Time ClockTijd;           // Actual DayTime from Real Time Clock

int DST;  //Daylight Saving  Time (read from EEPROM address 0: 0 = winter, 1 = Summer ) (not implemented yet)

unsigned  long StartPhoneSec;        // time to activate telephone in seconds from midnight
unsigned  long StopPhoneSec;         // time to deactivate telephone in seconds from midnight
unsigned  long DagSeconden;          // actual seconds since midnight 

Time t;                             //the  actual time/date info

  
void setup() {
  Serial.begin(9600);
  pinMode(RelayPin,  OUTPUT);
  pinMode(LedTel, OUTPUT);

  pinMode(P1,INPUT);
  pinMode(P2,INPUT);
  pinMode(P3,INPUT);

  rtc.begin();
  lcd.begin(16,2);
  // ***********  Time and Date (no day of week) can now be set with setup buttons (P1= Menu, P2=  +, P3= -)
  //rtc.setDOW(SATURDAY);     // Set Day-of-Week to SUNDAY
  //rtc.setTime(11,19,30);     // Set the time to 12:00:00 (24hr format)
  //rtc.setDate(23, 2, 2019);   // Day, Month, Year
  //*******
  //Default activation time for telephone  (can be changed with setup buttons)
  /* //not needed anymore since activation  can be set with buttons
  PhoneOn.hour =  18;
  PhoneOn.min  =  00;
  PhoneOn.sec  =  00;
  
  //State deactivation time for telephone
  PhoneOff.hour =  20;
  PhoneOff.min  =  00;
  PhoneOff.sec  =  00;
  //store default activation  and de-activation time to EEPROM in UNO
  EEPROM.write(1,PhoneOn.hour);
  EEPROM.write(2,PhoneOn.min);
  EEPROM.write(3,PhoneOff.hour);
  EEPROM.write(4,PhoneOff.min);
  */

//Read  activation and deactivation time from EEPROM at powerup
  PhoneOn.hour =  EEPROM.read(1);
  PhoneOn.min  =  EEPROM.read(2);
  PhoneOff.hour =  EEPROM.read(3);
  PhoneOff.min  =  EEPROM.read(4);

  StartPhoneSec = seconden(PhoneOn);    //recalculate  Phone starttime to number of seconds since midnight
  StopPhoneSec = seconden(PhoneOff);    //recalculate Phone stoptime to number of seconds since midnight
  
  //  ??? no idea why we have to add 5 years but it works like this ????
  yearupg  = t.year + 5;     //yearupg is set to actual year to allow easy setup (we do not  have to start from the beginning of (unix) time)
  
}


void loop()  {
  
// check if you press the SET button and increase the menu index
  if(digitalRead(P1))
  {
   menu=menu+1;
   BreakSetClock = DagSeconden;           //store keypress time to allow breakout after 10 seconds
  }
  if  (DagSeconden > (BreakSetClock + 10)) //display time and date after 10 seconds without  keypress
    {
      menu = 0;      
    }
// in which subroutine should  we go?
/*
 * Since clock time settings should be as accurate as possible we  will perform them last in the cycle (just before storing the values).
 * You  cannot set seconds. This is always 0. Set minutes 1 higher and press select when  the reference clock is at 59 seconds.
 * This has to be done in the 10 seconds  timeout frame so you might have to press the + and - a few times to cancel the breakout  routine. 
 */
  switch (menu) {
    case 0:
      DisplayDateTime();      // void DisplayDateTime
      break;
    case 1:
      DisplaySetStartHour();  // void DisplaySetStartHour (for telephone activation)
      break;
    case  2:
      DisplaySetStartMin();   // void DisplaySetStartMin (for telephone activation)
      break;
    case 3:
      DisplaySetStopHour();   // void DisplaySetStopHour  (for telephone De-activation)
      break;
    case 4:
      DisplaySetStopMin();    // void DisplaySetStopMin (for telephone De-activation)
      break;
    case 5:
      DisplaySetYear();       // void DisplaySetYear
      break;
    case 6:
      DisplaySetMonth();      // void DisplaySetMonth
      break;
    case 7:
      DisplaySetDay();        // void DisplaySetDay
      break;
    case 8:
      DisplaySetHour();       // void DisplaySetHour
      break;
    case 9:
      DisplaySetMinute();     // void DisplaySetMinute
      break;
    case 10:
      StoreSettings();        // void StoreSettings (only for the  settings that changed: Time - Date - PhoneOn - PhoneOff)
      menu=0;
      break;
  }
  

  
  t = rtc.getTime(); // Read current time and date.
  DagSeconden  = seconden(t);    //calculate seconds since midnight

// print control info  to Serial Monitor (commented out for better LCD clock response) 
/*  Serial.print("Uur:  ");
  Serial.print(t.hour);
  Serial.print(" Min: ");
  Serial.print(t.min);
  Serial.print(" Sec: ");
  Serial.print(t.sec);
  Serial.print("  Menupressed:  ");
  Serial.println(menu);

  Serial.print("Seconden sinds middernacht:  ");
  Serial.print(DagSeconden);
  Serial.print(" Start telephone: ");
  Serial.print(StartPhoneSec);
  Serial.print(" Stop telephone: ");
  Serial.println(StopPhoneSec);


  Serial.print("Starttijd: ");
  Serial.print(PhoneOn.hour);
  Serial.print(":");
  if (PhoneOn.min < 10)
    {
    Serial.print("0");
    }
  Serial.print(PhoneOn.min);
  Serial.print("  Stoptijd: ");
  Serial.print(PhoneOff.hour);
  Serial.print(":");
  if (PhoneOff.min < 10)
    {
    Serial.print("0");
    }
  Serial.println(PhoneOff.min);
*/
  
  if (StartPhoneSec < StopPhoneSec)   //no activation possible at midnight  - stoptime is larger than starttime
    {
      if ((DagSeconden > StartPhoneSec)  && (DagSeconden < StopPhoneSec)) //ClockTime is between start and stop times - activate  phone
        {
        digitalWrite(RelayPin, LOW);      
        digitalWrite(LedTel,  HIGH);  
        }
      else                                // Clocktime  is outside start and stoptimes - deactivate phone
        {
        digitalWrite(RelayPin,  HIGH);
        digitalWrite(LedTel, LOW);  
        }
    }
  else if  (StartPhoneSec > StopPhoneSec)  //we are running over midnight to the next day -  phone active at midnight
    {
      if (DagSeconden > StartPhoneSec)    //activate  phone
        {
        digitalWrite(RelayPin, LOW);  
        digitalWrite(LedTel,  HIGH);    
        }
      else if (DagSeconden > StopPhoneSec)  //deactivate  phone
        {
        digitalWrite(RelayPin, HIGH);
        digitalWrite(LedTel,  LOW);   
        }
    }
   

 delay(500);  //wait 0.5 seconds (keypress  reaction time is 0.5 second)

}


unsigned long seconden(Time dezetijd){    //calculate seconds sinds midnight for: ClockTime, PhoneStart and PhoneStop  
  unsigned long result;
  unsigned long mijnuur = dezetijd.hour;
  unsigned  long uurseconden = 3600;
  result = (dezetijd.sec + dezetijd.min * 60 + mijnuur  * uurseconden);
  return result;
}

void DisplayDateTime ()   //show  Time, Date, PhoneStartTime and PhoneStopTime on LCD screen
{
 lcd.clear();
  lcd.setCursor(1,0);
 lcd.print(rtc.getTimeStr());
 lcd.print("  ");
  lcd.print(PhoneOn.hour);
 lcd.print(":");
 if (PhoneOn.min < 10)
  {
    lcd.print("0");
  }
 lcd.print(PhoneOn.min);
 lcd.setCursor(0,1);
  lcd.print(rtc.getDateStr());
 lcd.print(" ");
 lcd.print(PhoneOff.hour);
  lcd.print(":");
 if (PhoneOff.min < 10)
  {
    lcd.print("0");
  }
  lcd.print(PhoneOff.min);
}

void DisplaySetHour()   //set clock  hours
{
// time setting
  lcd.clear();  
  if(digitalRead(P2)==HIGH)
    {
      BreakSetClock = DagSeconden;   //store menupress time to allow breakout  after 10 seconds
      if(hourupg==23)
      {
        hourupg=0;
      }
      else
      {
        hourupg=hourupg+1;
      }
    }
  if(digitalRead(P3)==HIGH)
    {
      BreakSetClock = DagSeconden;   //store menupress time to allow breakout  after 10 seconds
      if(hourupg==0)
      {
        hourupg=23;
      }
      else
      {
        hourupg=hourupg-1;
      }
    }
  lcd.setCursor(0,0);
  lcd.print("Set hour:");
  lcd.setCursor(0,1);
  lcd.print(hourupg,DEC);
  delay(200);
}

void DisplaySetMinute() //set clock minutes
{
//  Setting the minutes
  lcd.clear();
  if(digitalRead(P2)==HIGH)
  {
    BreakSetClock = DagSeconden;   //store menupress time to allow breakout after  10 seconds
    if (minupg==59)
    {
      minupg=0;
    }
    else
    {
      minupg=minupg+1;
    }
  }
   if(digitalRead(P3)==HIGH)
  {
    BreakSetClock = DagSeconden;   //store menupress time to allow breakout  after 10 seconds
    if (minupg==0)
    {
      minupg=59;
    }
    else
    {
      minupg=minupg-1;
    }
  }
  lcd.setCursor(0,0);
  lcd.print("Set Minutes:");
  lcd.setCursor(0,1);
  lcd.print(minupg,DEC);
  delay(200);
}
  
void DisplaySetYear() //set clock year (allready filled  with year in clockmemory)
{
// setting the year
  lcd.clear();
  if(digitalRead(P2)==HIGH)
  {    
    BreakSetClock = DagSeconden;   //store menupress time to allow breakout  after 10 seconds
    yearupg=yearupg+1;
  }
   if(digitalRead(P3)==HIGH)
  {
    BreakSetClock = DagSeconden;   //store menupress time to allow breakout  after 10 seconds
    yearupg=yearupg-1;
  }
  lcd.setCursor(0,0);
  lcd.print("Set  Year:");
  lcd.setCursor(0,1);
  lcd.print(yearupg,DEC);
  delay(200);
}

void  DisplaySetMonth()  //set clock month
{
// Setting the month
  lcd.clear();
  if(digitalRead(P2)==HIGH)
  {
    BreakSetClock = DagSeconden;   //store  menupress time to allow breakout after 10 seconds
    if (monthupg==12)
    {
      monthupg=1;
    }
    else
    {
      monthupg=monthupg+1;
    }
  }
   if(digitalRead(P3)==HIGH)
  {
    BreakSetClock = DagSeconden;   //store menupress time to allow breakout after 10 seconds
    if (monthupg==1)
    {
      monthupg=12;
    }
    else
    {
      monthupg=monthupg-1;
    }
  }
  lcd.setCursor(0,0);
  lcd.print("Set Month:");
  lcd.setCursor(0,1);
  lcd.print(monthupg,DEC);
  delay(200);
}

void DisplaySetDay()  //set  clock day
{
// Setting the day
  lcd.clear();
  if(digitalRead(P2)==HIGH)
  {
    BreakSetClock = DagSeconden;   //store menupress time to allow breakout  after 10 seconds
    if (dayupg==31)
    {
      dayupg=1;
    }
    else
    {
      dayupg=dayupg+1;
    }
  }
   if(digitalRead(P3)==HIGH)
  {
    BreakSetClock = DagSeconden;   //store menupress time to allow breakout  after 10 seconds
    if (dayupg==1)
    {
      dayupg=31;
    }
    else
    {
      dayupg=dayupg-1;
    }
  }
  lcd.setCursor(0,0);
  lcd.print("Set Day:");
  lcd.setCursor(0,1);
  lcd.print(dayupg,DEC);
  delay(200);

}

void DisplaySetStartHour()  //set phone starthour
{
//  time setting
  lcd.clear();  
  lcd.setCursor(0,0);
  lcd.print("Set starthour:");
  lcd.setCursor(0,1);
  lcd.print(starthourupg,DEC);
  if(digitalRead(P2)==HIGH)
    {
      BreakSetClock = DagSeconden;   //store menupress time to allow breakout  after 10 seconds
      if(starthourupg==23)
      {
        starthourupg=0;
      }
      else
      {
        starthourupg=starthourupg+1;
      }
    }
  if(digitalRead(P3)==HIGH)
    {
      BreakSetClock = DagSeconden;   //store menupress time to allow breakout after 10 seconds
      if(starthourupg==0)
      {
        starthourupg=23;
      }
      else
      {
        starthourupg=starthourupg-1;
      }
    }
  delay(200);
}

void DisplaySetStartMin() //set phonestartminutes
{
//  time setting
  lcd.clear();  
  lcd.setCursor(0,0);
  lcd.print("Set startminutes:");
  lcd.setCursor(0,1);
  lcd.print(startminupg,DEC);
  if(digitalRead(P2)==HIGH)
    {
      BreakSetClock = DagSeconden;   //store menupress time to allow breakout  after 10 seconds
      if(startminupg==59)
      {
        startminupg=0;
      }
      else
      {
        startminupg=startminupg+1;
      }
    }
  if(digitalRead(P3)==HIGH)
    {
      BreakSetClock = DagSeconden;   //store menupress time to allow breakout after 10 seconds
      if(startminupg==0)
      {
        startminupg=59;
      }
      else
      {
        startminupg=startminupg-1;
      }
    }
  delay(200);
}

void DisplaySetStopHour()   //set  phonestophour
{
// time setting
  lcd.clear();  
  lcd.setCursor(0,0);
  lcd.print("Set stophour:");
  lcd.setCursor(0,1);
  lcd.print(stophourupg,DEC);
  if(digitalRead(P2)==HIGH)
    {
      BreakSetClock = DagSeconden;   //store  menupress time to allow breakout after 10 seconds
      if(stophourupg==23)
      {
        stophourupg=0;
      }
      else
      {
        stophourupg=stophourupg+1;
      }
    }
  if(digitalRead(P3)==HIGH)
    {
      BreakSetClock  = DagSeconden;   //store menupress time to allow breakout after 10 seconds
      if(stophourupg==0)
      {
        stophourupg=23;
      }
      else
      {
        stophourupg=stophourupg-1;
      }
    }
  delay(200);
}

void DisplaySetStopMin()  //set phonestopminutes
{
//  time setting
  lcd.clear();  
  lcd.setCursor(0,0);
  lcd.print("Set stopminutes:");
  lcd.setCursor(0,1);
  lcd.print(stopminupg,DEC);
  if(digitalRead(P2)==HIGH)
    {
      BreakSetClock = DagSeconden;   //store menupress time to allow breakout  after 10 seconds
      if(stopminupg==59)
      {
        stopminupg=0;
      }
      else
      {
        stopminupg=stopminupg+1;
      }
    }
  if(digitalRead(P3)==HIGH)
    {
      BreakSetClock = DagSeconden;   //store menupress time to allow breakout after 10 seconds
      if(stopminupg==0)
      {
        stopminupg=59;
      }
      else
      {
        stopminupg=stopminupg-1;
      }
    }
  delay(200);
}

void StoreSettings()    //store the  results depending on values in variables
{
// Saving Time, Date, StopTime  and StartTime only if they are changed
// Disabled message to LCD to allow more  accurate time setting 

  lcd.clear();
  lcd.setCursor(0,0);
  if ((hourupg  == 0) && (minupg == 0))    //do not set time if both hours and minutes are zero  (cannot set clock to midnight time)
    {
      lcd.print("TIME not saved  !");  
      delay(2000);
    }
  else
    {
      lcd.print("Saving  TIME");
      rtc.setTime(hourupg,minupg,00);     // Set the time (24hr format)
      hourupg = 0;
      minupg = 0;
      delay(2000); 
    }
  lcd.clear();
  lcd.setCursor(0,0);
  if ((dayupg == 0) || (monthupg == 0) || (yearupg == 0))  //do not set date if any of these values is zero
    {
      lcd.print("DATE  not saved !");
      delay(2000);
    }
  else 
    {
      lcd.print("Saving  DATE");
      rtc.setDate(dayupg, monthupg, yearupg);   // Day, Month, Year
      dayupg = 0;
      monthupg = 0;
      delay(2000);
    }
  
    
//First Check if start and stoptime are not the same (should be at least  one minute difference)  
  lcd.clear();
  lcd.setCursor(0,0);
  if ((starthourupg  == stophourupg) && (startminupg == stopminupg) && ((starthourupg + startminupg +  stophourupg + stopminupg) != 0))
    {
      lcd.print("START & STOPTIME");
      lcd.setCursor(0,1);
      lcd.print("Cant be the same");
      delay(2000);
    }
  else 
    {  
    //check to see if starttime should be saved
      if ((starthourupg == 0) && (startminupg == 0))  //don't set starttime if both  hours and minutes are zero(cannot set starttime to midnight)
        {
          lcd.print("STARTTIME  ");  
          lcd.setCursor(0,1);  
          lcd.print("not saved !");
          delay(2000);
        }
      else
        {
          lcd.print("Saving  STARTTIME");
          PhoneOn.hour =  starthourupg;
          PhoneOn.min  =  startminupg;
          PhoneOn.sec  =  00;
          StartPhoneSec =  seconden(PhoneOn);    //recalculate Phone starttime to number of seconds since midnight
          EEPROM.write(1,PhoneOn.hour);         //write activation time to EEPROM  on UNO 
          EEPROM.write(2,PhoneOn.min);          //write activation time  to EEPROM on UNO 
          lcd.setCursor(0,1);
          lcd.print(PhoneOn.hour);
          lcd.print(":");
          if (PhoneOn.min < 10)
            {
              lcd.print("0");
            }
          lcd.print(PhoneOn.min);
          starthourupg = 0;
          startminupg = 0;
          delay(2000);  
        }
      
      lcd.clear();
      lcd.setCursor(0,0);
    //check to aee if stoptime should be changed  
      if ((stophourupg ==  0) && (stopminupg == 0))  //don't set stoptime if both hours and minutes are zero(cannot  set stoptime to midnight)
        {
          lcd.print("STOPTIME ");
          lcd.setCursor(0,1);  
          lcd.print("not saved !");
          delay(2000);
        }
      else
        {
          lcd.print("Saving STOPTIME");
          PhoneOff.hour =  stophourupg;
          PhoneOff.min  =  stopminupg;
          PhoneOff.sec  =  00;
          StopPhoneSec = seconden(PhoneOff);    //recalculate  Phone stoptime to number of seconds since midnight
          EEPROM.write(3,PhoneOff.hour);        //write de-activation time to EEPROM on UNO 
          EEPROM.write(4,PhoneOff.min);         //write de-activation time to EEPROM on UNO
          lcd.setCursor(0,1);
          lcd.print(PhoneOff.hour);
          lcd.print(":");
          if  (PhoneOff.min < 10)
            {
              lcd.print("0");
            }
          lcd.print(PhoneOff.min);
          stophourupg = 0;
          stopminupg  = 0;
          delay(2000);
        }
    }
  //delay(200);
}

TELEPHONECLOCK.ino

arduino

Sketch for the Arduino Uno (a few Dutch words used as variables, sorry)

1/*
2 * Telephone activation clock
3 * This is a clock to activate
4  a telephone for a programmed time.
5 * I use the DS3231 real time clock, this
6  is more accurate than the DS1302 version from Velleman (VMA 301). 
7 * The 16/2
8  LCD screen is the one that came with the Genuino Starter kit.
9 * For the relais
10  I used the Velleman VMA406. For safety reasons i use the normally closed contacts
11  to have
12 * an active telephone een when power supply to the unit fails.
13 *
14  
15 * Erik Luyten 
16 * March 11th, 2019
17 */
18
19
20#include <DS3231.h>
21                     //for clock
22#include <LiquidCrystal.h>              //for
23  LCD display
24#include <EEPROM.h>                     //for EEPROM on UNO to store
25  phone activation time settings during power failure
26DS3231  rtc(SDA, SCL);
27LiquidCrystal
28  lcd(12, 11, 5, 4, 3, 2);
29
30
31
32const int RelayPin = 7;       //activation
33  relay for telephone (normally closed is used so phone is active if unit is without
34  power)
35const int LedTel = 6;         //signal LED for phonerelay
36
37//************Buttons
38  for setclock*****************//
39int P1=8;   // Button SELECT to cycle through
40  possible MENU settings (0 = display actual date/time TO 10 = store changed values)
41int
42  P2=9;   // Button + 
43int P3=10;  // Button -
44
45//************Variables for
46  setclock **************//
47int hourupg;      //upgrade setting for hours
48int
49  minupg;       //upgrade setting for minutes
50int yearupg;      //upgrade setting
51  for year (will be set to actual year in SETUP so we don't have to start from zero)
52int
53  monthupg;     //upgrade setting for month(number)
54int dayupg;       //upgrade
55  setting for day(number)
56int menu = 0;     //cycles from 0 to 10
57int starthourupg
58  = 00;   //starting hour for telephone
59int startminupg = 00;    //starting minutes
60  for telephone
61int stophourupg = 00;    //stop hour for telephone
62int stopminupg
63  = 00;     //stop minutes for telephone
64unsigned long BreakSetClock;  //breakout
65  from menu settings after 10 seconds (each buttonpress resets BreakSetClock time)
66
67//************Time
68  to set phone on and off **********//
69Time PhoneOn;             // Time to activate
70  telephone
71Time PhoneOff;            // Time to deactivate telephone
72Time ClockTijd;
73           // Actual DayTime from Real Time Clock
74
75int DST;  //Daylight Saving
76  Time (read from EEPROM address 0: 0 = winter, 1 = Summer ) (not implemented yet)
77
78unsigned
79  long StartPhoneSec;        // time to activate telephone in seconds from midnight
80unsigned
81  long StopPhoneSec;         // time to deactivate telephone in seconds from midnight
82unsigned
83  long DagSeconden;          // actual seconds since midnight 
84
85Time t;                             //the
86  actual time/date info
87
88  
89void setup() {
90  Serial.begin(9600);
91  pinMode(RelayPin,
92  OUTPUT);
93  pinMode(LedTel, OUTPUT);
94
95  pinMode(P1,INPUT);
96  pinMode(P2,INPUT);
97
98  pinMode(P3,INPUT);
99
100  rtc.begin();
101  lcd.begin(16,2);
102  // ***********
103  Time and Date (no day of week) can now be set with setup buttons (P1= Menu, P2=
104  +, P3= -)
105  //rtc.setDOW(SATURDAY);     // Set Day-of-Week to SUNDAY
106  //rtc.setTime(11,19,30);
107     // Set the time to 12:00:00 (24hr format)
108  //rtc.setDate(23, 2, 2019);
109   // Day, Month, Year
110  //*******
111  //Default activation time for telephone
112  (can be changed with setup buttons)
113  /* //not needed anymore since activation
114  can be set with buttons
115  PhoneOn.hour =  18;
116  PhoneOn.min  =  00;
117  PhoneOn.sec
118  =  00;
119  
120  //State deactivation time for telephone
121  PhoneOff.hour =
122  20;
123  PhoneOff.min  =  00;
124  PhoneOff.sec  =  00;
125  //store default activation
126  and de-activation time to EEPROM in UNO
127  EEPROM.write(1,PhoneOn.hour);
128  EEPROM.write(2,PhoneOn.min);
129
130  EEPROM.write(3,PhoneOff.hour);
131  EEPROM.write(4,PhoneOff.min);
132  */
133
134//Read
135  activation and deactivation time from EEPROM at powerup
136  PhoneOn.hour =  EEPROM.read(1);
137
138  PhoneOn.min  =  EEPROM.read(2);
139  PhoneOff.hour =  EEPROM.read(3);
140  PhoneOff.min
141  =  EEPROM.read(4);
142
143  StartPhoneSec = seconden(PhoneOn);    //recalculate
144  Phone starttime to number of seconds since midnight
145  StopPhoneSec = seconden(PhoneOff);
146    //recalculate Phone stoptime to number of seconds since midnight
147  
148  //
149  ??? no idea why we have to add 5 years but it works like this ????
150  yearupg
151  = t.year + 5;     //yearupg is set to actual year to allow easy setup (we do not
152  have to start from the beginning of (unix) time)
153  
154}
155
156
157void loop()
158  {
159  
160// check if you press the SET button and increase the menu index
161
162  if(digitalRead(P1))
163  {
164   menu=menu+1;
165   BreakSetClock = DagSeconden;
166           //store keypress time to allow breakout after 10 seconds
167  }
168  if
169  (DagSeconden > (BreakSetClock + 10)) //display time and date after 10 seconds without
170  keypress
171    {
172      menu = 0;      
173    }
174// in which subroutine should
175  we go?
176/*
177 * Since clock time settings should be as accurate as possible we
178  will perform them last in the cycle (just before storing the values).
179 * You
180  cannot set seconds. This is always 0. Set minutes 1 higher and press select when
181  the reference clock is at 59 seconds.
182 * This has to be done in the 10 seconds
183  timeout frame so you might have to press the + and - a few times to cancel the breakout
184  routine. 
185 */
186  switch (menu) {
187    case 0:
188      DisplayDateTime();
189      // void DisplayDateTime
190      break;
191    case 1:
192      DisplaySetStartHour();
193  // void DisplaySetStartHour (for telephone activation)
194      break;
195    case
196  2:
197      DisplaySetStartMin();   // void DisplaySetStartMin (for telephone activation)
198
199      break;
200    case 3:
201      DisplaySetStopHour();   // void DisplaySetStopHour
202  (for telephone De-activation)
203      break;
204    case 4:
205      DisplaySetStopMin();
206    // void DisplaySetStopMin (for telephone De-activation)
207      break;
208
209    case 5:
210      DisplaySetYear();       // void DisplaySetYear
211      break;
212
213    case 6:
214      DisplaySetMonth();      // void DisplaySetMonth
215      break;
216
217    case 7:
218      DisplaySetDay();        // void DisplaySetDay
219      break;
220
221    case 8:
222      DisplaySetHour();       // void DisplaySetHour
223      break;
224
225    case 9:
226      DisplaySetMinute();     // void DisplaySetMinute
227      break;
228
229    case 10:
230      StoreSettings();        // void StoreSettings (only for the
231  settings that changed: Time - Date - PhoneOn - PhoneOff)
232      menu=0;
233      break;
234
235  }
236  
237
238  
239  t = rtc.getTime(); // Read current time and date.
240  DagSeconden
241  = seconden(t);    //calculate seconds since midnight
242
243// print control info
244  to Serial Monitor (commented out for better LCD clock response) 
245/*  Serial.print("Uur:
246  ");
247  Serial.print(t.hour);
248  Serial.print(" Min: ");
249  Serial.print(t.min);
250
251  Serial.print(" Sec: ");
252  Serial.print(t.sec);
253  Serial.print("  Menupressed:
254  ");
255  Serial.println(menu);
256
257  Serial.print("Seconden sinds middernacht:
258  ");
259  Serial.print(DagSeconden);
260  Serial.print(" Start telephone: ");
261
262  Serial.print(StartPhoneSec);
263  Serial.print(" Stop telephone: ");
264  Serial.println(StopPhoneSec);
265
266
267
268  Serial.print("Starttijd: ");
269  Serial.print(PhoneOn.hour);
270  Serial.print(":");
271
272  if (PhoneOn.min < 10)
273    {
274    Serial.print("0");
275    }
276  Serial.print(PhoneOn.min);
277
278  Serial.print("  Stoptijd: ");
279  Serial.print(PhoneOff.hour);
280  Serial.print(":");
281
282  if (PhoneOff.min < 10)
283    {
284    Serial.print("0");
285    }
286  Serial.println(PhoneOff.min);
287*/
288
289  
290  if (StartPhoneSec < StopPhoneSec)   //no activation possible at midnight
291  - stoptime is larger than starttime
292    {
293      if ((DagSeconden > StartPhoneSec)
294  && (DagSeconden < StopPhoneSec)) //ClockTime is between start and stop times - activate
295  phone
296        {
297        digitalWrite(RelayPin, LOW);      
298        digitalWrite(LedTel,
299  HIGH);  
300        }
301      else                                // Clocktime
302  is outside start and stoptimes - deactivate phone
303        {
304        digitalWrite(RelayPin,
305  HIGH);
306        digitalWrite(LedTel, LOW);  
307        }
308    }
309  else if
310  (StartPhoneSec > StopPhoneSec)  //we are running over midnight to the next day -
311  phone active at midnight
312    {
313      if (DagSeconden > StartPhoneSec)    //activate
314  phone
315        {
316        digitalWrite(RelayPin, LOW);  
317        digitalWrite(LedTel,
318  HIGH);    
319        }
320      else if (DagSeconden > StopPhoneSec)  //deactivate
321  phone
322        {
323        digitalWrite(RelayPin, HIGH);
324        digitalWrite(LedTel,
325  LOW);   
326        }
327    }
328   
329
330 delay(500);  //wait 0.5 seconds (keypress
331  reaction time is 0.5 second)
332
333}
334
335
336unsigned long seconden(Time dezetijd){
337    //calculate seconds sinds midnight for: ClockTime, PhoneStart and PhoneStop
338  
339  unsigned long result;
340  unsigned long mijnuur = dezetijd.hour;
341  unsigned
342  long uurseconden = 3600;
343  result = (dezetijd.sec + dezetijd.min * 60 + mijnuur
344  * uurseconden);
345  return result;
346}
347
348void DisplayDateTime ()   //show
349  Time, Date, PhoneStartTime and PhoneStopTime on LCD screen
350{
351 lcd.clear();
352
353  lcd.setCursor(1,0);
354 lcd.print(rtc.getTimeStr());
355 lcd.print("  ");
356
357  lcd.print(PhoneOn.hour);
358 lcd.print(":");
359 if (PhoneOn.min < 10)
360  {
361
362    lcd.print("0");
363  }
364 lcd.print(PhoneOn.min);
365 lcd.setCursor(0,1);
366
367  lcd.print(rtc.getDateStr());
368 lcd.print(" ");
369 lcd.print(PhoneOff.hour);
370
371  lcd.print(":");
372 if (PhoneOff.min < 10)
373  {
374    lcd.print("0");
375
376  }
377  lcd.print(PhoneOff.min);
378}
379
380void DisplaySetHour()   //set clock
381  hours
382{
383// time setting
384  lcd.clear();  
385  if(digitalRead(P2)==HIGH)
386
387    {
388      BreakSetClock = DagSeconden;   //store menupress time to allow breakout
389  after 10 seconds
390      if(hourupg==23)
391      {
392        hourupg=0;
393      }
394
395      else
396      {
397        hourupg=hourupg+1;
398      }
399    }
400  if(digitalRead(P3)==HIGH)
401
402    {
403      BreakSetClock = DagSeconden;   //store menupress time to allow breakout
404  after 10 seconds
405      if(hourupg==0)
406      {
407        hourupg=23;
408      }
409
410      else
411      {
412        hourupg=hourupg-1;
413      }
414    }
415  lcd.setCursor(0,0);
416
417  lcd.print("Set hour:");
418  lcd.setCursor(0,1);
419  lcd.print(hourupg,DEC);
420
421  delay(200);
422}
423
424void DisplaySetMinute() //set clock minutes
425{
426//
427  Setting the minutes
428  lcd.clear();
429  if(digitalRead(P2)==HIGH)
430  {
431
432    BreakSetClock = DagSeconden;   //store menupress time to allow breakout after
433  10 seconds
434    if (minupg==59)
435    {
436      minupg=0;
437    }
438    else
439
440    {
441      minupg=minupg+1;
442    }
443  }
444   if(digitalRead(P3)==HIGH)
445
446  {
447    BreakSetClock = DagSeconden;   //store menupress time to allow breakout
448  after 10 seconds
449    if (minupg==0)
450    {
451      minupg=59;
452    }
453
454    else
455    {
456      minupg=minupg-1;
457    }
458  }
459  lcd.setCursor(0,0);
460
461  lcd.print("Set Minutes:");
462  lcd.setCursor(0,1);
463  lcd.print(minupg,DEC);
464
465  delay(200);
466}
467  
468void DisplaySetYear() //set clock year (allready filled
469  with year in clockmemory)
470{
471// setting the year
472  lcd.clear();
473  if(digitalRead(P2)==HIGH)
474
475  {    
476    BreakSetClock = DagSeconden;   //store menupress time to allow breakout
477  after 10 seconds
478    yearupg=yearupg+1;
479  }
480   if(digitalRead(P3)==HIGH)
481
482  {
483    BreakSetClock = DagSeconden;   //store menupress time to allow breakout
484  after 10 seconds
485    yearupg=yearupg-1;
486  }
487  lcd.setCursor(0,0);
488  lcd.print("Set
489  Year:");
490  lcd.setCursor(0,1);
491  lcd.print(yearupg,DEC);
492  delay(200);
493}
494
495void
496  DisplaySetMonth()  //set clock month
497{
498// Setting the month
499  lcd.clear();
500
501  if(digitalRead(P2)==HIGH)
502  {
503    BreakSetClock = DagSeconden;   //store
504  menupress time to allow breakout after 10 seconds
505    if (monthupg==12)
506    {
507
508      monthupg=1;
509    }
510    else
511    {
512      monthupg=monthupg+1;
513
514    }
515  }
516   if(digitalRead(P3)==HIGH)
517  {
518    BreakSetClock = DagSeconden;
519   //store menupress time to allow breakout after 10 seconds
520    if (monthupg==1)
521
522    {
523      monthupg=12;
524    }
525    else
526    {
527      monthupg=monthupg-1;
528
529    }
530  }
531  lcd.setCursor(0,0);
532  lcd.print("Set Month:");
533  lcd.setCursor(0,1);
534
535  lcd.print(monthupg,DEC);
536  delay(200);
537}
538
539void DisplaySetDay()  //set
540  clock day
541{
542// Setting the day
543  lcd.clear();
544  if(digitalRead(P2)==HIGH)
545
546  {
547    BreakSetClock = DagSeconden;   //store menupress time to allow breakout
548  after 10 seconds
549    if (dayupg==31)
550    {
551      dayupg=1;
552    }
553
554    else
555    {
556      dayupg=dayupg+1;
557    }
558  }
559   if(digitalRead(P3)==HIGH)
560
561  {
562    BreakSetClock = DagSeconden;   //store menupress time to allow breakout
563  after 10 seconds
564    if (dayupg==1)
565    {
566      dayupg=31;
567    }
568
569    else
570    {
571      dayupg=dayupg-1;
572    }
573  }
574  lcd.setCursor(0,0);
575
576  lcd.print("Set Day:");
577  lcd.setCursor(0,1);
578  lcd.print(dayupg,DEC);
579
580  delay(200);
581
582}
583
584void DisplaySetStartHour()  //set phone starthour
585{
586//
587  time setting
588  lcd.clear();  
589  lcd.setCursor(0,0);
590  lcd.print("Set starthour:");
591
592  lcd.setCursor(0,1);
593  lcd.print(starthourupg,DEC);
594  if(digitalRead(P2)==HIGH)
595
596    {
597      BreakSetClock = DagSeconden;   //store menupress time to allow breakout
598  after 10 seconds
599      if(starthourupg==23)
600      {
601        starthourupg=0;
602
603      }
604      else
605      {
606        starthourupg=starthourupg+1;
607      }
608
609    }
610  if(digitalRead(P3)==HIGH)
611    {
612      BreakSetClock = DagSeconden;
613   //store menupress time to allow breakout after 10 seconds
614      if(starthourupg==0)
615
616      {
617        starthourupg=23;
618      }
619      else
620      {
621        starthourupg=starthourupg-1;
622
623      }
624    }
625  delay(200);
626}
627
628void DisplaySetStartMin() //set phonestartminutes
629{
630//
631  time setting
632  lcd.clear();  
633  lcd.setCursor(0,0);
634  lcd.print("Set startminutes:");
635
636  lcd.setCursor(0,1);
637  lcd.print(startminupg,DEC);
638  if(digitalRead(P2)==HIGH)
639
640    {
641      BreakSetClock = DagSeconden;   //store menupress time to allow breakout
642  after 10 seconds
643      if(startminupg==59)
644      {
645        startminupg=0;
646
647      }
648      else
649      {
650        startminupg=startminupg+1;
651      }
652
653    }
654  if(digitalRead(P3)==HIGH)
655    {
656      BreakSetClock = DagSeconden;
657   //store menupress time to allow breakout after 10 seconds
658      if(startminupg==0)
659
660      {
661        startminupg=59;
662      }
663      else
664      {
665        startminupg=startminupg-1;
666
667      }
668    }
669  delay(200);
670}
671
672void DisplaySetStopHour()   //set
673  phonestophour
674{
675// time setting
676  lcd.clear();  
677  lcd.setCursor(0,0);
678
679  lcd.print("Set stophour:");
680  lcd.setCursor(0,1);
681  lcd.print(stophourupg,DEC);
682
683  if(digitalRead(P2)==HIGH)
684    {
685      BreakSetClock = DagSeconden;   //store
686  menupress time to allow breakout after 10 seconds
687      if(stophourupg==23)
688
689      {
690        stophourupg=0;
691      }
692      else
693      {
694        stophourupg=stophourupg+1;
695
696      }
697    }
698  if(digitalRead(P3)==HIGH)
699    {
700      BreakSetClock
701  = DagSeconden;   //store menupress time to allow breakout after 10 seconds
702      if(stophourupg==0)
703
704      {
705        stophourupg=23;
706      }
707      else
708      {
709        stophourupg=stophourupg-1;
710
711      }
712    }
713  delay(200);
714}
715
716void DisplaySetStopMin()  //set phonestopminutes
717{
718//
719  time setting
720  lcd.clear();  
721  lcd.setCursor(0,0);
722  lcd.print("Set stopminutes:");
723
724  lcd.setCursor(0,1);
725  lcd.print(stopminupg,DEC);
726  if(digitalRead(P2)==HIGH)
727
728    {
729      BreakSetClock = DagSeconden;   //store menupress time to allow breakout
730  after 10 seconds
731      if(stopminupg==59)
732      {
733        stopminupg=0;
734
735      }
736      else
737      {
738        stopminupg=stopminupg+1;
739      }
740
741    }
742  if(digitalRead(P3)==HIGH)
743    {
744      BreakSetClock = DagSeconden;
745   //store menupress time to allow breakout after 10 seconds
746      if(stopminupg==0)
747
748      {
749        stopminupg=59;
750      }
751      else
752      {
753        stopminupg=stopminupg-1;
754
755      }
756    }
757  delay(200);
758}
759
760void StoreSettings()    //store the
761  results depending on values in variables
762{
763// Saving Time, Date, StopTime
764  and StartTime only if they are changed
765// Disabled message to LCD to allow more
766  accurate time setting 
767
768  lcd.clear();
769  lcd.setCursor(0,0);
770  if ((hourupg
771  == 0) && (minupg == 0))    //do not set time if both hours and minutes are zero
772  (cannot set clock to midnight time)
773    {
774      lcd.print("TIME not saved
775  !");  
776      delay(2000);
777    }
778  else
779    {
780      lcd.print("Saving
781  TIME");
782      rtc.setTime(hourupg,minupg,00);     // Set the time (24hr format)
783
784      hourupg = 0;
785      minupg = 0;
786      delay(2000); 
787    }
788  lcd.clear();
789
790  lcd.setCursor(0,0);
791  if ((dayupg == 0) || (monthupg == 0) || (yearupg == 0))
792  //do not set date if any of these values is zero
793    {
794      lcd.print("DATE
795  not saved !");
796      delay(2000);
797    }
798  else 
799    {
800      lcd.print("Saving
801  DATE");
802      rtc.setDate(dayupg, monthupg, yearupg);   // Day, Month, Year
803
804      dayupg = 0;
805      monthupg = 0;
806      delay(2000);
807    }
808  
809
810    
811//First Check if start and stoptime are not the same (should be at least
812  one minute difference)  
813  lcd.clear();
814  lcd.setCursor(0,0);
815  if ((starthourupg
816  == stophourupg) && (startminupg == stopminupg) && ((starthourupg + startminupg +
817  stophourupg + stopminupg) != 0))
818    {
819      lcd.print("START & STOPTIME");
820
821      lcd.setCursor(0,1);
822      lcd.print("Cant be the same");
823      delay(2000);
824
825    }
826  else 
827    {  
828    //check to see if starttime should be saved
829
830      if ((starthourupg == 0) && (startminupg == 0))  //don't set starttime if both
831  hours and minutes are zero(cannot set starttime to midnight)
832        {
833          lcd.print("STARTTIME
834  ");  
835          lcd.setCursor(0,1);  
836          lcd.print("not saved !");
837
838          delay(2000);
839        }
840      else
841        {
842          lcd.print("Saving
843  STARTTIME");
844          PhoneOn.hour =  starthourupg;
845          PhoneOn.min
846  =  startminupg;
847          PhoneOn.sec  =  00;
848          StartPhoneSec =
849  seconden(PhoneOn);    //recalculate Phone starttime to number of seconds since midnight
850
851          EEPROM.write(1,PhoneOn.hour);         //write activation time to EEPROM
852  on UNO 
853          EEPROM.write(2,PhoneOn.min);          //write activation time
854  to EEPROM on UNO 
855          lcd.setCursor(0,1);
856          lcd.print(PhoneOn.hour);
857
858          lcd.print(":");
859          if (PhoneOn.min < 10)
860            {
861
862              lcd.print("0");
863            }
864          lcd.print(PhoneOn.min);
865
866          starthourupg = 0;
867          startminupg = 0;
868          delay(2000);
869  
870        }
871      
872      lcd.clear();
873      lcd.setCursor(0,0);
874
875    //check to aee if stoptime should be changed  
876      if ((stophourupg ==
877  0) && (stopminupg == 0))  //don't set stoptime if both hours and minutes are zero(cannot
878  set stoptime to midnight)
879        {
880          lcd.print("STOPTIME ");
881
882          lcd.setCursor(0,1);  
883          lcd.print("not saved !");
884          delay(2000);
885
886        }
887      else
888        {
889          lcd.print("Saving STOPTIME");
890
891          PhoneOff.hour =  stophourupg;
892          PhoneOff.min  =  stopminupg;
893
894          PhoneOff.sec  =  00;
895          StopPhoneSec = seconden(PhoneOff);    //recalculate
896  Phone stoptime to number of seconds since midnight
897          EEPROM.write(3,PhoneOff.hour);
898        //write de-activation time to EEPROM on UNO 
899          EEPROM.write(4,PhoneOff.min);
900         //write de-activation time to EEPROM on UNO
901          lcd.setCursor(0,1);
902
903          lcd.print(PhoneOff.hour);
904          lcd.print(":");
905          if
906  (PhoneOff.min < 10)
907            {
908              lcd.print("0");
909            }
910
911          lcd.print(PhoneOff.min);
912          stophourupg = 0;
913          stopminupg
914  = 0;
915          delay(2000);
916        }
917    }
918  //delay(200);
919}
920

/*
 * Telephone activation clock
 * This is a clock to activate
  a telephone for a programmed time.
 * I use the DS3231 real time clock, this
  is more accurate than the DS1302 version from Velleman (VMA 301). 
 * The 16/2
  LCD screen is the one that came with the Genuino Starter kit.
 * For the relais
  I used the Velleman VMA406. For safety reasons i use the normally closed contacts
  to have
 * an active telephone een when power supply to the unit fails.
 *
  
 * Erik Luyten 
 * March 11th, 2019
 */


#include <DS3231.h>
                     //for clock
#include <LiquidCrystal.h>              //for
  LCD display
#include <EEPROM.h>                     //for EEPROM on UNO to store
  phone activation time settings during power failure
DS3231  rtc(SDA, SCL);
LiquidCrystal
  lcd(12, 11, 5, 4, 3, 2);



const int RelayPin = 7;       //activation
  relay for telephone (normally closed is used so phone is active if unit is without
  power)
const int LedTel = 6;         //signal LED for phonerelay

//************Buttons
  for setclock*****************//
int P1=8;   // Button SELECT to cycle through
  possible MENU settings (0 = display actual date/time TO 10 = store changed values)
int
  P2=9;   // Button + 
int P3=10;  // Button -

//************Variables for
  setclock **************//
int hourupg;      //upgrade setting for hours
int
  minupg;       //upgrade setting for minutes
int yearupg;      //upgrade setting
  for year (will be set to actual year in SETUP so we don't have to start from zero)
int
  monthupg;     //upgrade setting for month(number)
int dayupg;       //upgrade
  setting for day(number)
int menu = 0;     //cycles from 0 to 10
int starthourupg
  = 00;   //starting hour for telephone
int startminupg = 00;    //starting minutes
  for telephone
int stophourupg = 00;    //stop hour for telephone
int stopminupg
  = 00;     //stop minutes for telephone
unsigned long BreakSetClock;  //breakout
  from menu settings after 10 seconds (each buttonpress resets BreakSetClock time)

//************Time
  to set phone on and off **********//
Time PhoneOn;             // Time to activate
  telephone
Time PhoneOff;            // Time to deactivate telephone
Time ClockTijd;
           // Actual DayTime from Real Time Clock

int DST;  //Daylight Saving
  Time (read from EEPROM address 0: 0 = winter, 1 = Summer ) (not implemented yet)

unsigned
  long StartPhoneSec;        // time to activate telephone in seconds from midnight
unsigned
  long StopPhoneSec;         // time to deactivate telephone in seconds from midnight
unsigned
  long DagSeconden;          // actual seconds since midnight 

Time t;                             //the
  actual time/date info

  
void setup() {
  Serial.begin(9600);
  pinMode(RelayPin,
  OUTPUT);
  pinMode(LedTel, OUTPUT);

  pinMode(P1,INPUT);
  pinMode(P2,INPUT);

  pinMode(P3,INPUT);

  rtc.begin();
  lcd.begin(16,2);
  // ***********
  Time and Date (no day of week) can now be set with setup buttons (P1= Menu, P2=
  +, P3= -)
  //rtc.setDOW(SATURDAY);     // Set Day-of-Week to SUNDAY
  //rtc.setTime(11,19,30);
     // Set the time to 12:00:00 (24hr format)
  //rtc.setDate(23, 2, 2019);
   // Day, Month, Year
  //*******
  //Default activation time for telephone
  (can be changed with setup buttons)
  /* //not needed anymore since activation
  can be set with buttons
  PhoneOn.hour =  18;
  PhoneOn.min  =  00;
  PhoneOn.sec
  =  00;
  
  //State deactivation time for telephone
  PhoneOff.hour =
  20;
  PhoneOff.min  =  00;
  PhoneOff.sec  =  00;
  //store default activation
  and de-activation time to EEPROM in UNO
  EEPROM.write(1,PhoneOn.hour);
  EEPROM.write(2,PhoneOn.min);

  EEPROM.write(3,PhoneOff.hour);
  EEPROM.write(4,PhoneOff.min);
  */

//Read
  activation and deactivation time from EEPROM at powerup
  PhoneOn.hour =  EEPROM.read(1);

  PhoneOn.min  =  EEPROM.read(2);
  PhoneOff.hour =  EEPROM.read(3);
  PhoneOff.min
  =  EEPROM.read(4);

  StartPhoneSec = seconden(PhoneOn);    //recalculate
  Phone starttime to number of seconds since midnight
  StopPhoneSec = seconden(PhoneOff);
    //recalculate Phone stoptime to number of seconds since midnight
  
  //
  ??? no idea why we have to add 5 years but it works like this ????
  yearupg
  = t.year + 5;     //yearupg is set to actual year to allow easy setup (we do not
  have to start from the beginning of (unix) time)
  
}


void loop()
  {
  
// check if you press the SET button and increase the menu index

  if(digitalRead(P1))
  {
   menu=menu+1;
   BreakSetClock = DagSeconden;
           //store keypress time to allow breakout after 10 seconds
  }
  if
  (DagSeconden > (BreakSetClock + 10)) //display time and date after 10 seconds without
  keypress
    {
      menu = 0;      
    }
// in which subroutine should
  we go?
/*
 * Since clock time settings should be as accurate as possible we
  will perform them last in the cycle (just before storing the values).
 * You
  cannot set seconds. This is always 0. Set minutes 1 higher and press select when
  the reference clock is at 59 seconds.
 * This has to be done in the 10 seconds
  timeout frame so you might have to press the + and - a few times to cancel the breakout
  routine. 
 */
  switch (menu) {
    case 0:
      DisplayDateTime();
      // void DisplayDateTime
      break;
    case 1:
      DisplaySetStartHour();
  // void DisplaySetStartHour (for telephone activation)
      break;
    case
  2:
      DisplaySetStartMin();   // void DisplaySetStartMin (for telephone activation)

      break;
    case 3:
      DisplaySetStopHour();   // void DisplaySetStopHour
  (for telephone De-activation)
      break;
    case 4:
      DisplaySetStopMin();
    // void DisplaySetStopMin (for telephone De-activation)
      break;

    case 5:
      DisplaySetYear();       // void DisplaySetYear
      break;

    case 6:
      DisplaySetMonth();      // void DisplaySetMonth
      break;

    case 7:
      DisplaySetDay();        // void DisplaySetDay
      break;

    case 8:
      DisplaySetHour();       // void DisplaySetHour
      break;

    case 9:
      DisplaySetMinute();     // void DisplaySetMinute
      break;

    case 10:
      StoreSettings();        // void StoreSettings (only for the
  settings that changed: Time - Date - PhoneOn - PhoneOff)
      menu=0;
      break;

  }
  

  
  t = rtc.getTime(); // Read current time and date.
  DagSeconden
  = seconden(t);    //calculate seconds since midnight

// print control info
  to Serial Monitor (commented out for better LCD clock response) 
/*  Serial.print("Uur:
  ");
  Serial.print(t.hour);
  Serial.print(" Min: ");
  Serial.print(t.min);

  Serial.print(" Sec: ");
  Serial.print(t.sec);
  Serial.print("  Menupressed:
  ");
  Serial.println(menu);

  Serial.print("Seconden sinds middernacht:
  ");
  Serial.print(DagSeconden);
  Serial.print(" Start telephone: ");

  Serial.print(StartPhoneSec);
  Serial.print(" Stop telephone: ");
  Serial.println(StopPhoneSec);



  Serial.print("Starttijd: ");
  Serial.print(PhoneOn.hour);
  Serial.print(":");

  if (PhoneOn.min < 10)
    {
    Serial.print("0");
    }
  Serial.print(PhoneOn.min);

  Serial.print("  Stoptijd: ");
  Serial.print(PhoneOff.hour);
  Serial.print(":");

  if (PhoneOff.min < 10)
    {
    Serial.print("0");
    }
  Serial.println(PhoneOff.min);
*/

  
  if (StartPhoneSec < StopPhoneSec)   //no activation possible at midnight
  - stoptime is larger than starttime
    {
      if ((DagSeconden > StartPhoneSec)
  && (DagSeconden < StopPhoneSec)) //ClockTime is between start and stop times - activate
  phone
        {
        digitalWrite(RelayPin, LOW);      
        digitalWrite(LedTel,
  HIGH);  
        }
      else                                // Clocktime
  is outside start and stoptimes - deactivate phone
        {
        digitalWrite(RelayPin,
  HIGH);
        digitalWrite(LedTel, LOW);  
        }
    }
  else if
  (StartPhoneSec > StopPhoneSec)  //we are running over midnight to the next day -
  phone active at midnight
    {
      if (DagSeconden > StartPhoneSec)    //activate
  phone
        {
        digitalWrite(RelayPin, LOW);  
        digitalWrite(LedTel,
  HIGH);    
        }
      else if (DagSeconden > StopPhoneSec)  //deactivate
  phone
        {
        digitalWrite(RelayPin, HIGH);
        digitalWrite(LedTel,
  LOW);   
        }
    }
   

 delay(500);  //wait 0.5 seconds (keypress
  reaction time is 0.5 second)

}


unsigned long seconden(Time dezetijd){
    //calculate seconds sinds midnight for: ClockTime, PhoneStart and PhoneStop
  
  unsigned long result;
  unsigned long mijnuur = dezetijd.hour;
  unsigned
  long uurseconden = 3600;
  result = (dezetijd.sec + dezetijd.min * 60 + mijnuur
  * uurseconden);
  return result;
}

void DisplayDateTime ()   //show
  Time, Date, PhoneStartTime and PhoneStopTime on LCD screen
{
 lcd.clear();

  lcd.setCursor(1,0);
 lcd.print(rtc.getTimeStr());
 lcd.print("  ");

  lcd.print(PhoneOn.hour);
 lcd.print(":");
 if (PhoneOn.min < 10)
  {

    lcd.print("0");
  }
 lcd.print(PhoneOn.min);
 lcd.setCursor(0,1);

  lcd.print(rtc.getDateStr());
 lcd.print(" ");
 lcd.print(PhoneOff.hour);

  lcd.print(":");
 if (PhoneOff.min < 10)
  {
    lcd.print("0");

  }
  lcd.print(PhoneOff.min);
}

void DisplaySetHour()   //set clock
  hours
{
// time setting
  lcd.clear();  
  if(digitalRead(P2)==HIGH)

    {
      BreakSetClock = DagSeconden;   //store menupress time to allow breakout
  after 10 seconds
      if(hourupg==23)
      {
        hourupg=0;
      }

      else
      {
        hourupg=hourupg+1;
      }
    }
  if(digitalRead(P3)==HIGH)

    {
      BreakSetClock = DagSeconden;   //store menupress time to allow breakout
  after 10 seconds
      if(hourupg==0)
      {
        hourupg=23;
      }

      else
      {
        hourupg=hourupg-1;
      }
    }
  lcd.setCursor(0,0);

  lcd.print("Set hour:");
  lcd.setCursor(0,1);
  lcd.print(hourupg,DEC);

  delay(200);
}

void DisplaySetMinute() //set clock minutes
{
//
  Setting the minutes
  lcd.clear();
  if(digitalRead(P2)==HIGH)
  {

    BreakSetClock = DagSeconden;   //store menupress time to allow breakout after
  10 seconds
    if (minupg==59)
    {
      minupg=0;
    }
    else

    {
      minupg=minupg+1;
    }
  }
   if(digitalRead(P3)==HIGH)

  {
    BreakSetClock = DagSeconden;   //store menupress time to allow breakout
  after 10 seconds
    if (minupg==0)
    {
      minupg=59;
    }

    else
    {
      minupg=minupg-1;
    }
  }
  lcd.setCursor(0,0);

  lcd.print("Set Minutes:");
  lcd.setCursor(0,1);
  lcd.print(minupg,DEC);

  delay(200);
}
  
void DisplaySetYear() //set clock year (allready filled
  with year in clockmemory)
{
// setting the year
  lcd.clear();
  if(digitalRead(P2)==HIGH)

  {    
    BreakSetClock = DagSeconden;   //store menupress time to allow breakout
  after 10 seconds
    yearupg=yearupg+1;
  }
   if(digitalRead(P3)==HIGH)

  {
    BreakSetClock = DagSeconden;   //store menupress time to allow breakout
  after 10 seconds
    yearupg=yearupg-1;
  }
  lcd.setCursor(0,0);
  lcd.print("Set
  Year:");
  lcd.setCursor(0,1);
  lcd.print(yearupg,DEC);
  delay(200);
}

void
  DisplaySetMonth()  //set clock month
{
// Setting the month
  lcd.clear();

  if(digitalRead(P2)==HIGH)
  {
    BreakSetClock = DagSeconden;   //store
  menupress time to allow breakout after 10 seconds
    if (monthupg==12)
    {

      monthupg=1;
    }
    else
    {
      monthupg=monthupg+1;

    }
  }
   if(digitalRead(P3)==HIGH)
  {
    BreakSetClock = DagSeconden;
   //store menupress time to allow breakout after 10 seconds
    if (monthupg==1)

    {
      monthupg=12;
    }
    else
    {
      monthupg=monthupg-1;

    }
  }
  lcd.setCursor(0,0);
  lcd.print("Set Month:");
  lcd.setCursor(0,1);

  lcd.print(monthupg,DEC);
  delay(200);
}

void DisplaySetDay()  //set
  clock day
{
// Setting the day
  lcd.clear();
  if(digitalRead(P2)==HIGH)

  {
    BreakSetClock = DagSeconden;   //store menupress time to allow breakout
  after 10 seconds
    if (dayupg==31)
    {
      dayupg=1;
    }

    else
    {
      dayupg=dayupg+1;
    }
  }
   if(digitalRead(P3)==HIGH)

  {
    BreakSetClock = DagSeconden;   //store menupress time to allow breakout
  after 10 seconds
    if (dayupg==1)
    {
      dayupg=31;
    }

    else
    {
      dayupg=dayupg-1;
    }
  }
  lcd.setCursor(0,0);

  lcd.print("Set Day:");
  lcd.setCursor(0,1);
  lcd.print(dayupg,DEC);

  delay(200);

}

void DisplaySetStartHour()  //set phone starthour
{
//
  time setting
  lcd.clear();  
  lcd.setCursor(0,0);
  lcd.print("Set starthour:");

  lcd.setCursor(0,1);
  lcd.print(starthourupg,DEC);
  if(digitalRead(P2)==HIGH)

    {
      BreakSetClock = DagSeconden;   //store menupress time to allow breakout
  after 10 seconds
      if(starthourupg==23)
      {
        starthourupg=0;

      }
      else
      {
        starthourupg=starthourupg+1;
      }

    }
  if(digitalRead(P3)==HIGH)
    {
      BreakSetClock = DagSeconden;
   //store menupress time to allow breakout after 10 seconds
      if(starthourupg==0)

      {
        starthourupg=23;
      }
      else
      {
        starthourupg=starthourupg-1;

      }
    }
  delay(200);
}

void DisplaySetStartMin() //set phonestartminutes
{
//
  time setting
  lcd.clear();  
  lcd.setCursor(0,0);
  lcd.print("Set startminutes:");

  lcd.setCursor(0,1);
  lcd.print(startminupg,DEC);
  if(digitalRead(P2)==HIGH)

    {
      BreakSetClock = DagSeconden;   //store menupress time to allow breakout
  after 10 seconds
      if(startminupg==59)
      {
        startminupg=0;

      }
      else
      {
        startminupg=startminupg+1;
      }

    }
  if(digitalRead(P3)==HIGH)
    {
      BreakSetClock = DagSeconden;
   //store menupress time to allow breakout after 10 seconds
      if(startminupg==0)

      {
        startminupg=59;
      }
      else
      {
        startminupg=startminupg-1;

      }
    }
  delay(200);
}

void DisplaySetStopHour()   //set
  phonestophour
{
// time setting
  lcd.clear();  
  lcd.setCursor(0,0);

  lcd.print("Set stophour:");
  lcd.setCursor(0,1);
  lcd.print(stophourupg,DEC);

  if(digitalRead(P2)==HIGH)
    {
      BreakSetClock = DagSeconden;   //store
  menupress time to allow breakout after 10 seconds
      if(stophourupg==23)

      {
        stophourupg=0;
      }
      else
      {
        stophourupg=stophourupg+1;

      }
    }
  if(digitalRead(P3)==HIGH)
    {
      BreakSetClock
  = DagSeconden;   //store menupress time to allow breakout after 10 seconds
      if(stophourupg==0)

      {
        stophourupg=23;
      }
      else
      {
        stophourupg=stophourupg-1;

      }
    }
  delay(200);
}

void DisplaySetStopMin()  //set phonestopminutes
{
//
  time setting
  lcd.clear();  
  lcd.setCursor(0,0);
  lcd.print("Set stopminutes:");

  lcd.setCursor(0,1);
  lcd.print(stopminupg,DEC);
  if(digitalRead(P2)==HIGH)

    {
      BreakSetClock = DagSeconden;   //store menupress time to allow breakout
  after 10 seconds
      if(stopminupg==59)
      {
        stopminupg=0;

      }
      else
      {
        stopminupg=stopminupg+1;
      }

    }
  if(digitalRead(P3)==HIGH)
    {
      BreakSetClock = DagSeconden;
   //store menupress time to allow breakout after 10 seconds
      if(stopminupg==0)

      {
        stopminupg=59;
      }
      else
      {
        stopminupg=stopminupg-1;

      }
    }
  delay(200);
}

void StoreSettings()    //store the
  results depending on values in variables
{
// Saving Time, Date, StopTime
  and StartTime only if they are changed
// Disabled message to LCD to allow more
  accurate time setting 

  lcd.clear();
  lcd.setCursor(0,0);
  if ((hourupg
  == 0) && (minupg == 0))    //do not set time if both hours and minutes are zero
  (cannot set clock to midnight time)
    {
      lcd.print("TIME not saved
  !");  
      delay(2000);
    }
  else
    {
      lcd.print("Saving
  TIME");
      rtc.setTime(hourupg,minupg,00);     // Set the time (24hr format)

      hourupg = 0;
      minupg = 0;
      delay(2000); 
    }
  lcd.clear();

  lcd.setCursor(0,0);
  if ((dayupg == 0) || (monthupg == 0) || (yearupg == 0))
  //do not set date if any of these values is zero
    {
      lcd.print("DATE
  not saved !");
      delay(2000);
    }
  else 
    {
      lcd.print("Saving
  DATE");
      rtc.setDate(dayupg, monthupg, yearupg);   // Day, Month, Year

      dayupg = 0;
      monthupg = 0;
      delay(2000);
    }
  

    
//First Check if start and stoptime are not the same (should be at least
  one minute difference)  
  lcd.clear();
  lcd.setCursor(0,0);
  if ((starthourupg
  == stophourupg) && (startminupg == stopminupg) && ((starthourupg + startminupg +
  stophourupg + stopminupg) != 0))
    {
      lcd.print("START & STOPTIME");

      lcd.setCursor(0,1);
      lcd.print("Cant be the same");
      delay(2000);

    }
  else 
    {  
    //check to see if starttime should be saved

      if ((starthourupg == 0) && (startminupg == 0))  //don't set starttime if both
  hours and minutes are zero(cannot set starttime to midnight)
        {
          lcd.print("STARTTIME
  ");  
          lcd.setCursor(0,1);  
          lcd.print("not saved !");

          delay(2000);
        }
      else
        {
          lcd.print("Saving
  STARTTIME");
          PhoneOn.hour =  starthourupg;
          PhoneOn.min
  =  startminupg;
          PhoneOn.sec  =  00;
          StartPhoneSec =
  seconden(PhoneOn);    //recalculate Phone starttime to number of seconds since midnight

          EEPROM.write(1,PhoneOn.hour);         //write activation time to EEPROM
  on UNO 
          EEPROM.write(2,PhoneOn.min);          //write activation time
  to EEPROM on UNO 
          lcd.setCursor(0,1);
          lcd.print(PhoneOn.hour);

          lcd.print(":");
          if (PhoneOn.min < 10)
            {

              lcd.print("0");
            }
          lcd.print(PhoneOn.min);

          starthourupg = 0;
          startminupg = 0;
          delay(2000);
  
        }
      
      lcd.clear();
      lcd.setCursor(0,0);

    //check to aee if stoptime should be changed  
      if ((stophourupg ==
  0) && (stopminupg == 0))  //don't set stoptime if both hours and minutes are zero(cannot
  set stoptime to midnight)
        {
          lcd.print("STOPTIME ");

          lcd.setCursor(0,1);  
          lcd.print("not saved !");
          delay(2000);

        }
      else
        {
          lcd.print("Saving STOPTIME");

          PhoneOff.hour =  stophourupg;
          PhoneOff.min  =  stopminupg;

          PhoneOff.sec  =  00;
          StopPhoneSec = seconden(PhoneOff);    //recalculate
  Phone stoptime to number of seconds since midnight
          EEPROM.write(3,PhoneOff.hour);
        //write de-activation time to EEPROM on UNO 
          EEPROM.write(4,PhoneOff.min);
         //write de-activation time to EEPROM on UNO
          lcd.setCursor(0,1);

          lcd.print(PhoneOff.hour);
          lcd.print(":");
          if
  (PhoneOff.min < 10)
            {
              lcd.print("0");
            }

          lcd.print(PhoneOff.min);
          stophourupg = 0;
          stopminupg
  = 0;
          delay(2000);
        }
    }
  //delay(200);
}

Downloadable files

schematicTelephone activation clock

wiring diagram

schematicTelephone activation clock

wiring diagram

schematicTelephone activation clock

Documentation

PhoneClock enclosure

MDF 4mm lasercut box with additional MDF pieces for component parts

PhoneClock enclosure

Comments

Only logged in users can leave comments

eluyten

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content