Arduino RTC LED Clock

1/*
2 4 digit 7 segment display: http://www.sparkfun.com/products/9483
3  Datasheet: http://www.sparkfun.com/datasheets/Components/LED/7-Segment/YSD-439AR6B-35.pdf
4  */
5// modified connexion by niq_ro from http://nicuflorica.blogspot.com
6//  dataseet: http://www.tme.eu/ro/Document/dfc2efde2e22005fd28615e298ea2655/KW4-563XSA.pdf
7//  Code modified by BMIAK Basnayaka
8// http://www.setnfix.com
9
10int digit1  = 11; 
11int digit2 = 10;
12int digit3 = 9; 
13int digit4 = 6;
14int digit5  = 5; 
15int digit6 = 3; 
16
17//Pin mapping from Arduino to the ATmega DIP28  if you need it
18//http://www.arduino.cc/en/Hacking/PinMapping
19int segA = 0;  //Display pin 11
20int segB = 1; //Display pin 7
21int segC = 2; //Display pin  4
22int segD = 4; //Display pin 2
23int segE = 7; //Display pin 1
24int segF  = 8; //Display pin 10
25int segG = 12; //Display pin 5
26int segDP =13; // Display  pin 3
27
28
29
30#include <Wire.h>
31#include "RTClib.h"
32RTC_DS1307 RTC;
33
34//  Date and time functions using a DS1307 RTC connected via I2C and Wire lib
35//  original sketck from http://learn.adafruit.com/ds1307-real-time-clock-breakout-board-kit/
36//  add part with SQW=1Hz from http://tronixstuff.wordpress.com/2010/10/20/tutorial-arduino-and-the-i2c-bus/
37//  add part with manual adjust http://www.bristolwatch.com/arduino/arduino_ds1307.htm
38
39
40
41byte  SW0 = A0;
42byte SW1 = A2;
43byte SW2 = A1;
44byte SWT = A3;
45int Adhr=0;
46int  Admnt=0;
47int D = 0;
48int Z =0;
49
50// use for hexa in zecimal conversion
51long  zh, uh, ore;
52long zm, um, miniti;
53
54void setup() {
55  
56 //Serial.begin(57600);
57  Wire.begin();
58  RTC.begin();
59 // RTC.adjust(DateTime(F(__DATE__), F(__TIME__)));
60//  if you need set clock... just remove // from line above this
61
62// part code  for flashing LED
63Wire.beginTransmission(0x68);
64Wire.write(0x07); // move pointer  to SQW address
65// Wire.write(0x00); // turns the SQW pin off
66 Wire.write(0x10);  // sends 0x10 (hex) 00010000 (binary) to control register - turns on square wave  at 1Hz
67// Wire.write(0x13); // sends 0x13 (hex) 00010011 (binary) 32kHz
68
69Wire.endTransmission();
70  
71  
72  pinMode(segA, OUTPUT);
73  pinMode(segB, OUTPUT);
74  pinMode(segC,  OUTPUT);
75  pinMode(segD, OUTPUT);
76  pinMode(segE, OUTPUT);
77  pinMode(segF,  OUTPUT);
78  pinMode(segG, OUTPUT);
79  pinMode(segDP, OUTPUT);
80
81  pinMode(digit1,  OUTPUT);
82  pinMode(digit2, OUTPUT);
83  pinMode(digit3, OUTPUT);
84  pinMode(digit4,  OUTPUT);
85  pinMode(digit5, OUTPUT);
86  pinMode(digit6, OUTPUT);
87
88
89//Serial.begin(9600);
90
91pinMode(SW0,  INPUT);  // N.O. push button switch
92pinMode(SW1, INPUT);  // N.O. push button  switch
93pinMode(SW2, INPUT);  // N.O. push button switch
94pinMode(SWT, INPUT);  // N.O. push button switch
95
96digitalWrite(SW0, HIGH); // pull-ups on
97digitalWrite(SW1,  HIGH);
98digitalWrite(SW2, HIGH);
99digitalWrite(segDP, LOW);
100
101
102}
103
104
105void  loop() {
106
107  DateTime now = RTC.now();
108  long HR = now.hour()*1000;
109  long timp = (HR*10)+now.minute()*100+now.second();
110  Adhr = now.hour();
111  Admnt=now.minute();
112
113
114
115int DIM = 0;
116if (timp >=250000)
117timp=timp-240000;
118//------------------------------------------------------
119//12/24  hours shitching 
120//------------------------------------------------------
121if  (timp < 130000){
122digitalWrite(segDP, LOW);}
123
124
125if (digitalRead(SWT)==0){delay(300);
126  if (D == 0) {
127 D =1;delay(200);}
128 
129else{
130D =0;}
131}
132
133
134
135
136if  (D == 0){  
137if (timp>=130000){
138timp=timp-120000;
139digitalWrite(segDP, HIGH);}
140}
141
142if  (timp>=130000){ 
143digitalWrite(segDP, LOW);
144}
145
146if ((D==1)& (timp <130000))
147digitalWrite(segDP,  LOW);
148
149
150
151
152
153//------------------------------------------------------
154
155
156  
157
158
159
160//int timp = (now.minute(), DEC);
161//   displayNumber(12); //  this is number to diplay
162
163
164     
165    for(int i = 100 ; i >0  ; i--)  {
166     if (timp >= 100000) displayNumber01(timp); 
167     else displayNumber02(timp);  
168   } 
169
170   for(int i = 100 ; i >0  ; i--) {
171     if (timp >= 100000)  displayNumber03(timp); 
172     else displayNumber04(timp); 
173   } 
174
175   for(int  i = 100 ; i >0  ; i--) {
176     if (timp >= 100000) displayNumber05(timp); 
177     else displayNumber06(timp); 
178   } 
179
180
181  
182
183if (digitalRead(SW0)==0){delay(100);Z=1;  set_time(); }// hold the switch to set time
184}
185
186void set_time()   {
187  byte minutes1 = 0;
188  byte hours1 = 0;
189  byte minutes = 0;
190  byte hours  = 0;
191  hours=Adhr;
192  minutes=Admnt;
193
194
195    if ((hours & 0x0f) > 9)  hours =  hours + 6;
196      if (hours > 0x24) hours = 1; // Mid night 12.00 will  show as 12:00 (With PM LED on) or 24:00
197        //if (hours > 0x24) hours = 1;  // Mid night 12.00 will show as 0:00
198        if ((minutes & 0x0f) > 9) minutes  = minutes + 6;
199      if (minutes > 0x59) minutes = 0;
200      
201while (!(Z==0)){  // set time switch must be released to exit
202
203
204 
205
206
207    
208   int  TST = digitalRead(SW2);
209    while (TST==0) // set hours
210    { 
211     hours++;          
212     
213   // converting hexa in zecimal:
214    zh = hours / 16;
215    uh = hours - 16 * zh ;
216    ore = 10 * zh + uh; 
217    zm = minutes / 16;
218    um = minutes - 16 * zm ;
219    miniti = 10 * zm + um; 
220    
221   
222   
223      
224      if ((hours & 0x0f) > 9) hours =  hours + 6;
225            if (hours  > 0x24) hours = 1; // Mid night 12.00 will show as 12:00 (With PM LED on) or 24:00
226        //if (hours > 0x24) hours = 1; // Mid night 12.00 will show as 0:00
227        if (hours <= 9) 
228    delay(1);
229    
230      for(int i = 400 ; i >0  ; i--) {
231     displayNumber01(ore*10000+miniti*100); 
232     }
233    
234    TST = digitalRead(SW2);
235    }
236
237   while (!(digitalRead(SW1))) // set  minutes
238    { 
239     minutes++;  
240   // converting hexa in zecimal:
241    zh = hours / 16;
242    uh = hours - 16 * zh ;
243    ore = 10 * zh + uh; 
244    zm = minutes / 16;
245    um = minutes - 16 * zm ;
246    miniti = 10 * zm +  um; 
247    
248     for(int i = 400 ; i >0  ; i--) {
249     displayNumber01(ore*10000+miniti*100);  
250     }
251
252      if ((minutes & 0x0f) > 9) minutes = minutes + 6;
253      if  (minutes > 0x59) minutes = 0;
254      if (minutes >= 9) 
255    delay(1);    
256    }
257
258    Wire.beginTransmission(0x68); // activate DS1307
259    Wire.write(0);  // where to begin
260    Wire.write(0x00);          //seconds
261    Wire.write(minutes);          //minutes
262    Wire.write(0x80 | hours);    //hours (24hr time)
263    Wire.write(0x06);  // Day 01-07
264    Wire.write(0x01);  // Date 0-31
265    Wire.write(0x05);  // month 0-12
266    Wire.write(0x09);  // Year 00-99
267    Wire.write(0x10);  // Control 0x10 produces a 1 HZ square wave on pin 7. 
268    Wire.endTransmission();
269  
270    // converting hexa in zecimal:
271    zh = hours / 16;
272    uh = hours  - 16 * zh ;
273    ore = 10 * zh + uh; 
274    zm = minutes / 16;
275    um = minutes  - 16 * zm ;
276    miniti = 10 * zm + um; 
277
278 
279    
280    for(int i = 400  ; i >0  ; i--) {
281     displayNumber01(ore*10000+miniti*100); 
282     }
283delay(100);  
284//Serial.print(digitalRead(SW0));
285if (digitalRead(SW0)==0) Z = 0;
286 delay(300);   
287  }
288//Serial.print(SW2);
289}
290
291
292
293void displayNumber01(long  toDisplay) {
294#define DISPLAY_BRIGHTNESS  25
295
296#define DIGIT_ON  HIGH
297#define  DIGIT_OFF  LOW
298
299  for(int digit = 6 ; digit > 0 ; digit--) {
300
301    //Turn  on a digit for a short amount of time
302    switch(digit) {
303    case 1:
304     digitalWrite(digit1, DIGIT_ON);
305     
306      break;
307   case 2:
308      digitalWrite(digit2, DIGIT_ON);
309      //digitalWrite(segDP, LOW);
310      break;
311    case 3:
312      digitalWrite(digit3, DIGIT_ON);
313      
314      break;
315    case 4:
316      digitalWrite(digit4, DIGIT_ON);
317      
318      break;
319    case 5:
320      digitalWrite(digit5, DIGIT_ON);
321      
322      break;
323    case 6:
324      digitalWrite(digit6, DIGIT_ON);
325      
326      break;
327      
328    }
329    lightNumber(toDisplay % 10);
330    toDisplay /= 10;
331    delayMicroseconds(DISPLAY_BRIGHTNESS); 
332
333
334     //Turn off all segments
335    lightNumber(10); 
336
337    //Turn off all digits
338    digitalWrite(digit1,  DIGIT_OFF);
339    digitalWrite(digit2, DIGIT_OFF);
340    digitalWrite(digit3,  DIGIT_OFF);
341    digitalWrite(digit4, DIGIT_OFF);
342    digitalWrite(digit5,  DIGIT_OFF);
343    digitalWrite(digit6, DIGIT_OFF);
344}
345} 
346
347void displayNumber02(long  toDisplay) {
348#define DISPLAY_BRIGHTNESS  25
349
350#define DIGIT_ON  HIGH
351#define  DIGIT_OFF  LOW
352
353  for(int digit = 6 ; digit > 0 ; digit--) {
354
355    //Turn  on a digit for a short amount of time
356    switch(digit) {
357    case 1:
358     lightNumber(10); 
359     
360     break;
361   case 2:
362      digitalWrite(digit2,  DIGIT_ON);
363      //digitalWrite(segDP, LOW);
364      break;
365    case 3:
366      digitalWrite(digit3, DIGIT_ON);
367      
368      break;
369    case 4:
370      digitalWrite(digit4, DIGIT_ON);
371      
372      break;
373     case 5:
374      digitalWrite(digit5, DIGIT_ON);
375      
376      break;
377    case 6:
378      digitalWrite(digit6, DIGIT_ON);
379      
380      break;
381    }
382    lightNumber(toDisplay  % 10);
383    toDisplay /= 10;
384    delayMicroseconds(DISPLAY_BRIGHTNESS); 
385
386     //Turn off all segments
387    lightNumber(10); 
388
389    //Turn off all  digits
390    digitalWrite(digit1, DIGIT_OFF);
391    digitalWrite(digit2, DIGIT_OFF);
392    digitalWrite(digit3, DIGIT_OFF);
393    digitalWrite(digit4, DIGIT_OFF);
394    digitalWrite(digit5, DIGIT_OFF);
395    digitalWrite(digit6, DIGIT_OFF);
396}
397}  
398
399void displayNumber03(long toDisplay) {
400#define DISPLAY_BRIGHTNESS  25
401
402#define  DIGIT_ON  HIGH
403#define DIGIT_OFF  LOW
404
405  for(int digit = 6 ; digit > 0  ; digit--) {
406
407    //Turn on a digit for a short amount of time
408    switch(digit)  {
409    case 1:
410     digitalWrite(digit1, DIGIT_ON);
411     
412      break;
413   case 2:
414      digitalWrite(digit2, DIGIT_ON);
415      
416      break;
417    case 3:
418      digitalWrite(digit3, DIGIT_ON);
419      
420      break;
421    case 4:
422      digitalWrite(digit4, DIGIT_ON);
423      
424      break;
425    case 5:
426      digitalWrite(digit5, DIGIT_ON);
427      
428      break;
429    case 6:
430      digitalWrite(digit6, DIGIT_ON);
431      
432      break;
433    }
434    lightNumber(toDisplay % 10);
435    toDisplay /= 10;
436    delayMicroseconds(DISPLAY_BRIGHTNESS);  
437
438     //Turn off all segments
439    lightNumber(10); 
440
441    //Turn  off all digits
442    digitalWrite(digit1, DIGIT_OFF);
443    digitalWrite(digit2,  DIGIT_OFF);
444    digitalWrite(digit3, DIGIT_OFF);
445    digitalWrite(digit4,  DIGIT_OFF);
446    digitalWrite(digit5, DIGIT_OFF);
447    digitalWrite(digit6,  DIGIT_OFF);
448}
449} 
450
451void displayNumber04(long toDisplay) {
452#define  DISPLAY_BRIGHTNESS  25
453
454#define DIGIT_ON  HIGH
455#define DIGIT_OFF  LOW
456
457  for(int digit = 6 ; digit > 0 ; digit--) {
458
459    //Turn on a digit for a  short amount of time
460    switch(digit) {
461    case 1:
462     lightNumber(10);  
463     
464     break;
465   case 2:
466      digitalWrite(digit2, DIGIT_ON);
467      
468      break;
469    case 3:
470      digitalWrite(digit3, DIGIT_ON);
471      
472      break;
473    case 4:
474      digitalWrite(digit4, DIGIT_ON);
475      
476      break;
477    case 5:
478      digitalWrite(digit5, DIGIT_ON);
479      
480      break;
481    case 6:
482      digitalWrite(digit6, DIGIT_ON);
483      
484      break;
485    }
486    lightNumber(toDisplay % 10);
487    toDisplay  /= 10;
488    delayMicroseconds(DISPLAY_BRIGHTNESS); 
489
490     //Turn off all  segments
491    lightNumber(10); 
492
493    //Turn off all digits
494    digitalWrite(digit1,  DIGIT_OFF);
495    digitalWrite(digit2, DIGIT_OFF);
496    digitalWrite(digit3,  DIGIT_OFF);
497    digitalWrite(digit4, DIGIT_OFF);
498    digitalWrite(digit5,  DIGIT_OFF);
499    digitalWrite(digit6, DIGIT_OFF);
500}
501} 
502
503void displayNumber05(long  toDisplay) {
504#define DISPLAY_BRIGHTNESS  25
505
506#define DIGIT_ON  HIGH
507#define  DIGIT_OFF  LOW
508
509  for(int digit = 6 ; digit > 0 ; digit--) {
510
511    //Turn  on a digit for a short amount of time
512    switch(digit) {
513    case 1:
514     digitalWrite(digit1, DIGIT_ON);
515     
516      break;
517   case 2:
518      digitalWrite(digit2, DIGIT_ON);
519      
520      break;
521    case 3:
522      digitalWrite(digit3, DIGIT_ON);
523      
524      break;
525    case 4:
526      digitalWrite(digit4, DIGIT_ON);
527      
528      break;
529    case 5:
530      digitalWrite(digit5, DIGIT_ON);
531      
532      break;
533    case 6:
534      digitalWrite(digit6, DIGIT_ON);
535      
536      break;
537    }
538    lightNumber(toDisplay  % 10);
539    toDisplay /= 10;
540    delayMicroseconds(DISPLAY_BRIGHTNESS); 
541
542     //Turn off all segments
543    lightNumber(10); 
544
545    //Turn off all  digits
546    digitalWrite(digit1, DIGIT_OFF);
547    digitalWrite(digit2, DIGIT_OFF);
548    digitalWrite(digit3, DIGIT_OFF);
549    digitalWrite(digit4, DIGIT_OFF);
550    digitalWrite(digit5, DIGIT_OFF);
551    digitalWrite(digit6, DIGIT_OFF);
552}
553}  
554
555void displayNumber06(long toDisplay) {
556#define DISPLAY_BRIGHTNESS  25
557
558#define  DIGIT_ON  HIGH
559#define DIGIT_OFF  LOW
560
561  for(int digit = 6 ; digit > 0  ; digit--) {
562
563    //Turn on a digit for a short amount of time
564    switch(digit)  {
565    case 1:
566     //digitalWrite(digit1, DIGIT_ON);
567     
568      break;
569   case 2:
570      digitalWrite(digit2, DIGIT_ON);
571      
572      break;
573    case 3:
574      digitalWrite(digit3, DIGIT_ON);
575      
576      break;
577    case 4:
578      digitalWrite(digit4, DIGIT_ON);
579      
580      break;
581    case 5:
582      digitalWrite(digit5, DIGIT_ON);
583      
584      break;
585    case 6:
586      digitalWrite(digit6, DIGIT_ON);
587      
588      break;
589    }
590    lightNumber(toDisplay % 10);
591    toDisplay /= 10;
592    delayMicroseconds(DISPLAY_BRIGHTNESS);  
593
594     //Turn off all segments
595    lightNumber(10); 
596
597    //Turn  off all digits
598    digitalWrite(digit1, DIGIT_OFF);
599    digitalWrite(digit2,  DIGIT_OFF);
600    digitalWrite(digit3, DIGIT_OFF);
601    digitalWrite(digit4,  DIGIT_OFF);
602    digitalWrite(digit5, DIGIT_OFF);
603    digitalWrite(digit6,  DIGIT_OFF);
604}
605} 
606//Given a number, turns on those segments
607//If number  == 10, then turn off number
608void lightNumber(int numberToDisplay) {
609
610//Common  Anode *************************
611#define SEGMENT_ON  HIGH
612#define SEGMENT_OFF  LOW
613
614/* Common Cathode *****************
615  #define SEGMENT_ON  LOW
616  #define SEGMENT_OFF HIGH
617*/
618
619  switch (numberToDisplay){
620
621  case  0:
622    digitalWrite(segA, SEGMENT_ON);
623    digitalWrite(segB, SEGMENT_ON);
624    digitalWrite(segC, SEGMENT_ON);
625    digitalWrite(segD, SEGMENT_ON);
626    digitalWrite(segE,  SEGMENT_ON);
627    digitalWrite(segF, SEGMENT_ON);
628    digitalWrite(segG, SEGMENT_OFF);
629    break;
630
631  case 1:
632    digitalWrite(segA, SEGMENT_OFF);
633    digitalWrite(segB,  SEGMENT_ON);
634    digitalWrite(segC, SEGMENT_ON);
635    digitalWrite(segD, SEGMENT_OFF);
636    digitalWrite(segE, SEGMENT_OFF);
637    digitalWrite(segF, SEGMENT_OFF);
638    digitalWrite(segG, SEGMENT_OFF);
639    break;
640
641  case 2:
642    digitalWrite(segA,  SEGMENT_ON);
643    digitalWrite(segB, SEGMENT_ON);
644    digitalWrite(segC, SEGMENT_OFF);
645    digitalWrite(segD, SEGMENT_ON);
646    digitalWrite(segE, SEGMENT_ON);
647    digitalWrite(segF,  SEGMENT_OFF);
648    digitalWrite(segG, SEGMENT_ON);
649    break;
650
651  case  3:
652    digitalWrite(segA, SEGMENT_ON);
653    digitalWrite(segB, SEGMENT_ON);
654    digitalWrite(segC, SEGMENT_ON);
655    digitalWrite(segD, SEGMENT_ON);
656    digitalWrite(segE,  SEGMENT_OFF);
657    digitalWrite(segF, SEGMENT_OFF);
658    digitalWrite(segG,  SEGMENT_ON);
659    break;
660
661  case 4:
662    digitalWrite(segA, SEGMENT_OFF);
663    digitalWrite(segB, SEGMENT_ON);
664    digitalWrite(segC, SEGMENT_ON);
665    digitalWrite(segD,  SEGMENT_OFF);
666    digitalWrite(segE, SEGMENT_OFF);
667    digitalWrite(segF,  SEGMENT_ON);
668    digitalWrite(segG, SEGMENT_ON);
669    break;
670
671  case  5:
672    digitalWrite(segA, SEGMENT_ON);
673    digitalWrite(segB, SEGMENT_OFF);
674    digitalWrite(segC, SEGMENT_ON);
675    digitalWrite(segD, SEGMENT_ON);
676    digitalWrite(segE,  SEGMENT_OFF);
677    digitalWrite(segF, SEGMENT_ON);
678    digitalWrite(segG, SEGMENT_ON);
679    break;
680
681  case 6:
682    digitalWrite(segA, SEGMENT_ON);
683    digitalWrite(segB,  SEGMENT_OFF);
684    digitalWrite(segC, SEGMENT_ON);
685    digitalWrite(segD, SEGMENT_ON);
686    digitalWrite(segE, SEGMENT_ON);
687    digitalWrite(segF, SEGMENT_ON);
688    digitalWrite(segG,  SEGMENT_ON);
689    break;
690
691  case 7:
692    digitalWrite(segA, SEGMENT_ON);
693    digitalWrite(segB, SEGMENT_ON);
694    digitalWrite(segC, SEGMENT_ON);
695    digitalWrite(segD,  SEGMENT_OFF);
696    digitalWrite(segE, SEGMENT_OFF);
697    digitalWrite(segF,  SEGMENT_OFF);
698    digitalWrite(segG, SEGMENT_OFF);
699    break;
700
701  case  8:
702    digitalWrite(segA, SEGMENT_ON);
703    digitalWrite(segB, SEGMENT_ON);
704    digitalWrite(segC, SEGMENT_ON);
705    digitalWrite(segD, SEGMENT_ON);
706    digitalWrite(segE,  SEGMENT_ON);
707    digitalWrite(segF, SEGMENT_ON);
708    digitalWrite(segG, SEGMENT_ON);
709    break;
710
711  case 9:
712    digitalWrite(segA, SEGMENT_ON);
713    digitalWrite(segB,  SEGMENT_ON);
714    digitalWrite(segC, SEGMENT_ON);
715    digitalWrite(segD, SEGMENT_ON);
716    digitalWrite(segE, SEGMENT_OFF);
717    digitalWrite(segF, SEGMENT_ON);
718    digitalWrite(segG, SEGMENT_ON);
719    break;
720
721  // all segment are ON
722  case 10:
723    digitalWrite(segA, SEGMENT_OFF);
724    digitalWrite(segB, SEGMENT_OFF);
725    digitalWrite(segC, SEGMENT_OFF);
726    digitalWrite(segD, SEGMENT_OFF);
727    digitalWrite(segE, SEGMENT_OFF);
728    digitalWrite(segF, SEGMENT_OFF);
729    digitalWrite(segG, SEGMENT_OFF);
730    break;
731  
732  }
733// End of the  coding, BUDHUSARANAI, Best of luck.
734  
735}
736

1/*
2 4 digit 7 segment display: http://www.sparkfun.com/products/9483
3
4  Datasheet: http://www.sparkfun.com/datasheets/Components/LED/7-Segment/YSD-439AR6B-35.pdf
5
6  */
7// modified connexion by niq_ro from http://nicuflorica.blogspot.com
8//
9  dataseet: http://www.tme.eu/ro/Document/dfc2efde2e22005fd28615e298ea2655/KW4-563XSA.pdf
10//
11  Code modified by BMIAK Basnayaka
12// http://www.setnfix.com
13
14int digit1
15  = 11; 
16int digit2 = 10;
17int digit3 = 9; 
18int digit4 = 6;
19int digit5
20  = 5; 
21int digit6 = 3; 
22
23//Pin mapping from Arduino to the ATmega DIP28
24  if you need it
25//http://www.arduino.cc/en/Hacking/PinMapping
26int segA = 0;
27  //Display pin 11
28int segB = 1; //Display pin 7
29int segC = 2; //Display pin
30  4
31int segD = 4; //Display pin 2
32int segE = 7; //Display pin 1
33int segF
34  = 8; //Display pin 10
35int segG = 12; //Display pin 5
36int segDP =13; // Display
37  pin 3
38
39
40
41#include <Wire.h>
42#include "RTClib.h"
43RTC_DS1307 RTC;
44
45//
46  Date and time functions using a DS1307 RTC connected via I2C and Wire lib
47//
48  original sketck from http://learn.adafruit.com/ds1307-real-time-clock-breakout-board-kit/
49//
50  add part with SQW=1Hz from http://tronixstuff.wordpress.com/2010/10/20/tutorial-arduino-and-the-i2c-bus/
51//
52  add part with manual adjust http://www.bristolwatch.com/arduino/arduino_ds1307.htm
53
54
55
56byte
57  SW0 = A0;
58byte SW1 = A2;
59byte SW2 = A1;
60byte SWT = A3;
61int Adhr=0;
62int
63  Admnt=0;
64int D = 0;
65int Z =0;
66
67// use for hexa in zecimal conversion
68long
69  zh, uh, ore;
70long zm, um, miniti;
71
72void setup() {
73  
74 //Serial.begin(57600);
75
76  Wire.begin();
77  RTC.begin();
78 // RTC.adjust(DateTime(F(__DATE__), F(__TIME__)));
79//
80  if you need set clock... just remove // from line above this
81
82// part code
83  for flashing LED
84Wire.beginTransmission(0x68);
85Wire.write(0x07); // move pointer
86  to SQW address
87// Wire.write(0x00); // turns the SQW pin off
88 Wire.write(0x10);
89  // sends 0x10 (hex) 00010000 (binary) to control register - turns on square wave
90  at 1Hz
91// Wire.write(0x13); // sends 0x13 (hex) 00010011 (binary) 32kHz
92
93Wire.endTransmission();
94
95  
96  
97  pinMode(segA, OUTPUT);
98  pinMode(segB, OUTPUT);
99  pinMode(segC,
100  OUTPUT);
101  pinMode(segD, OUTPUT);
102  pinMode(segE, OUTPUT);
103  pinMode(segF,
104  OUTPUT);
105  pinMode(segG, OUTPUT);
106  pinMode(segDP, OUTPUT);
107
108  pinMode(digit1,
109  OUTPUT);
110  pinMode(digit2, OUTPUT);
111  pinMode(digit3, OUTPUT);
112  pinMode(digit4,
113  OUTPUT);
114  pinMode(digit5, OUTPUT);
115  pinMode(digit6, OUTPUT);
116
117
118//Serial.begin(9600);
119
120pinMode(SW0,
121  INPUT);  // N.O. push button switch
122pinMode(SW1, INPUT);  // N.O. push button
123  switch
124pinMode(SW2, INPUT);  // N.O. push button switch
125pinMode(SWT, INPUT);
126  // N.O. push button switch
127
128digitalWrite(SW0, HIGH); // pull-ups on
129digitalWrite(SW1,
130  HIGH);
131digitalWrite(SW2, HIGH);
132digitalWrite(segDP, LOW);
133
134
135}
136
137
138void
139  loop() {
140
141  DateTime now = RTC.now();
142  long HR = now.hour()*1000;
143
144  long timp = (HR*10)+now.minute()*100+now.second();
145  Adhr = now.hour();
146
147  Admnt=now.minute();
148
149
150
151int DIM = 0;
152if (timp >=250000)
153timp=timp-240000;
154//------------------------------------------------------
155//12/24
156  hours shitching 
157//------------------------------------------------------
158if
159  (timp < 130000){
160digitalWrite(segDP, LOW);}
161
162
163if (digitalRead(SWT)==0){delay(300);
164
165  if (D == 0) {
166 D =1;delay(200);}
167 
168else{
169D =0;}
170}
171
172
173
174
175if
176  (D == 0){  
177if (timp>=130000){
178timp=timp-120000;
179digitalWrite(segDP, HIGH);}
180}
181
182if
183  (timp>=130000){ 
184digitalWrite(segDP, LOW);
185}
186
187if ((D==1)& (timp <130000))
188digitalWrite(segDP,
189  LOW);
190
191
192
193
194
195//------------------------------------------------------
196
197
198
199  
200
201
202
203//int timp = (now.minute(), DEC);
204//   displayNumber(12); //
205  this is number to diplay
206
207
208     
209    for(int i = 100 ; i >0  ; i--)
210  {
211     if (timp >= 100000) displayNumber01(timp); 
212     else displayNumber02(timp);
213  
214   } 
215
216   for(int i = 100 ; i >0  ; i--) {
217     if (timp >= 100000)
218  displayNumber03(timp); 
219     else displayNumber04(timp); 
220   } 
221
222   for(int
223  i = 100 ; i >0  ; i--) {
224     if (timp >= 100000) displayNumber05(timp); 
225
226     else displayNumber06(timp); 
227   } 
228
229
230  
231
232if (digitalRead(SW0)==0){delay(100);Z=1;
233  set_time(); }// hold the switch to set time
234}
235
236void set_time()   {
237
238  byte minutes1 = 0;
239  byte hours1 = 0;
240  byte minutes = 0;
241  byte hours
242  = 0;
243  hours=Adhr;
244  minutes=Admnt;
245
246
247    if ((hours & 0x0f) > 9)
248  hours =  hours + 6;
249      if (hours > 0x24) hours = 1; // Mid night 12.00 will
250  show as 12:00 (With PM LED on) or 24:00
251        //if (hours > 0x24) hours = 1;
252  // Mid night 12.00 will show as 0:00
253        if ((minutes & 0x0f) > 9) minutes
254  = minutes + 6;
255      if (minutes > 0x59) minutes = 0;
256      
257while (!(Z==0)){
258  // set time switch must be released to exit
259
260
261 
262
263
264    
265   int
266  TST = digitalRead(SW2);
267    while (TST==0) // set hours
268    { 
269     hours++;
270          
271     
272   // converting hexa in zecimal:
273    zh = hours / 16;
274
275    uh = hours - 16 * zh ;
276    ore = 10 * zh + uh; 
277    zm = minutes / 16;
278
279    um = minutes - 16 * zm ;
280    miniti = 10 * zm + um; 
281    
282   
283   
284
285      
286      if ((hours & 0x0f) > 9) hours =  hours + 6;
287            if (hours
288  > 0x24) hours = 1; // Mid night 12.00 will show as 12:00 (With PM LED on) or 24:00
289
290        //if (hours > 0x24) hours = 1; // Mid night 12.00 will show as 0:00
291
292        if (hours <= 9) 
293    delay(1);
294    
295      for(int i = 400 ; i >0
296  ; i--) {
297     displayNumber01(ore*10000+miniti*100); 
298     }
299    
300
301    TST = digitalRead(SW2);
302    }
303
304   while (!(digitalRead(SW1))) // set
305  minutes
306    { 
307     minutes++;  
308   // converting hexa in zecimal:
309
310    zh = hours / 16;
311    uh = hours - 16 * zh ;
312    ore = 10 * zh + uh; 
313
314    zm = minutes / 16;
315    um = minutes - 16 * zm ;
316    miniti = 10 * zm +
317  um; 
318    
319     for(int i = 400 ; i >0  ; i--) {
320     displayNumber01(ore*10000+miniti*100);
321  
322     }
323
324      if ((minutes & 0x0f) > 9) minutes = minutes + 6;
325      if
326  (minutes > 0x59) minutes = 0;
327      if (minutes >= 9) 
328    delay(1);    
329
330    }
331
332    Wire.beginTransmission(0x68); // activate DS1307
333    Wire.write(0);
334  // where to begin
335    Wire.write(0x00);          //seconds
336    Wire.write(minutes);
337          //minutes
338    Wire.write(0x80 | hours);    //hours (24hr time)
339
340    Wire.write(0x06);  // Day 01-07
341    Wire.write(0x01);  // Date 0-31
342    Wire.write(0x05);
343  // month 0-12
344    Wire.write(0x09);  // Year 00-99
345    Wire.write(0x10);
346  // Control 0x10 produces a 1 HZ square wave on pin 7. 
347    Wire.endTransmission();
348
349  
350    // converting hexa in zecimal:
351    zh = hours / 16;
352    uh = hours
353  - 16 * zh ;
354    ore = 10 * zh + uh; 
355    zm = minutes / 16;
356    um = minutes
357  - 16 * zm ;
358    miniti = 10 * zm + um; 
359
360 
361    
362    for(int i = 400
363  ; i >0  ; i--) {
364     displayNumber01(ore*10000+miniti*100); 
365     }
366delay(100);
367  
368//Serial.print(digitalRead(SW0));
369if (digitalRead(SW0)==0) Z = 0;
370 delay(300);
371   
372  }
373//Serial.print(SW2);
374}
375
376
377
378void displayNumber01(long
379  toDisplay) {
380#define DISPLAY_BRIGHTNESS  25
381
382#define DIGIT_ON  HIGH
383#define
384  DIGIT_OFF  LOW
385
386  for(int digit = 6 ; digit > 0 ; digit--) {
387
388    //Turn
389  on a digit for a short amount of time
390    switch(digit) {
391    case 1:
392
393     digitalWrite(digit1, DIGIT_ON);
394     
395      break;
396   case 2:
397
398      digitalWrite(digit2, DIGIT_ON);
399      //digitalWrite(segDP, LOW);
400      break;
401
402    case 3:
403      digitalWrite(digit3, DIGIT_ON);
404      
405      break;
406
407    case 4:
408      digitalWrite(digit4, DIGIT_ON);
409      
410      break;
411
412    case 5:
413      digitalWrite(digit5, DIGIT_ON);
414      
415      break;
416
417    case 6:
418      digitalWrite(digit6, DIGIT_ON);
419      
420      break;
421
422      
423    }
424    lightNumber(toDisplay % 10);
425    toDisplay /= 10;
426
427    delayMicroseconds(DISPLAY_BRIGHTNESS); 
428
429
430     //Turn off all segments
431
432    lightNumber(10); 
433
434    //Turn off all digits
435    digitalWrite(digit1,
436  DIGIT_OFF);
437    digitalWrite(digit2, DIGIT_OFF);
438    digitalWrite(digit3,
439  DIGIT_OFF);
440    digitalWrite(digit4, DIGIT_OFF);
441    digitalWrite(digit5,
442  DIGIT_OFF);
443    digitalWrite(digit6, DIGIT_OFF);
444}
445} 
446
447void displayNumber02(long
448  toDisplay) {
449#define DISPLAY_BRIGHTNESS  25
450
451#define DIGIT_ON  HIGH
452#define
453  DIGIT_OFF  LOW
454
455  for(int digit = 6 ; digit > 0 ; digit--) {
456
457    //Turn
458  on a digit for a short amount of time
459    switch(digit) {
460    case 1:
461
462     lightNumber(10); 
463     
464     break;
465   case 2:
466      digitalWrite(digit2,
467  DIGIT_ON);
468      //digitalWrite(segDP, LOW);
469      break;
470    case 3:
471
472      digitalWrite(digit3, DIGIT_ON);
473      
474      break;
475    case 4:
476
477      digitalWrite(digit4, DIGIT_ON);
478      
479      break;
480     case 5:
481
482      digitalWrite(digit5, DIGIT_ON);
483      
484      break;
485    case 6:
486
487      digitalWrite(digit6, DIGIT_ON);
488      
489      break;
490    }
491    lightNumber(toDisplay
492  % 10);
493    toDisplay /= 10;
494    delayMicroseconds(DISPLAY_BRIGHTNESS); 
495
496
497     //Turn off all segments
498    lightNumber(10); 
499
500    //Turn off all
501  digits
502    digitalWrite(digit1, DIGIT_OFF);
503    digitalWrite(digit2, DIGIT_OFF);
504
505    digitalWrite(digit3, DIGIT_OFF);
506    digitalWrite(digit4, DIGIT_OFF);
507
508    digitalWrite(digit5, DIGIT_OFF);
509    digitalWrite(digit6, DIGIT_OFF);
510}
511}
512  
513
514void displayNumber03(long toDisplay) {
515#define DISPLAY_BRIGHTNESS  25
516
517#define
518  DIGIT_ON  HIGH
519#define DIGIT_OFF  LOW
520
521  for(int digit = 6 ; digit > 0
522  ; digit--) {
523
524    //Turn on a digit for a short amount of time
525    switch(digit)
526  {
527    case 1:
528     digitalWrite(digit1, DIGIT_ON);
529     
530      break;
531
532   case 2:
533      digitalWrite(digit2, DIGIT_ON);
534      
535      break;
536
537    case 3:
538      digitalWrite(digit3, DIGIT_ON);
539      
540      break;
541
542    case 4:
543      digitalWrite(digit4, DIGIT_ON);
544      
545      break;
546
547    case 5:
548      digitalWrite(digit5, DIGIT_ON);
549      
550      break;
551
552    case 6:
553      digitalWrite(digit6, DIGIT_ON);
554      
555      break;
556
557    }
558    lightNumber(toDisplay % 10);
559    toDisplay /= 10;
560    delayMicroseconds(DISPLAY_BRIGHTNESS);
561  
562
563     //Turn off all segments
564    lightNumber(10); 
565
566    //Turn
567  off all digits
568    digitalWrite(digit1, DIGIT_OFF);
569    digitalWrite(digit2,
570  DIGIT_OFF);
571    digitalWrite(digit3, DIGIT_OFF);
572    digitalWrite(digit4,
573  DIGIT_OFF);
574    digitalWrite(digit5, DIGIT_OFF);
575    digitalWrite(digit6,
576  DIGIT_OFF);
577}
578} 
579
580void displayNumber04(long toDisplay) {
581#define
582  DISPLAY_BRIGHTNESS  25
583
584#define DIGIT_ON  HIGH
585#define DIGIT_OFF  LOW
586
587
588  for(int digit = 6 ; digit > 0 ; digit--) {
589
590    //Turn on a digit for a
591  short amount of time
592    switch(digit) {
593    case 1:
594     lightNumber(10);
595  
596     
597     break;
598   case 2:
599      digitalWrite(digit2, DIGIT_ON);
600
601      
602      break;
603    case 3:
604      digitalWrite(digit3, DIGIT_ON);
605
606      
607      break;
608    case 4:
609      digitalWrite(digit4, DIGIT_ON);
610
611      
612      break;
613    case 5:
614      digitalWrite(digit5, DIGIT_ON);
615
616      
617      break;
618    case 6:
619      digitalWrite(digit6, DIGIT_ON);
620
621      
622      break;
623    }
624    lightNumber(toDisplay % 10);
625    toDisplay
626  /= 10;
627    delayMicroseconds(DISPLAY_BRIGHTNESS); 
628
629     //Turn off all
630  segments
631    lightNumber(10); 
632
633    //Turn off all digits
634    digitalWrite(digit1,
635  DIGIT_OFF);
636    digitalWrite(digit2, DIGIT_OFF);
637    digitalWrite(digit3,
638  DIGIT_OFF);
639    digitalWrite(digit4, DIGIT_OFF);
640    digitalWrite(digit5,
641  DIGIT_OFF);
642    digitalWrite(digit6, DIGIT_OFF);
643}
644} 
645
646void displayNumber05(long
647  toDisplay) {
648#define DISPLAY_BRIGHTNESS  25
649
650#define DIGIT_ON  HIGH
651#define
652  DIGIT_OFF  LOW
653
654  for(int digit = 6 ; digit > 0 ; digit--) {
655
656    //Turn
657  on a digit for a short amount of time
658    switch(digit) {
659    case 1:
660
661     digitalWrite(digit1, DIGIT_ON);
662     
663      break;
664   case 2:
665
666      digitalWrite(digit2, DIGIT_ON);
667      
668      break;
669    case 3:
670
671      digitalWrite(digit3, DIGIT_ON);
672      
673      break;
674    case 4:
675
676      digitalWrite(digit4, DIGIT_ON);
677      
678      break;
679    case 5:
680
681      digitalWrite(digit5, DIGIT_ON);
682      
683      break;
684    case 6:
685
686      digitalWrite(digit6, DIGIT_ON);
687      
688      break;
689    }
690    lightNumber(toDisplay
691  % 10);
692    toDisplay /= 10;
693    delayMicroseconds(DISPLAY_BRIGHTNESS); 
694
695
696     //Turn off all segments
697    lightNumber(10); 
698
699    //Turn off all
700  digits
701    digitalWrite(digit1, DIGIT_OFF);
702    digitalWrite(digit2, DIGIT_OFF);
703
704    digitalWrite(digit3, DIGIT_OFF);
705    digitalWrite(digit4, DIGIT_OFF);
706
707    digitalWrite(digit5, DIGIT_OFF);
708    digitalWrite(digit6, DIGIT_OFF);
709}
710}
711  
712
713void displayNumber06(long toDisplay) {
714#define DISPLAY_BRIGHTNESS  25
715
716#define
717  DIGIT_ON  HIGH
718#define DIGIT_OFF  LOW
719
720  for(int digit = 6 ; digit > 0
721  ; digit--) {
722
723    //Turn on a digit for a short amount of time
724    switch(digit)
725  {
726    case 1:
727     //digitalWrite(digit1, DIGIT_ON);
728     
729      break;
730
731   case 2:
732      digitalWrite(digit2, DIGIT_ON);
733      
734      break;
735
736    case 3:
737      digitalWrite(digit3, DIGIT_ON);
738      
739      break;
740
741    case 4:
742      digitalWrite(digit4, DIGIT_ON);
743      
744      break;
745
746    case 5:
747      digitalWrite(digit5, DIGIT_ON);
748      
749      break;
750
751    case 6:
752      digitalWrite(digit6, DIGIT_ON);
753      
754      break;
755
756    }
757    lightNumber(toDisplay % 10);
758    toDisplay /= 10;
759    delayMicroseconds(DISPLAY_BRIGHTNESS);
760  
761
762     //Turn off all segments
763    lightNumber(10); 
764
765    //Turn
766  off all digits
767    digitalWrite(digit1, DIGIT_OFF);
768    digitalWrite(digit2,
769  DIGIT_OFF);
770    digitalWrite(digit3, DIGIT_OFF);
771    digitalWrite(digit4,
772  DIGIT_OFF);
773    digitalWrite(digit5, DIGIT_OFF);
774    digitalWrite(digit6,
775  DIGIT_OFF);
776}
777} 
778//Given a number, turns on those segments
779//If number
780  == 10, then turn off number
781void lightNumber(int numberToDisplay) {
782
783//Common
784  Anode *************************
785#define SEGMENT_ON  HIGH
786#define SEGMENT_OFF
787  LOW
788
789/* Common Cathode *****************
790  #define SEGMENT_ON  LOW
791
792  #define SEGMENT_OFF HIGH
793*/
794
795  switch (numberToDisplay){
796
797  case
798  0:
799    digitalWrite(segA, SEGMENT_ON);
800    digitalWrite(segB, SEGMENT_ON);
801
802    digitalWrite(segC, SEGMENT_ON);
803    digitalWrite(segD, SEGMENT_ON);
804    digitalWrite(segE,
805  SEGMENT_ON);
806    digitalWrite(segF, SEGMENT_ON);
807    digitalWrite(segG, SEGMENT_OFF);
808
809    break;
810
811  case 1:
812    digitalWrite(segA, SEGMENT_OFF);
813    digitalWrite(segB,
814  SEGMENT_ON);
815    digitalWrite(segC, SEGMENT_ON);
816    digitalWrite(segD, SEGMENT_OFF);
817
818    digitalWrite(segE, SEGMENT_OFF);
819    digitalWrite(segF, SEGMENT_OFF);
820
821    digitalWrite(segG, SEGMENT_OFF);
822    break;
823
824  case 2:
825    digitalWrite(segA,
826  SEGMENT_ON);
827    digitalWrite(segB, SEGMENT_ON);
828    digitalWrite(segC, SEGMENT_OFF);
829
830    digitalWrite(segD, SEGMENT_ON);
831    digitalWrite(segE, SEGMENT_ON);
832    digitalWrite(segF,
833  SEGMENT_OFF);
834    digitalWrite(segG, SEGMENT_ON);
835    break;
836
837  case
838  3:
839    digitalWrite(segA, SEGMENT_ON);
840    digitalWrite(segB, SEGMENT_ON);
841
842    digitalWrite(segC, SEGMENT_ON);
843    digitalWrite(segD, SEGMENT_ON);
844    digitalWrite(segE,
845  SEGMENT_OFF);
846    digitalWrite(segF, SEGMENT_OFF);
847    digitalWrite(segG,
848  SEGMENT_ON);
849    break;
850
851  case 4:
852    digitalWrite(segA, SEGMENT_OFF);
853
854    digitalWrite(segB, SEGMENT_ON);
855    digitalWrite(segC, SEGMENT_ON);
856    digitalWrite(segD,
857  SEGMENT_OFF);
858    digitalWrite(segE, SEGMENT_OFF);
859    digitalWrite(segF,
860  SEGMENT_ON);
861    digitalWrite(segG, SEGMENT_ON);
862    break;
863
864  case
865  5:
866    digitalWrite(segA, SEGMENT_ON);
867    digitalWrite(segB, SEGMENT_OFF);
868
869    digitalWrite(segC, SEGMENT_ON);
870    digitalWrite(segD, SEGMENT_ON);
871    digitalWrite(segE,
872  SEGMENT_OFF);
873    digitalWrite(segF, SEGMENT_ON);
874    digitalWrite(segG, SEGMENT_ON);
875
876    break;
877
878  case 6:
879    digitalWrite(segA, SEGMENT_ON);
880    digitalWrite(segB,
881  SEGMENT_OFF);
882    digitalWrite(segC, SEGMENT_ON);
883    digitalWrite(segD, SEGMENT_ON);
884
885    digitalWrite(segE, SEGMENT_ON);
886    digitalWrite(segF, SEGMENT_ON);
887    digitalWrite(segG,
888  SEGMENT_ON);
889    break;
890
891  case 7:
892    digitalWrite(segA, SEGMENT_ON);
893
894    digitalWrite(segB, SEGMENT_ON);
895    digitalWrite(segC, SEGMENT_ON);
896    digitalWrite(segD,
897  SEGMENT_OFF);
898    digitalWrite(segE, SEGMENT_OFF);
899    digitalWrite(segF,
900  SEGMENT_OFF);
901    digitalWrite(segG, SEGMENT_OFF);
902    break;
903
904  case
905  8:
906    digitalWrite(segA, SEGMENT_ON);
907    digitalWrite(segB, SEGMENT_ON);
908
909    digitalWrite(segC, SEGMENT_ON);
910    digitalWrite(segD, SEGMENT_ON);
911    digitalWrite(segE,
912  SEGMENT_ON);
913    digitalWrite(segF, SEGMENT_ON);
914    digitalWrite(segG, SEGMENT_ON);
915
916    break;
917
918  case 9:
919    digitalWrite(segA, SEGMENT_ON);
920    digitalWrite(segB,
921  SEGMENT_ON);
922    digitalWrite(segC, SEGMENT_ON);
923    digitalWrite(segD, SEGMENT_ON);
924
925    digitalWrite(segE, SEGMENT_OFF);
926    digitalWrite(segF, SEGMENT_ON);
927
928    digitalWrite(segG, SEGMENT_ON);
929    break;
930
931  // all segment are ON
932
933  case 10:
934    digitalWrite(segA, SEGMENT_OFF);
935    digitalWrite(segB, SEGMENT_OFF);
936
937    digitalWrite(segC, SEGMENT_OFF);
938    digitalWrite(segD, SEGMENT_OFF);
939
940    digitalWrite(segE, SEGMENT_OFF);
941    digitalWrite(segF, SEGMENT_OFF);
942
943    digitalWrite(segG, SEGMENT_OFF);
944    break;
945  
946  }
947// End of the
948  coding, BUDHUSARANAI, Best of luck.
949  
950}
951