Digital Clock using Arduino Nano

Digital Clock with Hour/ Minute/Second Display, Alarm and Hour chime using Arduino Nano and RTC DS3231

Aug 6, 2021

•

37138 views

•

5 respects

home automation

clocks

Components and supplies

3mm LED

DS3231

Small Push button Switch

Resistor 10K

Resistor 220ohm

1 inch Common Anode 7 segment Display

SPDT SWITCH

General purpose PCB 20Cm X 10 Cm

Arduino Nano V3

1/2 inch Common Anode 7 Segment Display

Project description

Code

Arduino sketch for Digital Clock

arduino

Arduino Sketch for Digital Clock

1int aset;
2int dtt2;
3int newdtt1;
4int digit1 = 11; 
5int digit2  = 10; 
6int digit3 = 9; 
7int digit4 = 6; 
8int digit5 = A3; 
9int digit6  = A2; 
10int Dot = 1;
11int Hrchime = 0;
12int segA = 2;
13int segB = 3;    
14int  segC = 4; 
15int segD = 5; 
16int segE = 12; 
17int segF = 7; 
18int segG =  8; 
19int SW0   =A0;
20int SW1   =A1;
21int almout =13;
22int aset1 = 3; //  set value as 3  for first time retrival of alarm set 
23int alringt =1; // required  alarm ring time in minute
24int hrchringt = 6;// required time for hour chime in  seconds
25static unsigned int altim;
26//#include <Wire.h>
27#include "RTClib.h"
28#include  <EEPROM.h>
29#define EEADDR 166 // Start location to write EEPROM data.
30RTC_DS3231  RTC;
31// =====================setup()=================================
32void  setup() {
33//Serial.begin(9600);
34   RTC.begin();
35  DateTime now = RTC.now();
36//RTC.adjust(DateTime(__DATE__,  __TIME__));// for setting clock   remove // from this line  and upload sketch
37  //after setting clock again put // on the line and upload once more 
38
39  pinMode(segA,  OUTPUT);
40  pinMode(segB, OUTPUT);
41  pinMode(segC, OUTPUT);
42  pinMode(segD,  OUTPUT);
43  pinMode(segE, OUTPUT);
44  pinMode(segF, OUTPUT);
45  pinMode(segG,  OUTPUT);
46  pinMode(Dot, OUTPUT);
47  pinMode(Hrchime, OUTPUT);
48  pinMode(digit1,  OUTPUT);
49  pinMode(digit2, OUTPUT);
50  pinMode(digit3, OUTPUT);
51  pinMode(digit4,  OUTPUT);
52  pinMode(digit5, OUTPUT);
53  pinMode(digit6, OUTPUT);
54  pinMode(almout,  OUTPUT);
55  pinMode(SW0, INPUT);  // Alarm  setting SPST  switch
56  pinMode(SW1,  INPUT);  //Alarm setting  PUSH switch
57  digitalWrite(SW0, LOW);
58  digitalWrite(SW1,  LOW);
59  digitalWrite(almout, LOW);
60  digitalWrite(Hrchime, LOW);
61
62
63//  retrieving alarm set time from flash on first time power_on
64
65int EEAddr  = EEADDR;
66if (aset1 == 3  ) {
67  EEPROM.get(EEAddr , altim); EEAddr += sizeof(altim);
68    newdtt1 = altim;
69    dtt2 = altim; 
70    aset1 = 6;
71    aset  = 7;
72  //Serial.print ("Flash first Read  "); 
73  //Serial.print (dtt2);
74 }
75  else{}
76
77//  end of alrm set time retrieving from flash memory
78 
79}//==================end  of setup ()====================================
80
81
82
83//********************  STARTING MAIN PROGRAM*****************************
84
85void loop() {
86  //digitalWrite(segDP,  HIGH);
87
88  int mt;
89  int dt;
90  int dtt;
91  int almsethr;
92  int almsetmn;
93  int chm;
94
95while ( digitalRead(SW0) == HIGH  && digitalRead(SW1) == LOW ){
96  
97    dt = almsethr;
98    mt = almsetmn;
99   
100    for (int i = 20 ; i >  0  ; i--) {
101      Light_HR_MIN(dtt2);
102     Light_HR_MIN(dtt2);
103    }
104    }    //end of while loop
105
106 
107 while ( digitalRead(SW0) == HIGH  && digitalRead(SW1)  == HIGH){
108    digitalWrite(Dot, HIGH);
109    digitalWrite(digit5, HIGH);
110    digitalWrite(digit6, HIGH);
111    
112    dtt2++;
113    int a;
114    int  b;
115    a = dtt2 / 100;
116    b = dtt2 % 100;
117
118    if (b >= 60)
119    {  b = 0;
120      a++;
121    }
122    else {}
123    if (a >= 24) a = 0;
124    else  {}
125    dtt2 =  a * 100 + b;
126
127    for (int i = 20 ; i > 0  ; i--) {
128     Light_HR_MIN(dtt2);
129     Light_HR_MIN(dtt2);
130      
131    }
132    almsethr  = dt;
133    almsetmn = mt;
134    aset =1;
135  
136    }        //end of while  loop
137
138
139 while ( digitalRead(SW0) == LOW ){
140   DateTime now = RTC.now();
141   int rr= (now.hour());
142   int gt=(now.minute());
143   int timp5 = rr*100 +  gt;
144  
145//----------- Writing Alarm set_time to Flash memory------
146 
147  
148  if (aset == 1){
149 ALARMSTORE(dtt2 ,1 , newdtt1);
150aset = 6;
151}
152else{}
153
154//---------------------------------Alarm  ringing------
155
156   if (timp5 == dtt2   ) {
157           digitalWrite(almout,  HIGH);
158        }
159   else{}
160 if (timp5 == dtt2+alringt) {
161   digitalWrite(almout,  LOW);
162}
163  else{}
164  
165//-----------------------------Hour chime setting----------=----
166  
167if ( timp5 % 100 == 00   &&  now.second() <= hrchringt )    
168       { digitalWrite(Hrchime,  HIGH);
169       }
170    else{       
171   digitalWrite(Hrchime , LOW); }
172
173  
174//------------STARTS LINES FOR DISPLAYING CURRENT TIME-----------
175   
176  if ( digitalRead(SW0) == LOW  ) {
177
178 DateTime now = RTC.now();
179  int tim  = (now.hour());
180  if (tim >  12) {
181   tim = tim - 12;
182    }
183  else;
184  if (tim ==  0) {
185      tim = 12; }
186    else;
187    int timp = (tim * 100  + now.minute());
188    int timp1 = now.second();
189   
190// For Digits display
191    for (int i = 8 ; i > 0  ; i--) {
192       Light_HR_MIN(timp);
193       displaysecond(timp1);  }
194   }
195  else {}
196
197}   //end of WHILE loop 
198
199 } // ==================END  OF MAIN PROGRAM======================
200
201
202// ***************SUB PROGRAMS************************************
203
204//======================for  display of Hour and Minute============
205void Light_HR_MIN(int toDisplay) {
206#define  BRIGHTNESS  1000
207#define DIGIT_ON  HIGH
208#define DIGIT_OFF  LOW
209int hrr  =toDisplay/100;
210
211  if (digitalRead(SW1) == HIGH)
212  { digitalWrite(digit5,  LOW);
213    digitalWrite(digit6, LOW);
214  }
215  else{}
216
217  for (int digit  = 4 ; digit > 0 ; digit--) {
218        switch (digit) {
219     
220      case  1:
221      if (hrr < 10  && hrr != 0 )
222         {digitalWrite(digit1, DIGIT_OFF);
223         }
224         else{
225         digitalWrite(digit1, DIGIT_ON);
226         }
227         break;
228      case 2:
229         digitalWrite(digit2, DIGIT_ON);
230         break;
231      case 3:
232        digitalWrite(digit3, DIGIT_ON);
233         break;
234      case 4:
235        digitalWrite(digit4, DIGIT_ON);
236        break;
237    }
238    
239    ShowNumber(toDisplay % 10);
240    toDisplay  /= 10;
241    delayMicroseconds(BRIGHTNESS);
242    ShowNumber(10);
243    //Turn  off all digits
244    digitalWrite(digit1, DIGIT_OFF);
245    digitalWrite(digit2,  DIGIT_OFF);
246    digitalWrite(digit3, DIGIT_OFF);
247    digitalWrite(digit4,  DIGIT_OFF);
248  }
249}
250
251//====================for display of Second and dots============
252void  displaysecond(int sec) {
253#define BRIGHTNESS 1000
254#define BRIGHTNESS1  400
255
256#define  DIGIT_ON  HIGH
257#define DIGIT_OFF  LOW
258  int yy = sec / 10;
259  int aa = sec  % 10;
260  digitalWrite(digit5, DIGIT_ON);
261  digitalWrite(digit6, DIGIT_OFF);
262  if (sec % 2 == 0 ) {
263    digitalWrite(Dot, LOW);
264    delayMicroseconds(BRIGHTNESS);
265  }
266  else;
267   digitalWrite(Dot, HIGH);
268   delayMicroseconds(BRIGHTNESS1);
269   digitalWrite(digit6, DIGIT_ON);
270   digitalWrite(digit5, DIGIT_OFF);
271 
272ShowNumber(yy);
273  delayMicroseconds(BRIGHTNESS);
274  digitalWrite(digit5, DIGIT_ON);
275  digitalWrite(digit6,  DIGIT_OFF);
276  
277  ShowNumber(aa );
278  delayMicroseconds(BRIGHTNESS);
279  
280  ShowNumber(10);
281  digitalWrite(digit6, DIGIT_OFF);
282  digitalWrite(digit5,  DIGIT_OFF);
283}
284//================for diplay of each of the six digits=============
285void  ShowNumber(int numberToDisplay) {
286
287#define SEGMENT_ON  LOW
288#define SEGMENT_OFF  HIGH
289
290  switch (numberToDisplay) {
291    case 0:
292      digitalWrite(segA,  SEGMENT_ON);
293      digitalWrite(segB, SEGMENT_ON);
294      digitalWrite(segC,  SEGMENT_ON);
295      digitalWrite(segD, SEGMENT_ON);
296      digitalWrite(segE,  SEGMENT_ON);
297      digitalWrite(segF, SEGMENT_ON);
298      digitalWrite(segG,  SEGMENT_OFF);
299      break;
300    case 1:
301      digitalWrite(segA, SEGMENT_OFF);
302      digitalWrite(segB, SEGMENT_ON);
303      digitalWrite(segC, SEGMENT_ON);
304      digitalWrite(segD, SEGMENT_OFF);
305      digitalWrite(segE, SEGMENT_OFF);
306      digitalWrite(segF, SEGMENT_OFF);
307      digitalWrite(segG, SEGMENT_OFF);
308      break;
309    case 2:
310      digitalWrite(segA, SEGMENT_ON);
311      digitalWrite(segB,  SEGMENT_ON);
312      digitalWrite(segC, SEGMENT_OFF);
313      digitalWrite(segD,  SEGMENT_ON);
314      digitalWrite(segE, SEGMENT_ON);
315      digitalWrite(segF,  SEGMENT_OFF);
316      digitalWrite(segG, SEGMENT_ON);
317      break;
318    case  3:
319      digitalWrite(segA, SEGMENT_ON);
320      digitalWrite(segB, SEGMENT_ON);
321      digitalWrite(segC, SEGMENT_ON);
322      digitalWrite(segD, SEGMENT_ON);
323      digitalWrite(segE, SEGMENT_OFF);
324      digitalWrite(segF, SEGMENT_OFF);
325      digitalWrite(segG, SEGMENT_ON);
326      break;
327    case 4:
328      digitalWrite(segA,  SEGMENT_OFF);
329      digitalWrite(segB, SEGMENT_ON);
330      digitalWrite(segC,  SEGMENT_ON);
331      digitalWrite(segD, SEGMENT_OFF);
332      digitalWrite(segE,  SEGMENT_OFF);
333      digitalWrite(segF, SEGMENT_ON);
334      digitalWrite(segG,  SEGMENT_ON);
335      break;
336    case 5:
337      digitalWrite(segA, SEGMENT_ON);
338      digitalWrite(segB, SEGMENT_OFF);
339      digitalWrite(segC, SEGMENT_ON);
340      digitalWrite(segD, SEGMENT_ON);
341      digitalWrite(segE, SEGMENT_OFF);
342      digitalWrite(segF, SEGMENT_ON);
343      digitalWrite(segG, SEGMENT_ON);
344      break;
345    case 6:
346      digitalWrite(segA, SEGMENT_ON);
347      digitalWrite(segB,  SEGMENT_OFF);
348      digitalWrite(segC, SEGMENT_ON);
349      digitalWrite(segD,  SEGMENT_ON);
350      digitalWrite(segE, SEGMENT_ON);
351      digitalWrite(segF,  SEGMENT_ON);
352      digitalWrite(segG, SEGMENT_ON);
353      break;
354    case  7:
355      digitalWrite(segA, SEGMENT_ON);
356      digitalWrite(segB, SEGMENT_ON);
357      digitalWrite(segC, SEGMENT_ON);
358      digitalWrite(segD, SEGMENT_OFF);
359      digitalWrite(segE, SEGMENT_OFF);
360      digitalWrite(segF, SEGMENT_OFF);
361      digitalWrite(segG, SEGMENT_OFF);
362      break;
363    case 8:
364      digitalWrite(segA,  SEGMENT_ON);
365      digitalWrite(segB, SEGMENT_ON);
366      digitalWrite(segC,  SEGMENT_ON);
367      digitalWrite(segD, SEGMENT_ON);
368      digitalWrite(segE,  SEGMENT_ON);
369      digitalWrite(segF, SEGMENT_ON);
370      digitalWrite(segG,  SEGMENT_ON);
371      break;
372    case 9:
373      digitalWrite(segA, SEGMENT_ON);
374      digitalWrite(segB, SEGMENT_ON);
375      digitalWrite(segC, SEGMENT_ON);
376      digitalWrite(segD, SEGMENT_ON);
377      digitalWrite(segE, SEGMENT_OFF);
378      digitalWrite(segF, SEGMENT_ON);
379      digitalWrite(segG, SEGMENT_ON);
380      break;
381    case 10:
382      digitalWrite(segA, SEGMENT_OFF);
383      digitalWrite(segB,  SEGMENT_OFF);
384      digitalWrite(segC, SEGMENT_OFF);
385      digitalWrite(segD,  SEGMENT_OFF);
386      digitalWrite(segE, SEGMENT_OFF);
387      digitalWrite(segF,  SEGMENT_OFF);
388      digitalWrite(segG, SEGMENT_OFF);
389      break;
390
391  }}
392//====================For storing alarnm data in flash memory===========
393
394  void ALARMSTORE(int alrmtim , int rw ,  int newdtt1) {
395
396   static unsigned  int altim;
397   int EEAddr = EEADDR;
398   altim = alrmtim;
399   if (rw == 1){  
400      EEPROM.update(EEAddr , altim); EEAddr += sizeof(altim);
401   //   Serial.print("EEPROM  Written");
402   //   Serial.print(altim);
403      newdtt1 = altim;
404      dtt2  = altim;
405   }   
406
407 else{}
408      if (rw == 0){
409      EEPROM.get(EEAddr  , altim); EEAddr += sizeof(altim);
410     // Serial.print("EEPROMread");
411    //  Serial.print(altim);
412      newdtt1 = altim;
413 dtt2 = altim; 
414}
415else{}
416
417}  // end of  ALRMSTORE
418

int aset;
int dtt2;
int newdtt1;
int digit1 = 11; 
int digit2  = 10; 
int digit3 = 9; 
int digit4 = 6; 
int digit5 = A3; 
int digit6  = A2; 
int Dot = 1;
int Hrchime = 0;
int segA = 2;
int segB = 3;    
int  segC = 4; 
int segD = 5; 
int segE = 12; 
int segF = 7; 
int segG =  8; 
int SW0   =A0;
int SW1   =A1;
int almout =13;
int aset1 = 3; //  set value as 3  for first time retrival of alarm set 
int alringt =1; // required  alarm ring time in minute
int hrchringt = 6;// required time for hour chime in  seconds
static unsigned int altim;
//#include <Wire.h>
#include "RTClib.h"
#include  <EEPROM.h>
#define EEADDR 166 // Start location to write EEPROM data.
RTC_DS3231  RTC;
// =====================setup()=================================
void  setup() {
//Serial.begin(9600);
   RTC.begin();
  DateTime now = RTC.now();
//RTC.adjust(DateTime(__DATE__,  __TIME__));// for setting clock   remove // from this line  and upload sketch
  //after setting clock again put // on the line and upload once more 

  pinMode(segA,  OUTPUT);
  pinMode(segB, OUTPUT);
  pinMode(segC, OUTPUT);
  pinMode(segD,  OUTPUT);
  pinMode(segE, OUTPUT);
  pinMode(segF, OUTPUT);
  pinMode(segG,  OUTPUT);
  pinMode(Dot, OUTPUT);
  pinMode(Hrchime, OUTPUT);
  pinMode(digit1,  OUTPUT);
  pinMode(digit2, OUTPUT);
  pinMode(digit3, OUTPUT);
  pinMode(digit4,  OUTPUT);
  pinMode(digit5, OUTPUT);
  pinMode(digit6, OUTPUT);
  pinMode(almout,  OUTPUT);
  pinMode(SW0, INPUT);  // Alarm  setting SPST  switch
  pinMode(SW1,  INPUT);  //Alarm setting  PUSH switch
  digitalWrite(SW0, LOW);
  digitalWrite(SW1,  LOW);
  digitalWrite(almout, LOW);
  digitalWrite(Hrchime, LOW);


//  retrieving alarm set time from flash on first time power_on

int EEAddr  = EEADDR;
if (aset1 == 3  ) {
  EEPROM.get(EEAddr , altim); EEAddr += sizeof(altim);
    newdtt1 = altim;
    dtt2 = altim; 
    aset1 = 6;
    aset  = 7;
  //Serial.print ("Flash first Read  "); 
  //Serial.print (dtt2);
 }
  else{}

//  end of alrm set time retrieving from flash memory
 
}//==================end  of setup ()====================================



//********************  STARTING MAIN PROGRAM*****************************

void loop() {
  //digitalWrite(segDP,  HIGH);

  int mt;
  int dt;
  int dtt;
  int almsethr;
  int almsetmn;
  int chm;

while ( digitalRead(SW0) == HIGH  && digitalRead(SW1) == LOW ){
  
    dt = almsethr;
    mt = almsetmn;
   
    for (int i = 20 ; i >  0  ; i--) {
      Light_HR_MIN(dtt2);
     Light_HR_MIN(dtt2);
    }
    }    //end of while loop

 
 while ( digitalRead(SW0) == HIGH  && digitalRead(SW1)  == HIGH){
    digitalWrite(Dot, HIGH);
    digitalWrite(digit5, HIGH);
    digitalWrite(digit6, HIGH);
    
    dtt2++;
    int a;
    int  b;
    a = dtt2 / 100;
    b = dtt2 % 100;

    if (b >= 60)
    {  b = 0;
      a++;
    }
    else {}
    if (a >= 24) a = 0;
    else  {}
    dtt2 =  a * 100 + b;

    for (int i = 20 ; i > 0  ; i--) {
     Light_HR_MIN(dtt2);
     Light_HR_MIN(dtt2);
      
    }
    almsethr  = dt;
    almsetmn = mt;
    aset =1;
  
    }        //end of while  loop


 while ( digitalRead(SW0) == LOW ){
   DateTime now = RTC.now();
   int rr= (now.hour());
   int gt=(now.minute());
   int timp5 = rr*100 +  gt;
  
//----------- Writing Alarm set_time to Flash memory------
 
  
  if (aset == 1){
 ALARMSTORE(dtt2 ,1 , newdtt1);
aset = 6;
}
else{}

//---------------------------------Alarm  ringing------

   if (timp5 == dtt2   ) {
           digitalWrite(almout,  HIGH);
        }
   else{}
 if (timp5 == dtt2+alringt) {
   digitalWrite(almout,  LOW);
}
  else{}
  
//-----------------------------Hour chime setting----------=----
  
if ( timp5 % 100 == 00   &&  now.second() <= hrchringt )    
       { digitalWrite(Hrchime,  HIGH);
       }
    else{       
   digitalWrite(Hrchime , LOW); }

  
//------------STARTS LINES FOR DISPLAYING CURRENT TIME-----------
   
  if ( digitalRead(SW0) == LOW  ) {

 DateTime now = RTC.now();
  int tim  = (now.hour());
  if (tim >  12) {
   tim = tim - 12;
    }
  else;
  if (tim ==  0) {
      tim = 12; }
    else;
    int timp = (tim * 100  + now.minute());
    int timp1 = now.second();
   
// For Digits display
    for (int i = 8 ; i > 0  ; i--) {
       Light_HR_MIN(timp);
       displaysecond(timp1);  }
   }
  else {}

}   //end of WHILE loop 

 } // ==================END  OF MAIN PROGRAM======================


// ***************SUB PROGRAMS************************************

//======================for  display of Hour and Minute============
void Light_HR_MIN(int toDisplay) {
#define  BRIGHTNESS  1000
#define DIGIT_ON  HIGH
#define DIGIT_OFF  LOW
int hrr  =toDisplay/100;

  if (digitalRead(SW1) == HIGH)
  { digitalWrite(digit5,  LOW);
    digitalWrite(digit6, LOW);
  }
  else{}

  for (int digit  = 4 ; digit > 0 ; digit--) {
        switch (digit) {
     
      case  1:
      if (hrr < 10  && hrr != 0 )
         {digitalWrite(digit1, DIGIT_OFF);
         }
         else{
         digitalWrite(digit1, DIGIT_ON);
         }
         break;
      case 2:
         digitalWrite(digit2, DIGIT_ON);
         break;
      case 3:
        digitalWrite(digit3, DIGIT_ON);
         break;
      case 4:
        digitalWrite(digit4, DIGIT_ON);
        break;
    }
    
    ShowNumber(toDisplay % 10);
    toDisplay  /= 10;
    delayMicroseconds(BRIGHTNESS);
    ShowNumber(10);
    //Turn  off all digits
    digitalWrite(digit1, DIGIT_OFF);
    digitalWrite(digit2,  DIGIT_OFF);
    digitalWrite(digit3, DIGIT_OFF);
    digitalWrite(digit4,  DIGIT_OFF);
  }
}

//====================for display of Second and dots============
void  displaysecond(int sec) {
#define BRIGHTNESS 1000
#define BRIGHTNESS1  400

#define  DIGIT_ON  HIGH
#define DIGIT_OFF  LOW
  int yy = sec / 10;
  int aa = sec  % 10;
  digitalWrite(digit5, DIGIT_ON);
  digitalWrite(digit6, DIGIT_OFF);
  if (sec % 2 == 0 ) {
    digitalWrite(Dot, LOW);
    delayMicroseconds(BRIGHTNESS);
  }
  else;
   digitalWrite(Dot, HIGH);
   delayMicroseconds(BRIGHTNESS1);
   digitalWrite(digit6, DIGIT_ON);
   digitalWrite(digit5, DIGIT_OFF);
 
ShowNumber(yy);
  delayMicroseconds(BRIGHTNESS);
  digitalWrite(digit5, DIGIT_ON);
  digitalWrite(digit6,  DIGIT_OFF);
  
  ShowNumber(aa );
  delayMicroseconds(BRIGHTNESS);
  
  ShowNumber(10);
  digitalWrite(digit6, DIGIT_OFF);
  digitalWrite(digit5,  DIGIT_OFF);
}
//================for diplay of each of the six digits=============
void  ShowNumber(int numberToDisplay) {

#define SEGMENT_ON  LOW
#define SEGMENT_OFF  HIGH

  switch (numberToDisplay) {
    case 0:
      digitalWrite(segA,  SEGMENT_ON);
      digitalWrite(segB, SEGMENT_ON);
      digitalWrite(segC,  SEGMENT_ON);
      digitalWrite(segD, SEGMENT_ON);
      digitalWrite(segE,  SEGMENT_ON);
      digitalWrite(segF, SEGMENT_ON);
      digitalWrite(segG,  SEGMENT_OFF);
      break;
    case 1:
      digitalWrite(segA, SEGMENT_OFF);
      digitalWrite(segB, SEGMENT_ON);
      digitalWrite(segC, SEGMENT_ON);
      digitalWrite(segD, SEGMENT_OFF);
      digitalWrite(segE, SEGMENT_OFF);
      digitalWrite(segF, SEGMENT_OFF);
      digitalWrite(segG, SEGMENT_OFF);
      break;
    case 2:
      digitalWrite(segA, SEGMENT_ON);
      digitalWrite(segB,  SEGMENT_ON);
      digitalWrite(segC, SEGMENT_OFF);
      digitalWrite(segD,  SEGMENT_ON);
      digitalWrite(segE, SEGMENT_ON);
      digitalWrite(segF,  SEGMENT_OFF);
      digitalWrite(segG, SEGMENT_ON);
      break;
    case  3:
      digitalWrite(segA, SEGMENT_ON);
      digitalWrite(segB, SEGMENT_ON);
      digitalWrite(segC, SEGMENT_ON);
      digitalWrite(segD, SEGMENT_ON);
      digitalWrite(segE, SEGMENT_OFF);
      digitalWrite(segF, SEGMENT_OFF);
      digitalWrite(segG, SEGMENT_ON);
      break;
    case 4:
      digitalWrite(segA,  SEGMENT_OFF);
      digitalWrite(segB, SEGMENT_ON);
      digitalWrite(segC,  SEGMENT_ON);
      digitalWrite(segD, SEGMENT_OFF);
      digitalWrite(segE,  SEGMENT_OFF);
      digitalWrite(segF, SEGMENT_ON);
      digitalWrite(segG,  SEGMENT_ON);
      break;
    case 5:
      digitalWrite(segA, SEGMENT_ON);
      digitalWrite(segB, SEGMENT_OFF);
      digitalWrite(segC, SEGMENT_ON);
      digitalWrite(segD, SEGMENT_ON);
      digitalWrite(segE, SEGMENT_OFF);
      digitalWrite(segF, SEGMENT_ON);
      digitalWrite(segG, SEGMENT_ON);
      break;
    case 6:
      digitalWrite(segA, SEGMENT_ON);
      digitalWrite(segB,  SEGMENT_OFF);
      digitalWrite(segC, SEGMENT_ON);
      digitalWrite(segD,  SEGMENT_ON);
      digitalWrite(segE, SEGMENT_ON);
      digitalWrite(segF,  SEGMENT_ON);
      digitalWrite(segG, SEGMENT_ON);
      break;
    case  7:
      digitalWrite(segA, SEGMENT_ON);
      digitalWrite(segB, SEGMENT_ON);
      digitalWrite(segC, SEGMENT_ON);
      digitalWrite(segD, SEGMENT_OFF);
      digitalWrite(segE, SEGMENT_OFF);
      digitalWrite(segF, SEGMENT_OFF);
      digitalWrite(segG, SEGMENT_OFF);
      break;
    case 8:
      digitalWrite(segA,  SEGMENT_ON);
      digitalWrite(segB, SEGMENT_ON);
      digitalWrite(segC,  SEGMENT_ON);
      digitalWrite(segD, SEGMENT_ON);
      digitalWrite(segE,  SEGMENT_ON);
      digitalWrite(segF, SEGMENT_ON);
      digitalWrite(segG,  SEGMENT_ON);
      break;
    case 9:
      digitalWrite(segA, SEGMENT_ON);
      digitalWrite(segB, SEGMENT_ON);
      digitalWrite(segC, SEGMENT_ON);
      digitalWrite(segD, SEGMENT_ON);
      digitalWrite(segE, SEGMENT_OFF);
      digitalWrite(segF, SEGMENT_ON);
      digitalWrite(segG, SEGMENT_ON);
      break;
    case 10:
      digitalWrite(segA, SEGMENT_OFF);
      digitalWrite(segB,  SEGMENT_OFF);
      digitalWrite(segC, SEGMENT_OFF);
      digitalWrite(segD,  SEGMENT_OFF);
      digitalWrite(segE, SEGMENT_OFF);
      digitalWrite(segF,  SEGMENT_OFF);
      digitalWrite(segG, SEGMENT_OFF);
      break;

  }}
//====================For storing alarnm data in flash memory===========

  void ALARMSTORE(int alrmtim , int rw ,  int newdtt1) {

   static unsigned  int altim;
   int EEAddr = EEADDR;
   altim = alrmtim;
   if (rw == 1){  
      EEPROM.update(EEAddr , altim); EEAddr += sizeof(altim);
   //   Serial.print("EEPROM  Written");
   //   Serial.print(altim);
      newdtt1 = altim;
      dtt2  = altim;
   }   

 else{}
      if (rw == 0){
      EEPROM.get(EEAddr  , altim); EEAddr += sizeof(altim);
     // Serial.print("EEPROMread");
    //  Serial.print(altim);
      newdtt1 = altim;
 dtt2 = altim; 
}
else{}

}  // end of  ALRMSTORE

Arduino sketch for Digital Clock

arduino

Arduino Sketch for Digital Clock

1int aset;
2int dtt2;
3int newdtt1;
4int digit1 = 11; 
5int digit2
6  = 10; 
7int digit3 = 9; 
8int digit4 = 6; 
9int digit5 = A3; 
10int digit6
11  = A2; 
12int Dot = 1;
13int Hrchime = 0;
14int segA = 2;
15int segB = 3;    
16int
17  segC = 4; 
18int segD = 5; 
19int segE = 12; 
20int segF = 7; 
21int segG =
22  8; 
23int SW0   =A0;
24int SW1   =A1;
25int almout =13;
26int aset1 = 3; //
27  set value as 3  for first time retrival of alarm set 
28int alringt =1; // required
29  alarm ring time in minute
30int hrchringt = 6;// required time for hour chime in
31  seconds
32static unsigned int altim;
33//#include <Wire.h>
34#include "RTClib.h"
35#include
36  <EEPROM.h>
37#define EEADDR 166 // Start location to write EEPROM data.
38RTC_DS3231
39  RTC;
40// =====================setup()=================================
41void
42  setup() {
43//Serial.begin(9600);
44   RTC.begin();
45  DateTime now = RTC.now();
46//RTC.adjust(DateTime(__DATE__,
47  __TIME__));// for setting clock   remove // from this line  and upload sketch
48
49  //after setting clock again put // on the line and upload once more 
50
51  pinMode(segA,
52  OUTPUT);
53  pinMode(segB, OUTPUT);
54  pinMode(segC, OUTPUT);
55  pinMode(segD,
56  OUTPUT);
57  pinMode(segE, OUTPUT);
58  pinMode(segF, OUTPUT);
59  pinMode(segG,
60  OUTPUT);
61  pinMode(Dot, OUTPUT);
62  pinMode(Hrchime, OUTPUT);
63  pinMode(digit1,
64  OUTPUT);
65  pinMode(digit2, OUTPUT);
66  pinMode(digit3, OUTPUT);
67  pinMode(digit4,
68  OUTPUT);
69  pinMode(digit5, OUTPUT);
70  pinMode(digit6, OUTPUT);
71  pinMode(almout,
72  OUTPUT);
73  pinMode(SW0, INPUT);  // Alarm  setting SPST  switch
74  pinMode(SW1,
75  INPUT);  //Alarm setting  PUSH switch
76  digitalWrite(SW0, LOW);
77  digitalWrite(SW1,
78  LOW);
79  digitalWrite(almout, LOW);
80  digitalWrite(Hrchime, LOW);
81
82
83//
84  retrieving alarm set time from flash on first time power_on
85
86int EEAddr
87  = EEADDR;
88if (aset1 == 3  ) {
89  EEPROM.get(EEAddr , altim); EEAddr += sizeof(altim);
90
91    newdtt1 = altim;
92    dtt2 = altim; 
93    aset1 = 6;
94    aset  = 7;
95
96  //Serial.print ("Flash first Read  "); 
97  //Serial.print (dtt2);
98 }
99
100  else{}
101
102//  end of alrm set time retrieving from flash memory
103 
104}//==================end
105  of setup ()====================================
106
107
108
109//********************
110  STARTING MAIN PROGRAM*****************************
111
112void loop() {
113  //digitalWrite(segDP,
114  HIGH);
115
116  int mt;
117  int dt;
118  int dtt;
119  int almsethr;
120  int almsetmn;
121
122  int chm;
123
124while ( digitalRead(SW0) == HIGH  && digitalRead(SW1) == LOW ){
125
126  
127    dt = almsethr;
128    mt = almsetmn;
129   
130    for (int i = 20 ; i >
131  0  ; i--) {
132      Light_HR_MIN(dtt2);
133     Light_HR_MIN(dtt2);
134    }
135
136    }    //end of while loop
137
138 
139 while ( digitalRead(SW0) == HIGH  && digitalRead(SW1)
140  == HIGH){
141    digitalWrite(Dot, HIGH);
142    digitalWrite(digit5, HIGH);
143
144    digitalWrite(digit6, HIGH);
145    
146    dtt2++;
147    int a;
148    int
149  b;
150    a = dtt2 / 100;
151    b = dtt2 % 100;
152
153    if (b >= 60)
154    {
155  b = 0;
156      a++;
157    }
158    else {}
159    if (a >= 24) a = 0;
160    else
161  {}
162    dtt2 =  a * 100 + b;
163
164    for (int i = 20 ; i > 0  ; i--) {
165
166     Light_HR_MIN(dtt2);
167     Light_HR_MIN(dtt2);
168      
169    }
170    almsethr
171  = dt;
172    almsetmn = mt;
173    aset =1;
174  
175    }        //end of while
176  loop
177
178
179 while ( digitalRead(SW0) == LOW ){
180   DateTime now = RTC.now();
181
182   int rr= (now.hour());
183   int gt=(now.minute());
184   int timp5 = rr*100 +
185  gt;
186  
187//----------- Writing Alarm set_time to Flash memory------
188 
189
190  
191  if (aset == 1){
192 ALARMSTORE(dtt2 ,1 , newdtt1);
193aset = 6;
194}
195else{}
196
197//---------------------------------Alarm
198  ringing------
199
200   if (timp5 == dtt2   ) {
201           digitalWrite(almout,
202  HIGH);
203        }
204   else{}
205 if (timp5 == dtt2+alringt) {
206   digitalWrite(almout,
207  LOW);
208}
209  else{}
210  
211//-----------------------------Hour chime setting----------=----
212
213  
214if ( timp5 % 100 == 00   &&  now.second() <= hrchringt )    
215       { digitalWrite(Hrchime,
216  HIGH);
217       }
218    else{       
219   digitalWrite(Hrchime , LOW); }
220
221
222  
223//------------STARTS LINES FOR DISPLAYING CURRENT TIME-----------
224   
225
226  if ( digitalRead(SW0) == LOW  ) {
227
228 DateTime now = RTC.now();
229  int tim
230  = (now.hour());
231  if (tim >  12) {
232   tim = tim - 12;
233    }
234  else;
235
236  if (tim ==  0) {
237      tim = 12; }
238    else;
239    int timp = (tim * 100
240  + now.minute());
241    int timp1 = now.second();
242   
243// For Digits display
244
245    for (int i = 8 ; i > 0  ; i--) {
246       Light_HR_MIN(timp);
247       displaysecond(timp1);
248  }
249   }
250  else {}
251
252}   //end of WHILE loop 
253
254 } // ==================END
255  OF MAIN PROGRAM======================
256
257
258// ***************SUB PROGRAMS************************************
259
260//======================for
261  display of Hour and Minute============
262void Light_HR_MIN(int toDisplay) {
263#define
264  BRIGHTNESS  1000
265#define DIGIT_ON  HIGH
266#define DIGIT_OFF  LOW
267int hrr
268  =toDisplay/100;
269
270  if (digitalRead(SW1) == HIGH)
271  { digitalWrite(digit5,
272  LOW);
273    digitalWrite(digit6, LOW);
274  }
275  else{}
276
277  for (int digit
278  = 4 ; digit > 0 ; digit--) {
279        switch (digit) {
280     
281      case
282  1:
283      if (hrr < 10  && hrr != 0 )
284         {digitalWrite(digit1, DIGIT_OFF);
285
286         }
287         else{
288         digitalWrite(digit1, DIGIT_ON);
289         }
290
291         break;
292      case 2:
293         digitalWrite(digit2, DIGIT_ON);
294
295         break;
296      case 3:
297        digitalWrite(digit3, DIGIT_ON);
298
299         break;
300      case 4:
301        digitalWrite(digit4, DIGIT_ON);
302
303        break;
304    }
305    
306    ShowNumber(toDisplay % 10);
307    toDisplay
308  /= 10;
309    delayMicroseconds(BRIGHTNESS);
310    ShowNumber(10);
311    //Turn
312  off all digits
313    digitalWrite(digit1, DIGIT_OFF);
314    digitalWrite(digit2,
315  DIGIT_OFF);
316    digitalWrite(digit3, DIGIT_OFF);
317    digitalWrite(digit4,
318  DIGIT_OFF);
319  }
320}
321
322//====================for display of Second and dots============
323void
324  displaysecond(int sec) {
325#define BRIGHTNESS 1000
326#define BRIGHTNESS1  400
327
328#define
329  DIGIT_ON  HIGH
330#define DIGIT_OFF  LOW
331  int yy = sec / 10;
332  int aa = sec
333  % 10;
334  digitalWrite(digit5, DIGIT_ON);
335  digitalWrite(digit6, DIGIT_OFF);
336
337  if (sec % 2 == 0 ) {
338    digitalWrite(Dot, LOW);
339    delayMicroseconds(BRIGHTNESS);
340
341  }
342  else;
343   digitalWrite(Dot, HIGH);
344   delayMicroseconds(BRIGHTNESS1);
345
346   digitalWrite(digit6, DIGIT_ON);
347   digitalWrite(digit5, DIGIT_OFF);
348 
349ShowNumber(yy);
350
351  delayMicroseconds(BRIGHTNESS);
352  digitalWrite(digit5, DIGIT_ON);
353  digitalWrite(digit6,
354  DIGIT_OFF);
355  
356  ShowNumber(aa );
357  delayMicroseconds(BRIGHTNESS);
358
359  
360  ShowNumber(10);
361  digitalWrite(digit6, DIGIT_OFF);
362  digitalWrite(digit5,
363  DIGIT_OFF);
364}
365//================for diplay of each of the six digits=============
366void
367  ShowNumber(int numberToDisplay) {
368
369#define SEGMENT_ON  LOW
370#define SEGMENT_OFF
371  HIGH
372
373  switch (numberToDisplay) {
374    case 0:
375      digitalWrite(segA,
376  SEGMENT_ON);
377      digitalWrite(segB, SEGMENT_ON);
378      digitalWrite(segC,
379  SEGMENT_ON);
380      digitalWrite(segD, SEGMENT_ON);
381      digitalWrite(segE,
382  SEGMENT_ON);
383      digitalWrite(segF, SEGMENT_ON);
384      digitalWrite(segG,
385  SEGMENT_OFF);
386      break;
387    case 1:
388      digitalWrite(segA, SEGMENT_OFF);
389
390      digitalWrite(segB, SEGMENT_ON);
391      digitalWrite(segC, SEGMENT_ON);
392
393      digitalWrite(segD, SEGMENT_OFF);
394      digitalWrite(segE, SEGMENT_OFF);
395
396      digitalWrite(segF, SEGMENT_OFF);
397      digitalWrite(segG, SEGMENT_OFF);
398
399      break;
400    case 2:
401      digitalWrite(segA, SEGMENT_ON);
402      digitalWrite(segB,
403  SEGMENT_ON);
404      digitalWrite(segC, SEGMENT_OFF);
405      digitalWrite(segD,
406  SEGMENT_ON);
407      digitalWrite(segE, SEGMENT_ON);
408      digitalWrite(segF,
409  SEGMENT_OFF);
410      digitalWrite(segG, SEGMENT_ON);
411      break;
412    case
413  3:
414      digitalWrite(segA, SEGMENT_ON);
415      digitalWrite(segB, SEGMENT_ON);
416
417      digitalWrite(segC, SEGMENT_ON);
418      digitalWrite(segD, SEGMENT_ON);
419
420      digitalWrite(segE, SEGMENT_OFF);
421      digitalWrite(segF, SEGMENT_OFF);
422
423      digitalWrite(segG, SEGMENT_ON);
424      break;
425    case 4:
426      digitalWrite(segA,
427  SEGMENT_OFF);
428      digitalWrite(segB, SEGMENT_ON);
429      digitalWrite(segC,
430  SEGMENT_ON);
431      digitalWrite(segD, SEGMENT_OFF);
432      digitalWrite(segE,
433  SEGMENT_OFF);
434      digitalWrite(segF, SEGMENT_ON);
435      digitalWrite(segG,
436  SEGMENT_ON);
437      break;
438    case 5:
439      digitalWrite(segA, SEGMENT_ON);
440
441      digitalWrite(segB, SEGMENT_OFF);
442      digitalWrite(segC, SEGMENT_ON);
443
444      digitalWrite(segD, SEGMENT_ON);
445      digitalWrite(segE, SEGMENT_OFF);
446
447      digitalWrite(segF, SEGMENT_ON);
448      digitalWrite(segG, SEGMENT_ON);
449
450      break;
451    case 6:
452      digitalWrite(segA, SEGMENT_ON);
453      digitalWrite(segB,
454  SEGMENT_OFF);
455      digitalWrite(segC, SEGMENT_ON);
456      digitalWrite(segD,
457  SEGMENT_ON);
458      digitalWrite(segE, SEGMENT_ON);
459      digitalWrite(segF,
460  SEGMENT_ON);
461      digitalWrite(segG, SEGMENT_ON);
462      break;
463    case
464  7:
465      digitalWrite(segA, SEGMENT_ON);
466      digitalWrite(segB, SEGMENT_ON);
467
468      digitalWrite(segC, SEGMENT_ON);
469      digitalWrite(segD, SEGMENT_OFF);
470
471      digitalWrite(segE, SEGMENT_OFF);
472      digitalWrite(segF, SEGMENT_OFF);
473
474      digitalWrite(segG, SEGMENT_OFF);
475      break;
476    case 8:
477      digitalWrite(segA,
478  SEGMENT_ON);
479      digitalWrite(segB, SEGMENT_ON);
480      digitalWrite(segC,
481  SEGMENT_ON);
482      digitalWrite(segD, SEGMENT_ON);
483      digitalWrite(segE,
484  SEGMENT_ON);
485      digitalWrite(segF, SEGMENT_ON);
486      digitalWrite(segG,
487  SEGMENT_ON);
488      break;
489    case 9:
490      digitalWrite(segA, SEGMENT_ON);
491
492      digitalWrite(segB, SEGMENT_ON);
493      digitalWrite(segC, SEGMENT_ON);
494
495      digitalWrite(segD, SEGMENT_ON);
496      digitalWrite(segE, SEGMENT_OFF);
497
498      digitalWrite(segF, SEGMENT_ON);
499      digitalWrite(segG, SEGMENT_ON);
500
501      break;
502    case 10:
503      digitalWrite(segA, SEGMENT_OFF);
504      digitalWrite(segB,
505  SEGMENT_OFF);
506      digitalWrite(segC, SEGMENT_OFF);
507      digitalWrite(segD,
508  SEGMENT_OFF);
509      digitalWrite(segE, SEGMENT_OFF);
510      digitalWrite(segF,
511  SEGMENT_OFF);
512      digitalWrite(segG, SEGMENT_OFF);
513      break;
514
515
516  }}
517//====================For storing alarnm data in flash memory===========
518
519
520  void ALARMSTORE(int alrmtim , int rw ,  int newdtt1) {
521
522   static unsigned
523  int altim;
524   int EEAddr = EEADDR;
525   altim = alrmtim;
526   if (rw == 1){
527  
528      EEPROM.update(EEAddr , altim); EEAddr += sizeof(altim);
529   //   Serial.print("EEPROM
530  Written");
531   //   Serial.print(altim);
532      newdtt1 = altim;
533      dtt2
534  = altim;
535   }   
536
537 else{}
538      if (rw == 0){
539      EEPROM.get(EEAddr
540  , altim); EEAddr += sizeof(altim);
541     // Serial.print("EEPROMread");
542
543    //  Serial.print(altim);
544      newdtt1 = altim;
545 dtt2 = altim; 
546}
547else{}
548
549}
550  // end of  ALRMSTORE
551

int aset;
int dtt2;
int newdtt1;
int digit1 = 11; 
int digit2
  = 10; 
int digit3 = 9; 
int digit4 = 6; 
int digit5 = A3; 
int digit6
  = A2; 
int Dot = 1;
int Hrchime = 0;
int segA = 2;
int segB = 3;    
int
  segC = 4; 
int segD = 5; 
int segE = 12; 
int segF = 7; 
int segG =
  8; 
int SW0   =A0;
int SW1   =A1;
int almout =13;
int aset1 = 3; //
  set value as 3  for first time retrival of alarm set 
int alringt =1; // required
  alarm ring time in minute
int hrchringt = 6;// required time for hour chime in
  seconds
static unsigned int altim;
//#include <Wire.h>
#include "RTClib.h"
#include
  <EEPROM.h>
#define EEADDR 166 // Start location to write EEPROM data.
RTC_DS3231
  RTC;
// =====================setup()=================================
void
  setup() {
//Serial.begin(9600);
   RTC.begin();
  DateTime now = RTC.now();
//RTC.adjust(DateTime(__DATE__,
  __TIME__));// for setting clock   remove // from this line  and upload sketch

  //after setting clock again put // on the line and upload once more 

  pinMode(segA,
  OUTPUT);
  pinMode(segB, OUTPUT);
  pinMode(segC, OUTPUT);
  pinMode(segD,
  OUTPUT);
  pinMode(segE, OUTPUT);
  pinMode(segF, OUTPUT);
  pinMode(segG,
  OUTPUT);
  pinMode(Dot, OUTPUT);
  pinMode(Hrchime, OUTPUT);
  pinMode(digit1,
  OUTPUT);
  pinMode(digit2, OUTPUT);
  pinMode(digit3, OUTPUT);
  pinMode(digit4,
  OUTPUT);
  pinMode(digit5, OUTPUT);
  pinMode(digit6, OUTPUT);
  pinMode(almout,
  OUTPUT);
  pinMode(SW0, INPUT);  // Alarm  setting SPST  switch
  pinMode(SW1,
  INPUT);  //Alarm setting  PUSH switch
  digitalWrite(SW0, LOW);
  digitalWrite(SW1,
  LOW);
  digitalWrite(almout, LOW);
  digitalWrite(Hrchime, LOW);


//
  retrieving alarm set time from flash on first time power_on

int EEAddr
  = EEADDR;
if (aset1 == 3  ) {
  EEPROM.get(EEAddr , altim); EEAddr += sizeof(altim);

    newdtt1 = altim;
    dtt2 = altim; 
    aset1 = 6;
    aset  = 7;

  //Serial.print ("Flash first Read  "); 
  //Serial.print (dtt2);
 }

  else{}

//  end of alrm set time retrieving from flash memory
 
}//==================end
  of setup ()====================================



//********************
  STARTING MAIN PROGRAM*****************************

void loop() {
  //digitalWrite(segDP,
  HIGH);

  int mt;
  int dt;
  int dtt;
  int almsethr;
  int almsetmn;

  int chm;

while ( digitalRead(SW0) == HIGH  && digitalRead(SW1) == LOW ){

  
    dt = almsethr;
    mt = almsetmn;
   
    for (int i = 20 ; i >
  0  ; i--) {
      Light_HR_MIN(dtt2);
     Light_HR_MIN(dtt2);
    }

    }    //end of while loop

 
 while ( digitalRead(SW0) == HIGH  && digitalRead(SW1)
  == HIGH){
    digitalWrite(Dot, HIGH);
    digitalWrite(digit5, HIGH);

    digitalWrite(digit6, HIGH);
    
    dtt2++;
    int a;
    int
  b;
    a = dtt2 / 100;
    b = dtt2 % 100;

    if (b >= 60)
    {
  b = 0;
      a++;
    }
    else {}
    if (a >= 24) a = 0;
    else
  {}
    dtt2 =  a * 100 + b;

    for (int i = 20 ; i > 0  ; i--) {

     Light_HR_MIN(dtt2);
     Light_HR_MIN(dtt2);
      
    }
    almsethr
  = dt;
    almsetmn = mt;
    aset =1;
  
    }        //end of while
  loop


 while ( digitalRead(SW0) == LOW ){
   DateTime now = RTC.now();

   int rr= (now.hour());
   int gt=(now.minute());
   int timp5 = rr*100 +
  gt;
  
//----------- Writing Alarm set_time to Flash memory------
 

  
  if (aset == 1){
 ALARMSTORE(dtt2 ,1 , newdtt1);
aset = 6;
}
else{}

//---------------------------------Alarm
  ringing------

   if (timp5 == dtt2   ) {
           digitalWrite(almout,
  HIGH);
        }
   else{}
 if (timp5 == dtt2+alringt) {
   digitalWrite(almout,
  LOW);
}
  else{}
  
//-----------------------------Hour chime setting----------=----

  
if ( timp5 % 100 == 00   &&  now.second() <= hrchringt )    
       { digitalWrite(Hrchime,
  HIGH);
       }
    else{       
   digitalWrite(Hrchime , LOW); }


  
//------------STARTS LINES FOR DISPLAYING CURRENT TIME-----------
   

  if ( digitalRead(SW0) == LOW  ) {

 DateTime now = RTC.now();
  int tim
  = (now.hour());
  if (tim >  12) {
   tim = tim - 12;
    }
  else;

  if (tim ==  0) {
      tim = 12; }
    else;
    int timp = (tim * 100
  + now.minute());
    int timp1 = now.second();
   
// For Digits display

    for (int i = 8 ; i > 0  ; i--) {
       Light_HR_MIN(timp);
       displaysecond(timp1);
  }
   }
  else {}

}   //end of WHILE loop 

 } // ==================END
  OF MAIN PROGRAM======================


// ***************SUB PROGRAMS************************************

//======================for
  display of Hour and Minute============
void Light_HR_MIN(int toDisplay) {
#define
  BRIGHTNESS  1000
#define DIGIT_ON  HIGH
#define DIGIT_OFF  LOW
int hrr
  =toDisplay/100;

  if (digitalRead(SW1) == HIGH)
  { digitalWrite(digit5,
  LOW);
    digitalWrite(digit6, LOW);
  }
  else{}

  for (int digit
  = 4 ; digit > 0 ; digit--) {
        switch (digit) {
     
      case
  1:
      if (hrr < 10  && hrr != 0 )
         {digitalWrite(digit1, DIGIT_OFF);

         }
         else{
         digitalWrite(digit1, DIGIT_ON);
         }

         break;
      case 2:
         digitalWrite(digit2, DIGIT_ON);

         break;
      case 3:
        digitalWrite(digit3, DIGIT_ON);

         break;
      case 4:
        digitalWrite(digit4, DIGIT_ON);

        break;
    }
    
    ShowNumber(toDisplay % 10);
    toDisplay
  /= 10;
    delayMicroseconds(BRIGHTNESS);
    ShowNumber(10);
    //Turn
  off all digits
    digitalWrite(digit1, DIGIT_OFF);
    digitalWrite(digit2,
  DIGIT_OFF);
    digitalWrite(digit3, DIGIT_OFF);
    digitalWrite(digit4,
  DIGIT_OFF);
  }
}

//====================for display of Second and dots============
void
  displaysecond(int sec) {
#define BRIGHTNESS 1000
#define BRIGHTNESS1  400

#define
  DIGIT_ON  HIGH
#define DIGIT_OFF  LOW
  int yy = sec / 10;
  int aa = sec
  % 10;
  digitalWrite(digit5, DIGIT_ON);
  digitalWrite(digit6, DIGIT_OFF);

  if (sec % 2 == 0 ) {
    digitalWrite(Dot, LOW);
    delayMicroseconds(BRIGHTNESS);

  }
  else;
   digitalWrite(Dot, HIGH);
   delayMicroseconds(BRIGHTNESS1);

   digitalWrite(digit6, DIGIT_ON);
   digitalWrite(digit5, DIGIT_OFF);
 
ShowNumber(yy);

  delayMicroseconds(BRIGHTNESS);
  digitalWrite(digit5, DIGIT_ON);
  digitalWrite(digit6,
  DIGIT_OFF);
  
  ShowNumber(aa );
  delayMicroseconds(BRIGHTNESS);

  
  ShowNumber(10);
  digitalWrite(digit6, DIGIT_OFF);
  digitalWrite(digit5,
  DIGIT_OFF);
}
//================for diplay of each of the six digits=============
void
  ShowNumber(int numberToDisplay) {

#define SEGMENT_ON  LOW
#define SEGMENT_OFF
  HIGH

  switch (numberToDisplay) {
    case 0:
      digitalWrite(segA,
  SEGMENT_ON);
      digitalWrite(segB, SEGMENT_ON);
      digitalWrite(segC,
  SEGMENT_ON);
      digitalWrite(segD, SEGMENT_ON);
      digitalWrite(segE,
  SEGMENT_ON);
      digitalWrite(segF, SEGMENT_ON);
      digitalWrite(segG,
  SEGMENT_OFF);
      break;
    case 1:
      digitalWrite(segA, SEGMENT_OFF);

      digitalWrite(segB, SEGMENT_ON);
      digitalWrite(segC, SEGMENT_ON);

      digitalWrite(segD, SEGMENT_OFF);
      digitalWrite(segE, SEGMENT_OFF);

      digitalWrite(segF, SEGMENT_OFF);
      digitalWrite(segG, SEGMENT_OFF);

      break;
    case 2:
      digitalWrite(segA, SEGMENT_ON);
      digitalWrite(segB,
  SEGMENT_ON);
      digitalWrite(segC, SEGMENT_OFF);
      digitalWrite(segD,
  SEGMENT_ON);
      digitalWrite(segE, SEGMENT_ON);
      digitalWrite(segF,
  SEGMENT_OFF);
      digitalWrite(segG, SEGMENT_ON);
      break;
    case
  3:
      digitalWrite(segA, SEGMENT_ON);
      digitalWrite(segB, SEGMENT_ON);

      digitalWrite(segC, SEGMENT_ON);
      digitalWrite(segD, SEGMENT_ON);

      digitalWrite(segE, SEGMENT_OFF);
      digitalWrite(segF, SEGMENT_OFF);

      digitalWrite(segG, SEGMENT_ON);
      break;
    case 4:
      digitalWrite(segA,
  SEGMENT_OFF);
      digitalWrite(segB, SEGMENT_ON);
      digitalWrite(segC,
  SEGMENT_ON);
      digitalWrite(segD, SEGMENT_OFF);
      digitalWrite(segE,
  SEGMENT_OFF);
      digitalWrite(segF, SEGMENT_ON);
      digitalWrite(segG,
  SEGMENT_ON);
      break;
    case 5:
      digitalWrite(segA, SEGMENT_ON);

      digitalWrite(segB, SEGMENT_OFF);
      digitalWrite(segC, SEGMENT_ON);

      digitalWrite(segD, SEGMENT_ON);
      digitalWrite(segE, SEGMENT_OFF);

      digitalWrite(segF, SEGMENT_ON);
      digitalWrite(segG, SEGMENT_ON);

      break;
    case 6:
      digitalWrite(segA, SEGMENT_ON);
      digitalWrite(segB,
  SEGMENT_OFF);
      digitalWrite(segC, SEGMENT_ON);
      digitalWrite(segD,
  SEGMENT_ON);
      digitalWrite(segE, SEGMENT_ON);
      digitalWrite(segF,
  SEGMENT_ON);
      digitalWrite(segG, SEGMENT_ON);
      break;
    case
  7:
      digitalWrite(segA, SEGMENT_ON);
      digitalWrite(segB, SEGMENT_ON);

      digitalWrite(segC, SEGMENT_ON);
      digitalWrite(segD, SEGMENT_OFF);

      digitalWrite(segE, SEGMENT_OFF);
      digitalWrite(segF, SEGMENT_OFF);

      digitalWrite(segG, SEGMENT_OFF);
      break;
    case 8:
      digitalWrite(segA,
  SEGMENT_ON);
      digitalWrite(segB, SEGMENT_ON);
      digitalWrite(segC,
  SEGMENT_ON);
      digitalWrite(segD, SEGMENT_ON);
      digitalWrite(segE,
  SEGMENT_ON);
      digitalWrite(segF, SEGMENT_ON);
      digitalWrite(segG,
  SEGMENT_ON);
      break;
    case 9:
      digitalWrite(segA, SEGMENT_ON);

      digitalWrite(segB, SEGMENT_ON);
      digitalWrite(segC, SEGMENT_ON);

      digitalWrite(segD, SEGMENT_ON);
      digitalWrite(segE, SEGMENT_OFF);

      digitalWrite(segF, SEGMENT_ON);
      digitalWrite(segG, SEGMENT_ON);

      break;
    case 10:
      digitalWrite(segA, SEGMENT_OFF);
      digitalWrite(segB,
  SEGMENT_OFF);
      digitalWrite(segC, SEGMENT_OFF);
      digitalWrite(segD,
  SEGMENT_OFF);
      digitalWrite(segE, SEGMENT_OFF);
      digitalWrite(segF,
  SEGMENT_OFF);
      digitalWrite(segG, SEGMENT_OFF);
      break;


  }}
//====================For storing alarnm data in flash memory===========


  void ALARMSTORE(int alrmtim , int rw ,  int newdtt1) {

   static unsigned
  int altim;
   int EEAddr = EEADDR;
   altim = alrmtim;
   if (rw == 1){
  
      EEPROM.update(EEAddr , altim); EEAddr += sizeof(altim);
   //   Serial.print("EEPROM
  Written");
   //   Serial.print(altim);
      newdtt1 = altim;
      dtt2
  = altim;
   }   

 else{}
      if (rw == 0){
      EEPROM.get(EEAddr
  , altim); EEAddr += sizeof(altim);
     // Serial.print("EEPROMread");

    //  Serial.print(altim);
      newdtt1 = altim;
 dtt2 = altim; 
}
else{}

}
  // end of  ALRMSTORE

Downloadable files

Circuit Diagrams and images of the clock made

Documentation

Description of the Project

Comments

Only logged in users can leave comments

ajithbahul

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content