Arduino seven segment clock

Arduino ds1307 7-segment clock

Oct 24, 2020

•

4437 views

•

0 respects

Components and supplies

Pi RTC (DS1307)

7 Segment LED Display, InfoVue

Shift Register- Serial to Parallel

General Purpose Transistor NPN

Resistor 100 ohm

Resistor 10k ohm

Jumper wires (generic)

Solderless Breadboard Full Size

Arduino Nano R3

Apps and platforms

Arduino IDE

Project description

Code

Arduino 7segment clock code

c_cpp

copy it and paste on your arduino ide editor

1#include <Wire.h>
2#include <RTClib.h>
3
4RTC_DS1307 RTC;
5
6int
7  HOUR, MINUT, SECOND;
8int latchPin = 4; //pin 12 on the 595 o3 3
9int dataPin
10  = 2; //pin 14 on the 595 or 4
11int clockPin = 3; //pin 11 on the 595 or 2
12int
13  shift = 256;
14int units, tens, hundreds, thousands,tenthousand,lakh;
15int times
16  = 1;
17const int alarmHour = 17;
18const int alarmMinute = 26;
19
20void setup()
21  {
22  Serial.begin(9600);
23  pinMode(latchPin, OUTPUT);
24  pinMode(dataPin,
25  OUTPUT);
26  pinMode(clockPin, OUTPUT);
27  pinMode(13, OUTPUT);
28  Wire.begin();
29
30  RTC.begin();
31  if (!RTC.isrunning())
32  {
33    RTC.adjust(DateTime(__DATE__,
34  __TIME__));
35  }
36}
37
38void loop() {
39  
40  DateTime now = RTC.now();
41
42  HOUR = now.hour();
43  MINUT = now.minute();
44  SECOND = now.second();
45
46  //Serial.println(MINUT);
47  if (HOUR < 10)
48  {
49    tenthousand = HOUR;
50
51    lakh  = HOUR/10;
52  }
53  else if (HOUR >=  10 && HOUR < 24)
54  {
55    tenthousand
56  = HOUR % 10;
57    lakh = HOUR / 10;
58  }
59  if (MINUT <= 9)
60  {
61    hundreds
62  = MINUT;
63    thousands = MINUT/10;
64  }
65
66  else if (MINUT > 9 && MINUT
67  <= 60)
68  {
69    hundreds = MINUT % 10;
70    thousands = MINUT / 10;
71  }
72
73   if (SECOND <= 9)
74  {
75    units = SECOND;
76    tens = SECOND/10;
77  }
78
79
80  else if (SECOND > 9 && SECOND <= 60)
81  {
82    units = SECOND % 10;
83    tens
84  = SECOND / 10;
85  }
86
87  switch (hundreds)
88  {
89    case 0:
90      //0
91
92      digitalWrite(latchPin, LOW);
93      shiftOut(dataPin, clockPin, MSBFIRST,
94  shift * 8  >> 8 );
95      shiftOut(dataPin, clockPin, MSBFIRST, 0B01000000 );
96
97      digitalWrite(latchPin, HIGH);
98      break;
99    case 1:
100      //1
101
102      digitalWrite(latchPin, LOW);
103      shiftOut(dataPin, clockPin, MSBFIRST,
104  shift * 8  >> 8 );
105      shiftOut(dataPin, clockPin, MSBFIRST, 0B01111001);
106
107      digitalWrite(latchPin, HIGH);
108      break;
109    case 2:
110      //2
111
112      digitalWrite(latchPin, LOW);
113      shiftOut(dataPin, clockPin, MSBFIRST,
114  shift * 8  >> 8 );
115      shiftOut(dataPin, clockPin, MSBFIRST, 0B00100100);
116
117      digitalWrite(latchPin, HIGH);
118      break;
119    case 3:
120      //3
121
122      digitalWrite(latchPin, LOW);
123      shiftOut(dataPin, clockPin, MSBFIRST,
124  shift * 8 >> 8 );
125      shiftOut(dataPin, clockPin, MSBFIRST, 0B00110000);
126
127      digitalWrite(latchPin, HIGH);
128      break;
129    case 4:
130      //4
131
132      digitalWrite(latchPin, LOW);
133      shiftOut(dataPin, clockPin, MSBFIRST,
134  shift * 8 >> 8 );
135      shiftOut(dataPin, clockPin, MSBFIRST, 0B00011001);
136
137      digitalWrite(latchPin, HIGH);
138      break;
139    case 5:
140      //5
141
142      digitalWrite(latchPin, LOW);
143      shiftOut(dataPin, clockPin, MSBFIRST,
144  shift * 8 >> 8 );
145      shiftOut(dataPin, clockPin, MSBFIRST, 0B00010010);
146
147      digitalWrite(latchPin, HIGH);
148      break;
149    case 6:
150      //6
151
152      digitalWrite(latchPin, LOW);
153      shiftOut(dataPin, clockPin, MSBFIRST,
154  shift * 8   >> 8 );
155      shiftOut(dataPin, clockPin, MSBFIRST, 0B00000010);
156
157      digitalWrite(latchPin, HIGH);
158      break;
159    case 7:
160      //7
161
162      digitalWrite(latchPin, LOW);
163      shiftOut(dataPin, clockPin, MSBFIRST,
164  shift * 8  >> 8 );
165      shiftOut(dataPin, clockPin, MSBFIRST, 0B01111000);
166
167      digitalWrite(latchPin, HIGH);
168      break;
169    case 8:
170      //8
171
172      digitalWrite(latchPin, LOW);
173      shiftOut(dataPin, clockPin, MSBFIRST,
174  shift * 8  >> 8 );
175      shiftOut(dataPin, clockPin, MSBFIRST, 0B00000000);
176
177      digitalWrite(latchPin, HIGH);
178      break;
179    case 9:
180      //9
181
182      digitalWrite(latchPin, LOW);
183      shiftOut(dataPin, clockPin, MSBFIRST,
184  shift * 8  >> 8 );
185      shiftOut(dataPin, clockPin, MSBFIRST, 0B00010000);
186
187      digitalWrite(latchPin, HIGH);
188      break;
189  }
190  delay(times);
191
192
193
194  switch (thousands)
195  {
196    case 0:
197      //0
198      digitalWrite(latchPin,
199  LOW);
200      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4  >> 8 );
201      shiftOut(dataPin,
202  clockPin, MSBFIRST, shift * 4 + 192 );
203      digitalWrite(latchPin, HIGH);
204
205      break;
206    case 1:
207      //1
208      digitalWrite(latchPin, LOW);
209
210      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4   >> 8 );
211      shiftOut(dataPin,
212  clockPin, MSBFIRST, shift * 4 + 249);
213      digitalWrite(latchPin, HIGH);
214
215      break;
216    case 2:
217      //2
218      digitalWrite(latchPin, LOW);
219
220      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4   >> 8 );
221      shiftOut(dataPin,
222  clockPin, MSBFIRST, shift * 4 + 164);
223      digitalWrite(latchPin, HIGH);
224
225      break;
226    case 3:
227      //3
228      digitalWrite(latchPin, LOW);
229
230      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4   >> 8 );
231      shiftOut(dataPin,
232  clockPin, MSBFIRST, shift * 4 + 176);
233      digitalWrite(latchPin, HIGH);
234
235      break;
236    case 4:
237      //4
238      digitalWrite(latchPin, LOW);
239
240      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4 >> 8 );
241      shiftOut(dataPin,
242  clockPin, MSBFIRST, shift * 4 + 153);
243      digitalWrite(latchPin, HIGH);
244
245      break;
246    case 5:
247      //5
248      digitalWrite(latchPin, LOW);
249
250      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4   >> 8 );
251      shiftOut(dataPin,
252  clockPin, MSBFIRST, shift * 4 + 146);
253      digitalWrite(latchPin, HIGH);
254
255      break;
256    
257  }
258  delay(times);
259
260  switch (tenthousand)
261
262  {
263    case 0:
264      //0
265      digitalWrite(latchPin, LOW);
266      shiftOut(dataPin,
267  clockPin, MSBFIRST, shift * 2  >> 8 );
268      shiftOut(dataPin, clockPin, MSBFIRST,
269  shift * 2 + 64 );
270      digitalWrite(latchPin, HIGH);
271      break;
272    case
273  1:
274      //1
275      digitalWrite(latchPin, LOW);
276      shiftOut(dataPin,
277  clockPin, MSBFIRST, shift * 2  >> 8 );
278      shiftOut(dataPin, clockPin, MSBFIRST,
279  shift * 2 + 121);
280      digitalWrite(latchPin, HIGH);
281
282      break;
283
284    case 2:
285      //2
286      digitalWrite(latchPin, LOW);
287      shiftOut(dataPin,
288  clockPin, MSBFIRST, shift * 2  >> 8 );
289      shiftOut(dataPin, clockPin, MSBFIRST,
290  shift * 2 + 36);
291      digitalWrite(latchPin, HIGH);
292      break;
293    case
294  3:
295      //3
296      digitalWrite(latchPin, LOW);
297      shiftOut(dataPin,
298  clockPin, MSBFIRST, shift * 2 >> 8 );
299      shiftOut(dataPin, clockPin, MSBFIRST,
300  shift * 2 + 48);
301      digitalWrite(latchPin, HIGH);
302      break;
303    case
304  4:
305      //4
306      digitalWrite(latchPin, LOW);
307      shiftOut(dataPin,
308  clockPin, MSBFIRST, shift * 2 >> 8 );
309      shiftOut(dataPin, clockPin, MSBFIRST,
310  shift * 2 + 25);
311      digitalWrite(latchPin, HIGH);
312      break;
313    case
314  5:
315      //5
316      digitalWrite(latchPin, LOW);
317      shiftOut(dataPin,
318  clockPin, MSBFIRST, shift * 2   >> 8 );
319      shiftOut(dataPin, clockPin, MSBFIRST,
320  shift * 2 + 18);
321      digitalWrite(latchPin, HIGH);
322      break;
323    case
324  6:
325      //6
326      digitalWrite(latchPin, LOW);
327      shiftOut(dataPin,
328  clockPin, MSBFIRST, shift * 2   >> 8 );
329      shiftOut(dataPin, clockPin, MSBFIRST,
330  shift * 2 + 2);
331      digitalWrite(latchPin, HIGH);
332      break;
333    case
334  7:
335      //7
336      digitalWrite(latchPin, LOW);
337      shiftOut(dataPin,
338  clockPin, MSBFIRST, shift * 2  >> 8 );
339      shiftOut(dataPin, clockPin, MSBFIRST,
340  shift * 2 + 120);
341      digitalWrite(latchPin, HIGH);
342      break;
343    case
344  8:
345      //8
346      digitalWrite(latchPin, LOW);
347      shiftOut(dataPin,
348  clockPin, MSBFIRST, shift * 2  >> 8 );
349      shiftOut(dataPin, clockPin, MSBFIRST,
350  shift * 2 + 0);
351      digitalWrite(latchPin, HIGH);
352      break;
353    case
354  9:
355      //9
356      digitalWrite(latchPin, LOW);
357      shiftOut(dataPin,
358  clockPin, MSBFIRST, shift * 2  >> 8 );
359      shiftOut(dataPin, clockPin, MSBFIRST,
360  shift * 2 + 16);
361      digitalWrite(latchPin, HIGH);
362      break;
363
364
365  }
366  delay(times);
367 
368  switch (lakh)
369  {
370    case 0:
371      //0
372
373      digitalWrite(latchPin, LOW);
374      shiftOut(dataPin, clockPin, MSBFIRST,
375  shift   >> 8 );
376      shiftOut(dataPin, clockPin, MSBFIRST, shift  + 192 );
377
378      digitalWrite(latchPin, HIGH);
379      //delay(500);
380      break;
381    case
382  1:
383      //1
384      digitalWrite(latchPin, LOW);
385      shiftOut(dataPin,
386  clockPin, MSBFIRST, shift   >> 8 );
387      shiftOut(dataPin, clockPin, MSBFIRST,
388  shift  + 249);
389      digitalWrite(latchPin, HIGH);
390      //delay(500);
391
392      break;
393    case 2:
394      //2
395      digitalWrite(latchPin, LOW);
396
397      shiftOut(dataPin, clockPin, MSBFIRST, shift   >> 8 );
398      shiftOut(dataPin,
399  clockPin, MSBFIRST, shift  + 164);
400      digitalWrite(latchPin, HIGH);
401      //delay(500);
402
403      break;
404    case 3:
405      //3
406      digitalWrite(latchPin, LOW);
407
408      shiftOut(dataPin, clockPin, MSBFIRST, shift  >> 8 );
409      shiftOut(dataPin,
410  clockPin, MSBFIRST, shift  + 176);
411      digitalWrite(latchPin, HIGH);
412      //delay(500);
413
414      break;
415    case 4:
416      //4
417      digitalWrite(latchPin, LOW);
418
419      shiftOut(dataPin, clockPin, MSBFIRST, shift  >> 8 );
420      shiftOut(dataPin,
421  clockPin, MSBFIRST, shift  + 153);
422      digitalWrite(latchPin, HIGH);
423      //delay(500);
424
425      break;
426    case 5:
427      //5
428      digitalWrite(latchPin, LOW);
429
430      shiftOut(dataPin, clockPin, MSBFIRST, shift    >> 8 );
431      shiftOut(dataPin,
432  clockPin, MSBFIRST, shift  + 146);
433      digitalWrite(latchPin, HIGH);
434      //delay(500);
435
436      break;
437    case 6:
438      //6
439      digitalWrite(latchPin, LOW);
440
441      shiftOut(dataPin, clockPin, MSBFIRST, shift    >> 8 );
442      shiftOut(dataPin,
443  clockPin, MSBFIRST, shift  + 130);
444      digitalWrite(latchPin, HIGH);
445      //delay(500);
446
447      break;
448    case 7:
449      //7
450      digitalWrite(latchPin, LOW);
451
452      shiftOut(dataPin, clockPin, MSBFIRST, shift   >> 8 );
453      shiftOut(dataPin,
454  clockPin, MSBFIRST, shift  + 248);
455      digitalWrite(latchPin, HIGH);
456      //delay(500);
457
458      break;
459    case 8:
460      //8
461      digitalWrite(latchPin, LOW);
462
463      shiftOut(dataPin, clockPin, MSBFIRST, shift   >> 8 );
464      shiftOut(dataPin,
465  clockPin, MSBFIRST, shift  + 128);
466      digitalWrite(latchPin, HIGH);
467
468
469      break;
470    case 9:
471      //9
472      digitalWrite(latchPin, LOW);
473
474      shiftOut(dataPin, clockPin, MSBFIRST, shift   >> 8 );
475      shiftOut(dataPin,
476  clockPin, MSBFIRST, shift  + 152);
477      digitalWrite(latchPin, HIGH);
478      break;
479
480  }
481  delay(times);
482  //alarm section
483  
484  switch (units)
485  {
486
487    case 0:
488    {
489       digitalWrite(latchPin, LOW);
490      shiftOut(dataPin,
491  clockPin, MSBFIRST, 0B00100000 );
492      shiftOut(dataPin, clockPin, MSBFIRST,
493  0B11000000);
494      digitalWrite(latchPin, HIGH);
495      break;
496    }
497
498   case 1:
499    {
500       digitalWrite(latchPin, LOW);
501      shiftOut(dataPin,
502  clockPin, MSBFIRST, 0B00100000 );
503      shiftOut(dataPin, clockPin, MSBFIRST,
504  0B11111001);
505      digitalWrite(latchPin, HIGH);
506      break;
507    }
508
509    case 2:
510    {
511       digitalWrite(latchPin, LOW);
512      shiftOut(dataPin,
513  clockPin, MSBFIRST, 0B00100000 );
514      shiftOut(dataPin, clockPin, MSBFIRST,
515  0B10100100);
516      digitalWrite(latchPin, HIGH);
517      break;
518    }
519
520    case 3:
521    {
522       digitalWrite(latchPin, LOW);
523      shiftOut(dataPin,
524  clockPin, MSBFIRST, 0B00100000 );
525      shiftOut(dataPin, clockPin, MSBFIRST,
526  0B10110000);
527      digitalWrite(latchPin, HIGH);
528      break;
529    }
530
531    case 4:
532    {
533       digitalWrite(latchPin, LOW);
534      shiftOut(dataPin,
535  clockPin, MSBFIRST, 0B00100000 );
536      shiftOut(dataPin, clockPin, MSBFIRST,0B10011001
537  );
538      digitalWrite(latchPin, HIGH);
539      break;
540    }
541    case 5:
542
543    {
544       digitalWrite(latchPin, LOW);
545      shiftOut(dataPin, clockPin,
546  MSBFIRST, 0B00100000 );
547      shiftOut(dataPin, clockPin, MSBFIRST, 0B10010010);
548
549      digitalWrite(latchPin, HIGH);
550      break;
551    }
552    case 6:
553
554    {
555       digitalWrite(latchPin, LOW);
556      shiftOut(dataPin, clockPin,
557  MSBFIRST, 0B00100000 );
558      shiftOut(dataPin, clockPin, MSBFIRST, 0B00000010);
559
560      digitalWrite(latchPin, HIGH);
561      break;
562    }
563    case 7:
564
565    {
566       digitalWrite(latchPin, LOW);
567      shiftOut(dataPin, clockPin,
568  MSBFIRST, 0B00100000 );
569      shiftOut(dataPin, clockPin, MSBFIRST, 0B11111000);
570
571      digitalWrite(latchPin, HIGH);
572      break;
573    }
574    case 8:
575
576    {
577       digitalWrite(latchPin, LOW);
578      shiftOut(dataPin, clockPin,
579  MSBFIRST, 0B00100000 );
580      shiftOut(dataPin, clockPin, MSBFIRST, 0B10000000);
581
582      digitalWrite(latchPin, HIGH);
583      break;
584    }
585    case 9:
586
587    {
588       digitalWrite(latchPin, LOW);
589      shiftOut(dataPin, clockPin,
590  MSBFIRST, 0B00100000 );
591      shiftOut(dataPin, clockPin, MSBFIRST, 0B00010000);
592
593      digitalWrite(latchPin, HIGH);
594      break;
595    }
596  }
597  delay(times);
598
599  
600  
601     switch (tens)
602  {
603    case 0:
604    {
605       digitalWrite(latchPin,
606  LOW);
607      shiftOut(dataPin, clockPin, MSBFIRST, 0B00010000 );
608      shiftOut(dataPin,
609  clockPin, MSBFIRST, 0B11000000);
610      digitalWrite(latchPin, HIGH);
611      break;
612
613    }
614   case 1:
615    {
616       digitalWrite(latchPin, LOW);
617      shiftOut(dataPin,
618  clockPin, MSBFIRST, 0B00010000 );
619      shiftOut(dataPin, clockPin, MSBFIRST,
620  0B11111001);
621      digitalWrite(latchPin, HIGH);
622      break;
623    }
624
625    case 2:
626    {
627       digitalWrite(latchPin, LOW);
628      shiftOut(dataPin,
629  clockPin, MSBFIRST, 0B00010000 );
630      shiftOut(dataPin, clockPin, MSBFIRST,
631  0B10100100);
632      digitalWrite(latchPin, HIGH);
633      break;
634    }
635
636    case 3:
637    {
638       digitalWrite(latchPin, LOW);
639      shiftOut(dataPin,
640  clockPin, MSBFIRST, 0B00010000 );
641      shiftOut(dataPin, clockPin, MSBFIRST,
642  0B10110000);
643      digitalWrite(latchPin, HIGH);
644      break;
645    }
646
647    case 4:
648    {
649       digitalWrite(latchPin, LOW);
650      shiftOut(dataPin,
651  clockPin, MSBFIRST, 0B00010000);
652      shiftOut(dataPin, clockPin, MSBFIRST,0B10011001
653  );
654      digitalWrite(latchPin, HIGH);
655      break;
656    }
657    case 5:
658
659    {
660       digitalWrite(latchPin, LOW);
661      shiftOut(dataPin, clockPin,
662  MSBFIRST, 0B00010000 );
663      shiftOut(dataPin, clockPin, MSBFIRST, 0B10010010);
664
665      digitalWrite(latchPin, HIGH);
666      break;
667    }
668    case 6:
669
670    {
671       digitalWrite(latchPin, LOW);
672      shiftOut(dataPin, clockPin,
673  MSBFIRST, 0B00010000 );
674      shiftOut(dataPin, clockPin, MSBFIRST, 0B00000010);
675
676      digitalWrite(latchPin, HIGH);
677      break;
678    }
679    case 7:
680
681    {
682       digitalWrite(latchPin, LOW);
683      shiftOut(dataPin, clockPin,
684  MSBFIRST, 0B00010000 );
685      shiftOut(dataPin, clockPin, MSBFIRST, 0B11111000);
686
687      digitalWrite(latchPin, HIGH);
688      break;
689    }
690    case 8:
691
692    {
693       digitalWrite(latchPin, LOW);
694      shiftOut(dataPin, clockPin,
695  MSBFIRST, 0B00010000 );
696      shiftOut(dataPin, clockPin, MSBFIRST, 0B10000000);
697
698      digitalWrite(latchPin, HIGH);
699      break;
700    }
701    case 9:
702
703    {
704       digitalWrite(latchPin, LOW);
705      shiftOut(dataPin, clockPin,
706  MSBFIRST, 0B00010000 );
707      shiftOut(dataPin, clockPin, MSBFIRST, 0B00010000);
708
709      digitalWrite(latchPin, HIGH);
710      break;
711    }
712  }
713  if (HOUR
714  == alarmHour && MINUT == alarmMinute)
715  {
716    digitalWrite(13, HIGH);
717
718  }
719  else
720  {
721    digitalWrite(13, LOW);
722  }
723
724}

#include <Wire.h>
#include <RTClib.h>

RTC_DS1307 RTC;

int
  HOUR, MINUT, SECOND;
int latchPin = 4; //pin 12 on the 595 o3 3
int dataPin
  = 2; //pin 14 on the 595 or 4
int clockPin = 3; //pin 11 on the 595 or 2
int
  shift = 256;
int units, tens, hundreds, thousands,tenthousand,lakh;
int times
  = 1;
const int alarmHour = 17;
const int alarmMinute = 26;

void setup()
  {
  Serial.begin(9600);
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin,
  OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(13, OUTPUT);
  Wire.begin();

  RTC.begin();
  if (!RTC.isrunning())
  {
    RTC.adjust(DateTime(__DATE__,
  __TIME__));
  }
}

void loop() {
  
  DateTime now = RTC.now();

  HOUR = now.hour();
  MINUT = now.minute();
  SECOND = now.second();

  //Serial.println(MINUT);
  if (HOUR < 10)
  {
    tenthousand = HOUR;

    lakh  = HOUR/10;
  }
  else if (HOUR >=  10 && HOUR < 24)
  {
    tenthousand
  = HOUR % 10;
    lakh = HOUR / 10;
  }
  if (MINUT <= 9)
  {
    hundreds
  = MINUT;
    thousands = MINUT/10;
  }

  else if (MINUT > 9 && MINUT
  <= 60)
  {
    hundreds = MINUT % 10;
    thousands = MINUT / 10;
  }

   if (SECOND <= 9)
  {
    units = SECOND;
    tens = SECOND/10;
  }


  else if (SECOND > 9 && SECOND <= 60)
  {
    units = SECOND % 10;
    tens
  = SECOND / 10;
  }

  switch (hundreds)
  {
    case 0:
      //0

      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift * 8  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B01000000 );

      digitalWrite(latchPin, HIGH);
      break;
    case 1:
      //1

      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift * 8  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B01111001);

      digitalWrite(latchPin, HIGH);
      break;
    case 2:
      //2

      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift * 8  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00100100);

      digitalWrite(latchPin, HIGH);
      break;
    case 3:
      //3

      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift * 8 >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00110000);

      digitalWrite(latchPin, HIGH);
      break;
    case 4:
      //4

      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift * 8 >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00011001);

      digitalWrite(latchPin, HIGH);
      break;
    case 5:
      //5

      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift * 8 >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00010010);

      digitalWrite(latchPin, HIGH);
      break;
    case 6:
      //6

      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift * 8   >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00000010);

      digitalWrite(latchPin, HIGH);
      break;
    case 7:
      //7

      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift * 8  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B01111000);

      digitalWrite(latchPin, HIGH);
      break;
    case 8:
      //8

      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift * 8  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00000000);

      digitalWrite(latchPin, HIGH);
      break;
    case 9:
      //9

      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift * 8  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00010000);

      digitalWrite(latchPin, HIGH);
      break;
  }
  delay(times);



  switch (thousands)
  {
    case 0:
      //0
      digitalWrite(latchPin,
  LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4  >> 8 );
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift * 4 + 192 );
      digitalWrite(latchPin, HIGH);

      break;
    case 1:
      //1
      digitalWrite(latchPin, LOW);

      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4   >> 8 );
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift * 4 + 249);
      digitalWrite(latchPin, HIGH);

      break;
    case 2:
      //2
      digitalWrite(latchPin, LOW);

      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4   >> 8 );
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift * 4 + 164);
      digitalWrite(latchPin, HIGH);

      break;
    case 3:
      //3
      digitalWrite(latchPin, LOW);

      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4   >> 8 );
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift * 4 + 176);
      digitalWrite(latchPin, HIGH);

      break;
    case 4:
      //4
      digitalWrite(latchPin, LOW);

      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4 >> 8 );
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift * 4 + 153);
      digitalWrite(latchPin, HIGH);

      break;
    case 5:
      //5
      digitalWrite(latchPin, LOW);

      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4   >> 8 );
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift * 4 + 146);
      digitalWrite(latchPin, HIGH);

      break;
    
  }
  delay(times);

  switch (tenthousand)

  {
    case 0:
      //0
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift * 2  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift * 2 + 64 );
      digitalWrite(latchPin, HIGH);
      break;
    case
  1:
      //1
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift * 2  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift * 2 + 121);
      digitalWrite(latchPin, HIGH);

      break;

    case 2:
      //2
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift * 2  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift * 2 + 36);
      digitalWrite(latchPin, HIGH);
      break;
    case
  3:
      //3
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift * 2 >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift * 2 + 48);
      digitalWrite(latchPin, HIGH);
      break;
    case
  4:
      //4
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift * 2 >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift * 2 + 25);
      digitalWrite(latchPin, HIGH);
      break;
    case
  5:
      //5
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift * 2   >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift * 2 + 18);
      digitalWrite(latchPin, HIGH);
      break;
    case
  6:
      //6
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift * 2   >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift * 2 + 2);
      digitalWrite(latchPin, HIGH);
      break;
    case
  7:
      //7
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift * 2  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift * 2 + 120);
      digitalWrite(latchPin, HIGH);
      break;
    case
  8:
      //8
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift * 2  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift * 2 + 0);
      digitalWrite(latchPin, HIGH);
      break;
    case
  9:
      //9
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift * 2  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift * 2 + 16);
      digitalWrite(latchPin, HIGH);
      break;


  }
  delay(times);
 
  switch (lakh)
  {
    case 0:
      //0

      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift   >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, shift  + 192 );

      digitalWrite(latchPin, HIGH);
      //delay(500);
      break;
    case
  1:
      //1
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift   >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,
  shift  + 249);
      digitalWrite(latchPin, HIGH);
      //delay(500);

      break;
    case 2:
      //2
      digitalWrite(latchPin, LOW);

      shiftOut(dataPin, clockPin, MSBFIRST, shift   >> 8 );
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift  + 164);
      digitalWrite(latchPin, HIGH);
      //delay(500);

      break;
    case 3:
      //3
      digitalWrite(latchPin, LOW);

      shiftOut(dataPin, clockPin, MSBFIRST, shift  >> 8 );
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift  + 176);
      digitalWrite(latchPin, HIGH);
      //delay(500);

      break;
    case 4:
      //4
      digitalWrite(latchPin, LOW);

      shiftOut(dataPin, clockPin, MSBFIRST, shift  >> 8 );
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift  + 153);
      digitalWrite(latchPin, HIGH);
      //delay(500);

      break;
    case 5:
      //5
      digitalWrite(latchPin, LOW);

      shiftOut(dataPin, clockPin, MSBFIRST, shift    >> 8 );
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift  + 146);
      digitalWrite(latchPin, HIGH);
      //delay(500);

      break;
    case 6:
      //6
      digitalWrite(latchPin, LOW);

      shiftOut(dataPin, clockPin, MSBFIRST, shift    >> 8 );
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift  + 130);
      digitalWrite(latchPin, HIGH);
      //delay(500);

      break;
    case 7:
      //7
      digitalWrite(latchPin, LOW);

      shiftOut(dataPin, clockPin, MSBFIRST, shift   >> 8 );
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift  + 248);
      digitalWrite(latchPin, HIGH);
      //delay(500);

      break;
    case 8:
      //8
      digitalWrite(latchPin, LOW);

      shiftOut(dataPin, clockPin, MSBFIRST, shift   >> 8 );
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift  + 128);
      digitalWrite(latchPin, HIGH);


      break;
    case 9:
      //9
      digitalWrite(latchPin, LOW);

      shiftOut(dataPin, clockPin, MSBFIRST, shift   >> 8 );
      shiftOut(dataPin,
  clockPin, MSBFIRST, shift  + 152);
      digitalWrite(latchPin, HIGH);
      break;

  }
  delay(times);
  //alarm section
  
  switch (units)
  {

    case 0:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin,
  clockPin, MSBFIRST, 0B00100000 );
      shiftOut(dataPin, clockPin, MSBFIRST,
  0B11000000);
      digitalWrite(latchPin, HIGH);
      break;
    }

   case 1:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin,
  clockPin, MSBFIRST, 0B00100000 );
      shiftOut(dataPin, clockPin, MSBFIRST,
  0B11111001);
      digitalWrite(latchPin, HIGH);
      break;
    }

    case 2:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin,
  clockPin, MSBFIRST, 0B00100000 );
      shiftOut(dataPin, clockPin, MSBFIRST,
  0B10100100);
      digitalWrite(latchPin, HIGH);
      break;
    }

    case 3:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin,
  clockPin, MSBFIRST, 0B00100000 );
      shiftOut(dataPin, clockPin, MSBFIRST,
  0B10110000);
      digitalWrite(latchPin, HIGH);
      break;
    }

    case 4:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin,
  clockPin, MSBFIRST, 0B00100000 );
      shiftOut(dataPin, clockPin, MSBFIRST,0B10011001
  );
      digitalWrite(latchPin, HIGH);
      break;
    }
    case 5:

    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin,
  MSBFIRST, 0B00100000 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B10010010);

      digitalWrite(latchPin, HIGH);
      break;
    }
    case 6:

    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin,
  MSBFIRST, 0B00100000 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00000010);

      digitalWrite(latchPin, HIGH);
      break;
    }
    case 7:

    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin,
  MSBFIRST, 0B00100000 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B11111000);

      digitalWrite(latchPin, HIGH);
      break;
    }
    case 8:

    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin,
  MSBFIRST, 0B00100000 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B10000000);

      digitalWrite(latchPin, HIGH);
      break;
    }
    case 9:

    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin,
  MSBFIRST, 0B00100000 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00010000);

      digitalWrite(latchPin, HIGH);
      break;
    }
  }
  delay(times);

  
  
     switch (tens)
  {
    case 0:
    {
       digitalWrite(latchPin,
  LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00010000 );
      shiftOut(dataPin,
  clockPin, MSBFIRST, 0B11000000);
      digitalWrite(latchPin, HIGH);
      break;

    }
   case 1:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin,
  clockPin, MSBFIRST, 0B00010000 );
      shiftOut(dataPin, clockPin, MSBFIRST,
  0B11111001);
      digitalWrite(latchPin, HIGH);
      break;
    }

    case 2:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin,
  clockPin, MSBFIRST, 0B00010000 );
      shiftOut(dataPin, clockPin, MSBFIRST,
  0B10100100);
      digitalWrite(latchPin, HIGH);
      break;
    }

    case 3:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin,
  clockPin, MSBFIRST, 0B00010000 );
      shiftOut(dataPin, clockPin, MSBFIRST,
  0B10110000);
      digitalWrite(latchPin, HIGH);
      break;
    }

    case 4:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin,
  clockPin, MSBFIRST, 0B00010000);
      shiftOut(dataPin, clockPin, MSBFIRST,0B10011001
  );
      digitalWrite(latchPin, HIGH);
      break;
    }
    case 5:

    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin,
  MSBFIRST, 0B00010000 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B10010010);

      digitalWrite(latchPin, HIGH);
      break;
    }
    case 6:

    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin,
  MSBFIRST, 0B00010000 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00000010);

      digitalWrite(latchPin, HIGH);
      break;
    }
    case 7:

    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin,
  MSBFIRST, 0B00010000 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B11111000);

      digitalWrite(latchPin, HIGH);
      break;
    }
    case 8:

    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin,
  MSBFIRST, 0B00010000 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B10000000);

      digitalWrite(latchPin, HIGH);
      break;
    }
    case 9:

    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin,
  MSBFIRST, 0B00010000 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00010000);

      digitalWrite(latchPin, HIGH);
      break;
    }
  }
  if (HOUR
  == alarmHour && MINUT == alarmMinute)
  {
    digitalWrite(13, HIGH);

  }
  else
  {
    digitalWrite(13, LOW);
  }

}

Arduino 7segment clock code

c_cpp

copy it and paste on your arduino ide editor

1#include <Wire.h>
2#include <RTClib.h>
3
4RTC_DS1307 RTC;
5
6int  HOUR, MINUT, SECOND;
7int latchPin = 4; //pin 12 on the 595 o3 3
8int dataPin  = 2; //pin 14 on the 595 or 4
9int clockPin = 3; //pin 11 on the 595 or 2
10int  shift = 256;
11int units, tens, hundreds, thousands,tenthousand,lakh;
12int times  = 1;
13const int alarmHour = 17;
14const int alarmMinute = 26;
15
16void setup()  {
17  Serial.begin(9600);
18  pinMode(latchPin, OUTPUT);
19  pinMode(dataPin,  OUTPUT);
20  pinMode(clockPin, OUTPUT);
21  pinMode(13, OUTPUT);
22  Wire.begin();
23  RTC.begin();
24  if (!RTC.isrunning())
25  {
26    RTC.adjust(DateTime(__DATE__,  __TIME__));
27  }
28}
29
30void loop() {
31  
32  DateTime now = RTC.now();
33  HOUR = now.hour();
34  MINUT = now.minute();
35  SECOND = now.second();
36  //Serial.println(MINUT);
37  if (HOUR < 10)
38  {
39    tenthousand = HOUR;
40    lakh  = HOUR/10;
41  }
42  else if (HOUR >=  10 && HOUR < 24)
43  {
44    tenthousand  = HOUR % 10;
45    lakh = HOUR / 10;
46  }
47  if (MINUT <= 9)
48  {
49    hundreds  = MINUT;
50    thousands = MINUT/10;
51  }
52
53  else if (MINUT > 9 && MINUT  <= 60)
54  {
55    hundreds = MINUT % 10;
56    thousands = MINUT / 10;
57  }
58   if (SECOND <= 9)
59  {
60    units = SECOND;
61    tens = SECOND/10;
62  }
63
64  else if (SECOND > 9 && SECOND <= 60)
65  {
66    units = SECOND % 10;
67    tens  = SECOND / 10;
68  }
69
70  switch (hundreds)
71  {
72    case 0:
73      //0
74      digitalWrite(latchPin, LOW);
75      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 8  >> 8 );
76      shiftOut(dataPin, clockPin, MSBFIRST, 0B01000000 );
77      digitalWrite(latchPin, HIGH);
78      break;
79    case 1:
80      //1
81      digitalWrite(latchPin, LOW);
82      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 8  >> 8 );
83      shiftOut(dataPin, clockPin, MSBFIRST, 0B01111001);
84      digitalWrite(latchPin, HIGH);
85      break;
86    case 2:
87      //2
88      digitalWrite(latchPin, LOW);
89      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 8  >> 8 );
90      shiftOut(dataPin, clockPin, MSBFIRST, 0B00100100);
91      digitalWrite(latchPin, HIGH);
92      break;
93    case 3:
94      //3
95      digitalWrite(latchPin, LOW);
96      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 8 >> 8 );
97      shiftOut(dataPin, clockPin, MSBFIRST, 0B00110000);
98      digitalWrite(latchPin, HIGH);
99      break;
100    case 4:
101      //4
102      digitalWrite(latchPin, LOW);
103      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 8 >> 8 );
104      shiftOut(dataPin, clockPin, MSBFIRST, 0B00011001);
105      digitalWrite(latchPin, HIGH);
106      break;
107    case 5:
108      //5
109      digitalWrite(latchPin, LOW);
110      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 8 >> 8 );
111      shiftOut(dataPin, clockPin, MSBFIRST, 0B00010010);
112      digitalWrite(latchPin, HIGH);
113      break;
114    case 6:
115      //6
116      digitalWrite(latchPin, LOW);
117      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 8   >> 8 );
118      shiftOut(dataPin, clockPin, MSBFIRST, 0B00000010);
119      digitalWrite(latchPin, HIGH);
120      break;
121    case 7:
122      //7
123      digitalWrite(latchPin, LOW);
124      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 8  >> 8 );
125      shiftOut(dataPin, clockPin, MSBFIRST, 0B01111000);
126      digitalWrite(latchPin, HIGH);
127      break;
128    case 8:
129      //8
130      digitalWrite(latchPin, LOW);
131      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 8  >> 8 );
132      shiftOut(dataPin, clockPin, MSBFIRST, 0B00000000);
133      digitalWrite(latchPin, HIGH);
134      break;
135    case 9:
136      //9
137      digitalWrite(latchPin, LOW);
138      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 8  >> 8 );
139      shiftOut(dataPin, clockPin, MSBFIRST, 0B00010000);
140      digitalWrite(latchPin, HIGH);
141      break;
142  }
143  delay(times);
144
145
146  switch (thousands)
147  {
148    case 0:
149      //0
150      digitalWrite(latchPin,  LOW);
151      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4  >> 8 );
152      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 4 + 192 );
153      digitalWrite(latchPin, HIGH);
154      break;
155    case 1:
156      //1
157      digitalWrite(latchPin, LOW);
158      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4   >> 8 );
159      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 4 + 249);
160      digitalWrite(latchPin, HIGH);
161      break;
162    case 2:
163      //2
164      digitalWrite(latchPin, LOW);
165      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4   >> 8 );
166      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 4 + 164);
167      digitalWrite(latchPin, HIGH);
168      break;
169    case 3:
170      //3
171      digitalWrite(latchPin, LOW);
172      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4   >> 8 );
173      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 4 + 176);
174      digitalWrite(latchPin, HIGH);
175      break;
176    case 4:
177      //4
178      digitalWrite(latchPin, LOW);
179      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4 >> 8 );
180      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 4 + 153);
181      digitalWrite(latchPin, HIGH);
182      break;
183    case 5:
184      //5
185      digitalWrite(latchPin, LOW);
186      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4   >> 8 );
187      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 4 + 146);
188      digitalWrite(latchPin, HIGH);
189      break;
190    
191  }
192  delay(times);
193
194  switch (tenthousand)
195  {
196    case 0:
197      //0
198      digitalWrite(latchPin, LOW);
199      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 2  >> 8 );
200      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 2 + 64 );
201      digitalWrite(latchPin, HIGH);
202      break;
203    case  1:
204      //1
205      digitalWrite(latchPin, LOW);
206      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 2  >> 8 );
207      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 2 + 121);
208      digitalWrite(latchPin, HIGH);
209
210      break;
211    case 2:
212      //2
213      digitalWrite(latchPin, LOW);
214      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 2  >> 8 );
215      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 2 + 36);
216      digitalWrite(latchPin, HIGH);
217      break;
218    case  3:
219      //3
220      digitalWrite(latchPin, LOW);
221      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 2 >> 8 );
222      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 2 + 48);
223      digitalWrite(latchPin, HIGH);
224      break;
225    case  4:
226      //4
227      digitalWrite(latchPin, LOW);
228      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 2 >> 8 );
229      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 2 + 25);
230      digitalWrite(latchPin, HIGH);
231      break;
232    case  5:
233      //5
234      digitalWrite(latchPin, LOW);
235      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 2   >> 8 );
236      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 2 + 18);
237      digitalWrite(latchPin, HIGH);
238      break;
239    case  6:
240      //6
241      digitalWrite(latchPin, LOW);
242      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 2   >> 8 );
243      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 2 + 2);
244      digitalWrite(latchPin, HIGH);
245      break;
246    case  7:
247      //7
248      digitalWrite(latchPin, LOW);
249      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 2  >> 8 );
250      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 2 + 120);
251      digitalWrite(latchPin, HIGH);
252      break;
253    case  8:
254      //8
255      digitalWrite(latchPin, LOW);
256      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 2  >> 8 );
257      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 2 + 0);
258      digitalWrite(latchPin, HIGH);
259      break;
260    case  9:
261      //9
262      digitalWrite(latchPin, LOW);
263      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 2  >> 8 );
264      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 2 + 16);
265      digitalWrite(latchPin, HIGH);
266      break;
267
268  }
269  delay(times);
270 
271  switch (lakh)
272  {
273    case 0:
274      //0
275      digitalWrite(latchPin, LOW);
276      shiftOut(dataPin, clockPin, MSBFIRST,  shift   >> 8 );
277      shiftOut(dataPin, clockPin, MSBFIRST, shift  + 192 );
278      digitalWrite(latchPin, HIGH);
279      //delay(500);
280      break;
281    case  1:
282      //1
283      digitalWrite(latchPin, LOW);
284      shiftOut(dataPin,  clockPin, MSBFIRST, shift   >> 8 );
285      shiftOut(dataPin, clockPin, MSBFIRST,  shift  + 249);
286      digitalWrite(latchPin, HIGH);
287      //delay(500);
288      break;
289    case 2:
290      //2
291      digitalWrite(latchPin, LOW);
292      shiftOut(dataPin, clockPin, MSBFIRST, shift   >> 8 );
293      shiftOut(dataPin,  clockPin, MSBFIRST, shift  + 164);
294      digitalWrite(latchPin, HIGH);
295      //delay(500);
296      break;
297    case 3:
298      //3
299      digitalWrite(latchPin, LOW);
300      shiftOut(dataPin, clockPin, MSBFIRST, shift  >> 8 );
301      shiftOut(dataPin,  clockPin, MSBFIRST, shift  + 176);
302      digitalWrite(latchPin, HIGH);
303      //delay(500);
304      break;
305    case 4:
306      //4
307      digitalWrite(latchPin, LOW);
308      shiftOut(dataPin, clockPin, MSBFIRST, shift  >> 8 );
309      shiftOut(dataPin,  clockPin, MSBFIRST, shift  + 153);
310      digitalWrite(latchPin, HIGH);
311      //delay(500);
312      break;
313    case 5:
314      //5
315      digitalWrite(latchPin, LOW);
316      shiftOut(dataPin, clockPin, MSBFIRST, shift    >> 8 );
317      shiftOut(dataPin,  clockPin, MSBFIRST, shift  + 146);
318      digitalWrite(latchPin, HIGH);
319      //delay(500);
320      break;
321    case 6:
322      //6
323      digitalWrite(latchPin, LOW);
324      shiftOut(dataPin, clockPin, MSBFIRST, shift    >> 8 );
325      shiftOut(dataPin,  clockPin, MSBFIRST, shift  + 130);
326      digitalWrite(latchPin, HIGH);
327      //delay(500);
328      break;
329    case 7:
330      //7
331      digitalWrite(latchPin, LOW);
332      shiftOut(dataPin, clockPin, MSBFIRST, shift   >> 8 );
333      shiftOut(dataPin,  clockPin, MSBFIRST, shift  + 248);
334      digitalWrite(latchPin, HIGH);
335      //delay(500);
336      break;
337    case 8:
338      //8
339      digitalWrite(latchPin, LOW);
340      shiftOut(dataPin, clockPin, MSBFIRST, shift   >> 8 );
341      shiftOut(dataPin,  clockPin, MSBFIRST, shift  + 128);
342      digitalWrite(latchPin, HIGH);
343
344      break;
345    case 9:
346      //9
347      digitalWrite(latchPin, LOW);
348      shiftOut(dataPin, clockPin, MSBFIRST, shift   >> 8 );
349      shiftOut(dataPin,  clockPin, MSBFIRST, shift  + 152);
350      digitalWrite(latchPin, HIGH);
351      break;
352  }
353  delay(times);
354  //alarm section
355  
356  switch (units)
357  {
358    case 0:
359    {
360       digitalWrite(latchPin, LOW);
361      shiftOut(dataPin,  clockPin, MSBFIRST, 0B00100000 );
362      shiftOut(dataPin, clockPin, MSBFIRST,  0B11000000);
363      digitalWrite(latchPin, HIGH);
364      break;
365    }
366   case 1:
367    {
368       digitalWrite(latchPin, LOW);
369      shiftOut(dataPin,  clockPin, MSBFIRST, 0B00100000 );
370      shiftOut(dataPin, clockPin, MSBFIRST,  0B11111001);
371      digitalWrite(latchPin, HIGH);
372      break;
373    }
374    case 2:
375    {
376       digitalWrite(latchPin, LOW);
377      shiftOut(dataPin,  clockPin, MSBFIRST, 0B00100000 );
378      shiftOut(dataPin, clockPin, MSBFIRST,  0B10100100);
379      digitalWrite(latchPin, HIGH);
380      break;
381    }
382    case 3:
383    {
384       digitalWrite(latchPin, LOW);
385      shiftOut(dataPin,  clockPin, MSBFIRST, 0B00100000 );
386      shiftOut(dataPin, clockPin, MSBFIRST,  0B10110000);
387      digitalWrite(latchPin, HIGH);
388      break;
389    }
390    case 4:
391    {
392       digitalWrite(latchPin, LOW);
393      shiftOut(dataPin,  clockPin, MSBFIRST, 0B00100000 );
394      shiftOut(dataPin, clockPin, MSBFIRST,0B10011001  );
395      digitalWrite(latchPin, HIGH);
396      break;
397    }
398    case 5:
399    {
400       digitalWrite(latchPin, LOW);
401      shiftOut(dataPin, clockPin,  MSBFIRST, 0B00100000 );
402      shiftOut(dataPin, clockPin, MSBFIRST, 0B10010010);
403      digitalWrite(latchPin, HIGH);
404      break;
405    }
406    case 6:
407    {
408       digitalWrite(latchPin, LOW);
409      shiftOut(dataPin, clockPin,  MSBFIRST, 0B00100000 );
410      shiftOut(dataPin, clockPin, MSBFIRST, 0B00000010);
411      digitalWrite(latchPin, HIGH);
412      break;
413    }
414    case 7:
415    {
416       digitalWrite(latchPin, LOW);
417      shiftOut(dataPin, clockPin,  MSBFIRST, 0B00100000 );
418      shiftOut(dataPin, clockPin, MSBFIRST, 0B11111000);
419      digitalWrite(latchPin, HIGH);
420      break;
421    }
422    case 8:
423    {
424       digitalWrite(latchPin, LOW);
425      shiftOut(dataPin, clockPin,  MSBFIRST, 0B00100000 );
426      shiftOut(dataPin, clockPin, MSBFIRST, 0B10000000);
427      digitalWrite(latchPin, HIGH);
428      break;
429    }
430    case 9:
431    {
432       digitalWrite(latchPin, LOW);
433      shiftOut(dataPin, clockPin,  MSBFIRST, 0B00100000 );
434      shiftOut(dataPin, clockPin, MSBFIRST, 0B00010000);
435      digitalWrite(latchPin, HIGH);
436      break;
437    }
438  }
439  delay(times);
440  
441  
442     switch (tens)
443  {
444    case 0:
445    {
446       digitalWrite(latchPin,  LOW);
447      shiftOut(dataPin, clockPin, MSBFIRST, 0B00010000 );
448      shiftOut(dataPin,  clockPin, MSBFIRST, 0B11000000);
449      digitalWrite(latchPin, HIGH);
450      break;
451    }
452   case 1:
453    {
454       digitalWrite(latchPin, LOW);
455      shiftOut(dataPin,  clockPin, MSBFIRST, 0B00010000 );
456      shiftOut(dataPin, clockPin, MSBFIRST,  0B11111001);
457      digitalWrite(latchPin, HIGH);
458      break;
459    }
460    case 2:
461    {
462       digitalWrite(latchPin, LOW);
463      shiftOut(dataPin,  clockPin, MSBFIRST, 0B00010000 );
464      shiftOut(dataPin, clockPin, MSBFIRST,  0B10100100);
465      digitalWrite(latchPin, HIGH);
466      break;
467    }
468    case 3:
469    {
470       digitalWrite(latchPin, LOW);
471      shiftOut(dataPin,  clockPin, MSBFIRST, 0B00010000 );
472      shiftOut(dataPin, clockPin, MSBFIRST,  0B10110000);
473      digitalWrite(latchPin, HIGH);
474      break;
475    }
476    case 4:
477    {
478       digitalWrite(latchPin, LOW);
479      shiftOut(dataPin,  clockPin, MSBFIRST, 0B00010000);
480      shiftOut(dataPin, clockPin, MSBFIRST,0B10011001  );
481      digitalWrite(latchPin, HIGH);
482      break;
483    }
484    case 5:
485    {
486       digitalWrite(latchPin, LOW);
487      shiftOut(dataPin, clockPin,  MSBFIRST, 0B00010000 );
488      shiftOut(dataPin, clockPin, MSBFIRST, 0B10010010);
489      digitalWrite(latchPin, HIGH);
490      break;
491    }
492    case 6:
493    {
494       digitalWrite(latchPin, LOW);
495      shiftOut(dataPin, clockPin,  MSBFIRST, 0B00010000 );
496      shiftOut(dataPin, clockPin, MSBFIRST, 0B00000010);
497      digitalWrite(latchPin, HIGH);
498      break;
499    }
500    case 7:
501    {
502       digitalWrite(latchPin, LOW);
503      shiftOut(dataPin, clockPin,  MSBFIRST, 0B00010000 );
504      shiftOut(dataPin, clockPin, MSBFIRST, 0B11111000);
505      digitalWrite(latchPin, HIGH);
506      break;
507    }
508    case 8:
509    {
510       digitalWrite(latchPin, LOW);
511      shiftOut(dataPin, clockPin,  MSBFIRST, 0B00010000 );
512      shiftOut(dataPin, clockPin, MSBFIRST, 0B10000000);
513      digitalWrite(latchPin, HIGH);
514      break;
515    }
516    case 9:
517    {
518       digitalWrite(latchPin, LOW);
519      shiftOut(dataPin, clockPin,  MSBFIRST, 0B00010000 );
520      shiftOut(dataPin, clockPin, MSBFIRST, 0B00010000);
521      digitalWrite(latchPin, HIGH);
522      break;
523    }
524  }
525  if (HOUR  == alarmHour && MINUT == alarmMinute)
526  {
527    digitalWrite(13, HIGH);
528  }
529  else
530  {
531    digitalWrite(13, LOW);
532  }
533
534}

#include <Wire.h>
#include <RTClib.h>

RTC_DS1307 RTC;

int  HOUR, MINUT, SECOND;
int latchPin = 4; //pin 12 on the 595 o3 3
int dataPin  = 2; //pin 14 on the 595 or 4
int clockPin = 3; //pin 11 on the 595 or 2
int  shift = 256;
int units, tens, hundreds, thousands,tenthousand,lakh;
int times  = 1;
const int alarmHour = 17;
const int alarmMinute = 26;

void setup()  {
  Serial.begin(9600);
  pinMode(latchPin, OUTPUT);
  pinMode(dataPin,  OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(13, OUTPUT);
  Wire.begin();
  RTC.begin();
  if (!RTC.isrunning())
  {
    RTC.adjust(DateTime(__DATE__,  __TIME__));
  }
}

void loop() {
  
  DateTime now = RTC.now();
  HOUR = now.hour();
  MINUT = now.minute();
  SECOND = now.second();
  //Serial.println(MINUT);
  if (HOUR < 10)
  {
    tenthousand = HOUR;
    lakh  = HOUR/10;
  }
  else if (HOUR >=  10 && HOUR < 24)
  {
    tenthousand  = HOUR % 10;
    lakh = HOUR / 10;
  }
  if (MINUT <= 9)
  {
    hundreds  = MINUT;
    thousands = MINUT/10;
  }

  else if (MINUT > 9 && MINUT  <= 60)
  {
    hundreds = MINUT % 10;
    thousands = MINUT / 10;
  }
   if (SECOND <= 9)
  {
    units = SECOND;
    tens = SECOND/10;
  }

  else if (SECOND > 9 && SECOND <= 60)
  {
    units = SECOND % 10;
    tens  = SECOND / 10;
  }

  switch (hundreds)
  {
    case 0:
      //0
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 8  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B01000000 );
      digitalWrite(latchPin, HIGH);
      break;
    case 1:
      //1
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 8  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B01111001);
      digitalWrite(latchPin, HIGH);
      break;
    case 2:
      //2
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 8  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00100100);
      digitalWrite(latchPin, HIGH);
      break;
    case 3:
      //3
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 8 >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00110000);
      digitalWrite(latchPin, HIGH);
      break;
    case 4:
      //4
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 8 >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00011001);
      digitalWrite(latchPin, HIGH);
      break;
    case 5:
      //5
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 8 >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00010010);
      digitalWrite(latchPin, HIGH);
      break;
    case 6:
      //6
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 8   >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00000010);
      digitalWrite(latchPin, HIGH);
      break;
    case 7:
      //7
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 8  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B01111000);
      digitalWrite(latchPin, HIGH);
      break;
    case 8:
      //8
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 8  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00000000);
      digitalWrite(latchPin, HIGH);
      break;
    case 9:
      //9
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 8  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00010000);
      digitalWrite(latchPin, HIGH);
      break;
  }
  delay(times);


  switch (thousands)
  {
    case 0:
      //0
      digitalWrite(latchPin,  LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4  >> 8 );
      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 4 + 192 );
      digitalWrite(latchPin, HIGH);
      break;
    case 1:
      //1
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4   >> 8 );
      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 4 + 249);
      digitalWrite(latchPin, HIGH);
      break;
    case 2:
      //2
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4   >> 8 );
      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 4 + 164);
      digitalWrite(latchPin, HIGH);
      break;
    case 3:
      //3
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4   >> 8 );
      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 4 + 176);
      digitalWrite(latchPin, HIGH);
      break;
    case 4:
      //4
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4 >> 8 );
      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 4 + 153);
      digitalWrite(latchPin, HIGH);
      break;
    case 5:
      //5
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, shift * 4   >> 8 );
      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 4 + 146);
      digitalWrite(latchPin, HIGH);
      break;
    
  }
  delay(times);

  switch (tenthousand)
  {
    case 0:
      //0
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 2  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 2 + 64 );
      digitalWrite(latchPin, HIGH);
      break;
    case  1:
      //1
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 2  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 2 + 121);
      digitalWrite(latchPin, HIGH);

      break;
    case 2:
      //2
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 2  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 2 + 36);
      digitalWrite(latchPin, HIGH);
      break;
    case  3:
      //3
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 2 >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 2 + 48);
      digitalWrite(latchPin, HIGH);
      break;
    case  4:
      //4
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 2 >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 2 + 25);
      digitalWrite(latchPin, HIGH);
      break;
    case  5:
      //5
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 2   >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 2 + 18);
      digitalWrite(latchPin, HIGH);
      break;
    case  6:
      //6
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 2   >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 2 + 2);
      digitalWrite(latchPin, HIGH);
      break;
    case  7:
      //7
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 2  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 2 + 120);
      digitalWrite(latchPin, HIGH);
      break;
    case  8:
      //8
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 2  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 2 + 0);
      digitalWrite(latchPin, HIGH);
      break;
    case  9:
      //9
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,  clockPin, MSBFIRST, shift * 2  >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,  shift * 2 + 16);
      digitalWrite(latchPin, HIGH);
      break;

  }
  delay(times);
 
  switch (lakh)
  {
    case 0:
      //0
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST,  shift   >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST, shift  + 192 );
      digitalWrite(latchPin, HIGH);
      //delay(500);
      break;
    case  1:
      //1
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin,  clockPin, MSBFIRST, shift   >> 8 );
      shiftOut(dataPin, clockPin, MSBFIRST,  shift  + 249);
      digitalWrite(latchPin, HIGH);
      //delay(500);
      break;
    case 2:
      //2
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, shift   >> 8 );
      shiftOut(dataPin,  clockPin, MSBFIRST, shift  + 164);
      digitalWrite(latchPin, HIGH);
      //delay(500);
      break;
    case 3:
      //3
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, shift  >> 8 );
      shiftOut(dataPin,  clockPin, MSBFIRST, shift  + 176);
      digitalWrite(latchPin, HIGH);
      //delay(500);
      break;
    case 4:
      //4
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, shift  >> 8 );
      shiftOut(dataPin,  clockPin, MSBFIRST, shift  + 153);
      digitalWrite(latchPin, HIGH);
      //delay(500);
      break;
    case 5:
      //5
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, shift    >> 8 );
      shiftOut(dataPin,  clockPin, MSBFIRST, shift  + 146);
      digitalWrite(latchPin, HIGH);
      //delay(500);
      break;
    case 6:
      //6
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, shift    >> 8 );
      shiftOut(dataPin,  clockPin, MSBFIRST, shift  + 130);
      digitalWrite(latchPin, HIGH);
      //delay(500);
      break;
    case 7:
      //7
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, shift   >> 8 );
      shiftOut(dataPin,  clockPin, MSBFIRST, shift  + 248);
      digitalWrite(latchPin, HIGH);
      //delay(500);
      break;
    case 8:
      //8
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, shift   >> 8 );
      shiftOut(dataPin,  clockPin, MSBFIRST, shift  + 128);
      digitalWrite(latchPin, HIGH);

      break;
    case 9:
      //9
      digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, shift   >> 8 );
      shiftOut(dataPin,  clockPin, MSBFIRST, shift  + 152);
      digitalWrite(latchPin, HIGH);
      break;
  }
  delay(times);
  //alarm section
  
  switch (units)
  {
    case 0:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin,  clockPin, MSBFIRST, 0B00100000 );
      shiftOut(dataPin, clockPin, MSBFIRST,  0B11000000);
      digitalWrite(latchPin, HIGH);
      break;
    }
   case 1:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin,  clockPin, MSBFIRST, 0B00100000 );
      shiftOut(dataPin, clockPin, MSBFIRST,  0B11111001);
      digitalWrite(latchPin, HIGH);
      break;
    }
    case 2:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin,  clockPin, MSBFIRST, 0B00100000 );
      shiftOut(dataPin, clockPin, MSBFIRST,  0B10100100);
      digitalWrite(latchPin, HIGH);
      break;
    }
    case 3:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin,  clockPin, MSBFIRST, 0B00100000 );
      shiftOut(dataPin, clockPin, MSBFIRST,  0B10110000);
      digitalWrite(latchPin, HIGH);
      break;
    }
    case 4:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin,  clockPin, MSBFIRST, 0B00100000 );
      shiftOut(dataPin, clockPin, MSBFIRST,0B10011001  );
      digitalWrite(latchPin, HIGH);
      break;
    }
    case 5:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin,  MSBFIRST, 0B00100000 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B10010010);
      digitalWrite(latchPin, HIGH);
      break;
    }
    case 6:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin,  MSBFIRST, 0B00100000 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00000010);
      digitalWrite(latchPin, HIGH);
      break;
    }
    case 7:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin,  MSBFIRST, 0B00100000 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B11111000);
      digitalWrite(latchPin, HIGH);
      break;
    }
    case 8:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin,  MSBFIRST, 0B00100000 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B10000000);
      digitalWrite(latchPin, HIGH);
      break;
    }
    case 9:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin,  MSBFIRST, 0B00100000 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00010000);
      digitalWrite(latchPin, HIGH);
      break;
    }
  }
  delay(times);
  
  
     switch (tens)
  {
    case 0:
    {
       digitalWrite(latchPin,  LOW);
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00010000 );
      shiftOut(dataPin,  clockPin, MSBFIRST, 0B11000000);
      digitalWrite(latchPin, HIGH);
      break;
    }
   case 1:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin,  clockPin, MSBFIRST, 0B00010000 );
      shiftOut(dataPin, clockPin, MSBFIRST,  0B11111001);
      digitalWrite(latchPin, HIGH);
      break;
    }
    case 2:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin,  clockPin, MSBFIRST, 0B00010000 );
      shiftOut(dataPin, clockPin, MSBFIRST,  0B10100100);
      digitalWrite(latchPin, HIGH);
      break;
    }
    case 3:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin,  clockPin, MSBFIRST, 0B00010000 );
      shiftOut(dataPin, clockPin, MSBFIRST,  0B10110000);
      digitalWrite(latchPin, HIGH);
      break;
    }
    case 4:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin,  clockPin, MSBFIRST, 0B00010000);
      shiftOut(dataPin, clockPin, MSBFIRST,0B10011001  );
      digitalWrite(latchPin, HIGH);
      break;
    }
    case 5:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin,  MSBFIRST, 0B00010000 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B10010010);
      digitalWrite(latchPin, HIGH);
      break;
    }
    case 6:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin,  MSBFIRST, 0B00010000 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00000010);
      digitalWrite(latchPin, HIGH);
      break;
    }
    case 7:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin,  MSBFIRST, 0B00010000 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B11111000);
      digitalWrite(latchPin, HIGH);
      break;
    }
    case 8:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin,  MSBFIRST, 0B00010000 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B10000000);
      digitalWrite(latchPin, HIGH);
      break;
    }
    case 9:
    {
       digitalWrite(latchPin, LOW);
      shiftOut(dataPin, clockPin,  MSBFIRST, 0B00010000 );
      shiftOut(dataPin, clockPin, MSBFIRST, 0B00010000);
      digitalWrite(latchPin, HIGH);
      break;
    }
  }
  if (HOUR  == alarmHour && MINUT == alarmMinute)
  {
    digitalWrite(13, HIGH);
  }
  else
  {
    digitalWrite(13, LOW);
  }

}

Downloadable files

Arduino 7 segment display

pdf

Arduino 7 segment display

Comments

Only logged in users can leave comments

ramjipatel376

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content