1. #include<msp430x14x.h>
2. #include "lcd.h"
3. #include "portyLcd.h"
4. #define PRZYCISK BIT4&P4IN
5.  
6. unsigned int i=0;
7. unsigned int dziesiatkidni=2;
8. unsigned int dni=8;
9. unsigned int dziesiatkigodz=2;
10. unsigned int godz=3;
11. unsigned int dziesiatkiminut=5;
12. unsigned int minuty=9;
13. unsigned int dziesiatkisekund=5;
14. unsigned int sekundy=6;
15. unsigned int licznik=0;
16. unsigned int miesiac=3;
17. unsigned int dziesiatkimiesiecy=0;
18. unsigned int tysiaceroku=2;
19. unsigned int setkiroku=0;
20. unsigned int dziesiatkiroku=0;
21. unsigned int rok=0;
22. unsigned char znak;
23. unsigned char literar;
24.  
25.  
26. char sty[7]={"stycze "};
27. char lut[5]={"luty "};
28. char mar[7]={"marzec "};
29. char kwi[8]={"kwiecie "};
30. char maj[3]={"maj"};
31. char cze[8]={"czerwiec"};
32. char lip[6]={"lipiec"};
33. char sie[8]={"sierpie "};
34. char wrz[8]={"wrzesie "};
35. char paz[12]={"pazdziernik"};
36. char lis[10]={"listopad "};
37. char gru[8]={"grudzie "};
38.  
39. void Clock(void);
40.  
41. void main( void )
42. {
43.         znak=':';
44.         literar='r';
45.         P2DIR |= BIT1;                                           // STATUS LED
46.         WDTCTL=WDTPW + WDTHOLD;                                 // Wyłączenie WDT
47.         InitPortsLcd();                                                 // inicjalizacja portów LCD
48.         InitLCD();                                                              // inicjalizacja LCD
49.         clearDisplay();                                                 // czyszczenie wyświetlacza    
50.         // Basic Clock Module ustawiamy na ACLK(zegar 8 MHz ) i dzielimy częstotliwość przez 2 (4 MHz)
51.         BCSCTL1 |= XTS;                                                 // ACLK = LFXT1 = HF XTAL 8MHz
52.         do
53.         {
54.                 IFG1 &= ~OFIFG;                                 // Czyszczenie flgi OSCFault
55.                         for (i = 0xFF; i > 0; i--);                     // odczekanie
56.         }
57.         while ((IFG1 & OFIFG) == OFIFG);                // dopóki OSCFault jest ciągle ustawiona  
58.         BCSCTL1 |= DIVA_1;                                              // ACLK=8 MHz/2=4 MHz
59.         BCSCTL2 |= SELM0 | SELM1;                               // MCLK= LFTX1 =ACLK
60.         // Timer_A  ustawiamy na 500 kHz
61.         // a przerwanie generujemy co 100 ms
62.         TACTL = TASSEL_1 + MC_1 +ID_3;                          // Wybieram ACLK, ACLK/8=500kHz,tryb Up
63.         CCTL0 = CCIE;                                                   // włączenie przerwań od CCR0
64.         CCR0=50000;                                                     // podzielnik 50000: przerwanie co 100 ms
65.         _EINT();                                                                // włączenie przerwań
66.         for (;;)                            
67.         {
68.                 _BIS_SR(LPM3_bits);                             // przejscie do trybu LPM3
69.                         Clock();
70.         }
71. }
72.  
73. void Clock(void)
74. {
75.    SEND_CMD(CG_RAM_ADDR);
76.       int spec[2][8] = {{0,2, 4, 14, 10, 10, 10, 0}, // ń
77.       {0, 1, 2, 15, 2, 4, 15, 0}};// ź
78.       for(int registry = 0; registry < 2; ++registry)
79.       {
80.       for(int mw = 0; mw < 8; ++mw)
81.       SEND_CHAR(spec[registry][mw]);
82.       }
83.         if (licznik %10 ==0)                                            // gdy mineła sekunda (10 * 100 milisekund)
84.         {
85.                 licznik=0;
86.                         P2OUT ^=BIT1;                                   //zapal diodę
87.                         ++sekundy;                                      // licz sekundy
88.                         sekundy = sekundy%10;
89.                         dziesiatkisekund = dziesiatkisekund%6;
90.                         SEND_CMD(DD_RAM_ADDR);                          // gorna linia wyswietlacza
91.                         SEND_CHAR(dziesiatkidni+48);                    // wyswietla dziesiatki dni
92.                         SEND_CHAR(dni+48);                              // wyswietla jednosci dni
93.                         //SEND_CHAR(' ');                               // wyswietla pustny znak (odstęp)  
94.                         SEND_CHAR(' ');                                 // wyswietla pustny znak (odstęp)
95.                         if (dziesiatkimiesiecy==0 && miesiac==1)
96.                 for (i=0;i<=8;i++)
97.                 {
98.                   if(i==7)
99.                   {
100.                     SEND_CHAR(8);
101.                   }
102.                   else
103.                   {
104.                   SEND_CHAR(sty[i]);    // wyswietla styczen, jesli spelnione
105.                   }
106.                 }
107.                
108.                
109.                 if (dziesiatkimiesiecy==0 && miesiac==2)
110.                    for (i=0;i<=4;i++) SEND_CHAR(lut[i]);        
111.                        
112.                         // wyswietla luty, jesli spelnione
113.                         if (miesiac==3)
114.                 for (i=0;i<=6;i++) SEND_CHAR(mar[i]);// wyswietla marzec, jesli spelnione
115.                         if (miesiac==4)
116.                 for (i=0;i<=8;i++)
117.                 {
118.                   if(i==8)
119.                   {
120.                     SEND_CHAR(8);
121.                   }
122.                   else
123.                   {
124.                   SEND_CHAR(kwi[i]);    // wyswietla kwiecien, jesli spelnione
125.                   }
126.                 }
127.                         if (miesiac==5)
128.                 for (i=0;i<=3;i++) SEND_CHAR(maj[i]);// wyswietla maj, jesli spelnione                 
129.                 if (miesiac==6)
130.                 for (i=0;i<=8;i++) SEND_CHAR(cze[i]);   // wyswietla czerwiec, jeśli spelnione
131.                         if (miesiac==7)
132.                 for (i=0;i<=6;i++) SEND_CHAR(lip[i]);   // wyswietla lipiec, jesli spelnione
133.                         if (miesiac==8)
134.                 for (i=0;i<=8;i++)
135.                 {
136.                   if(i==8)
137.                   {
138.                     SEND_CHAR(8);
139.                   }
140.                   else
141.                   {
142.                     SEND_CHAR(sie[i]);
143.                   }
144.                 }
145.                         if (miesiac==9)
146.                 for (i=0;i<=8;i++)
147.                   {
148.                   if(i==8)
149.                   {
150.                     SEND_CHAR(8);
151.                   }
152.                   else
153.                   {
154.                     SEND_CHAR(wrz[i]);
155.                   }
156.                   }
157.                 // wyswietla wrzesien, jesli spelnione
158.                         if (dziesiatkimiesiecy==1 && miesiac==0)
159.                 for (i=0;i<=11;i++)
160.                 {
161.                   if(i==3)
162.                   {
163.                     SEND_CHAR(9);
164.                   }
165.                   else
166.                   {
167.                     SEND_CHAR(paz[i]);
168.                   }
169.                 }// wyswietla pazdziernik, jeśli spelnione
170.                         if (dziesiatkimiesiecy==1 && miesiac==1)
171.                 for (i=0;i<=11;i++) SEND_CHAR(lis[i]);  // wyswietla listopad, jesli spelnione
172.                         if (dziesiatkimiesiecy==1 && miesiac==2)
173.                 for (i=0;i<=11;i++)
174.                 {
175.                   if(i==8)
176.                   {
177.                     SEND_CHAR(8);
178.                   }
179.                   else
180.                   {
181.                     SEND_CHAR(gru[i]);
182.                   }
183.                 }
184.                
185.                 SEND_CHAR(tysiaceroku+48);                      // wyswietla tysiace lat
186.                         SEND_CHAR(setkiroku+48);                        // wyswietla setki lat
187.                         SEND_CHAR(dziesiatkiroku+48);                   // wyswietla dziesiatki lat
188.                         SEND_CHAR(rok+48);                              // wyswietla jednosci lat
189.                         SEND_CHAR(literar);                             // wyswietla literke "r"
190.                        
191.                 // wyswietla grudzien, jeśli spelnione
192.                         SEND_CMD(DD_RAM_ADDR2);                 // dolna linia wyswietlacza
193.                         SEND_CHAR(dziesiatkigodz+48);                   // wyswietla dziesiatki godzin
194.                         SEND_CHAR(godz+48);                             // wyswietla jednosci godzin
195.                         SEND_CHAR(znak);                                // wyswietla dwukropek
196.                         SEND_CHAR(dziesiatkiminut+48);                  // wyswietla dziesiatki minut
197.                         SEND_CHAR(minuty+48);                           // wyswietla jednosci minut
198.                         SEND_CHAR(znak);                                
199.                         SEND_CHAR(dziesiatkisekund+48);                                                                
200.                         SEND_CHAR(sekundy+48);                                  // wyswietla pustny znak (odstęp)
201.                         SEND_CHAR(' ');                                 // wyswietla pustny znak (odstęp)
202.                         SEND_CMD(CUR_SHIFT_LEFT );              // wróć kursorem na początek
203.                         if(sekundy==9)                                          // przeskok z X9 sekund na (X+1)0 sekund
204.                         dziesiatkisekund++;                            
205.                         if(dziesiatkisekund==6)                         // przeskok z 59 sekund na X minut 00 sekund
206.                         {
207.                         dziesiatkisekund=0;
208.                         minuty++;
209.                         }
210.                         if(minuty==10)                                          // przeskok z X9 minut na (X+1)0 minut
211.                         {
212.                         minuty=0;
213.                         dziesiatkiminut++;
214.                         }
215.                         if(dziesiatkiminut==6)                          // przeskok z 59 minut na X godzin 00 minut
216.                         {
217.                         dziesiatkiminut=0;
218.                         godz++;
219.                         }
220.                         if(godz==10)                                            // przeskok z X9 godzin na (X+1)0 godzin
221.                         {
222.                         godz=0;
223.                         dziesiatkigodz++;
224.                         }
225.                         if(dziesiatkigodz==2 && godz==4 )       // przeskok z 23:59:59 na 00:00:00
226.                         {
227.                         dziesiatkigodz=0;
228.                         godz=0;
229.                         dni++;
230.                         }
231.                         if(dni==9)                                              // przeskok z X9 dni na (X+1)0 dni
232.                         {
233.                         dni=1;
234.                         dziesiatkidni++;
235.                         }
236.                         // przeskok z 31 dnia na dzień 1 kolejnego miesiąca (dla miesięcy: 1,3,5,7,8,10,12)
237.                         if(dziesiatkidni==3 && dni==2 && (miesiac==1 || miesiac==3 || miesiac==5 ||miesiac==7 ||miesiac==8 ||(miesiac==0 && dziesiatkimiesiecy==1) ||(miesiac==2 && dziesiatkimiesiecy==1)))
238.                         {
239.                         dziesiatkidni=0;
240.                         dni=1;
241.                         miesiac++;
242.                         }
243.                         // przeskok z 30 dnia na dzień 1 kolejnego miesiąca (dla miesięcy: 4,6,9,11)
244.                         if(dziesiatkidni==3 && dni==1 && (miesiac==4 || miesiac==6 ||miesiac==7 ||miesiac==9 ||(miesiac==1 && dziesiatkimiesiecy==1)))
245.                         {
246.                         dziesiatkidni=0;
247.                         dni=1;
248.                         miesiac++;
249.                         }
250.                         int rokvalue=1000*tysiaceroku+100*setkiroku+10*dziesiatkiroku+rok;                    
251.                         // przeskok z 28 dnia na dzień 1 kolejnego miesiąca (dla miesięca: 2)
252.                         if(dziesiatkidni==2 && dni==9 && miesiac==2 && dziesiatkimiesiecy==0)
253.                         {
254.                           if(((rokvalue%400)==0) &&(rokvalue%4==0)&&(rokvalue%100!=0))
255.                          {
256.                            dziesiatkidni=2;
257.                            dni=9;
258.                            miesiac=2;
259.                          }
260.                          else
261.                          {
262.                           dziesiatkidni=0;
263.                           dni=1;
264.                           ++miesiac;
265.                          }
266.                         }
267.                         if(dziesiatkimiesiecy==0 && miesiac==10)// przeskok z 9 miesiaca na 10
268.                         {
269.                         miesiac=0;
270.                         dziesiatkimiesiecy=1;
271.                         }
272.                         if(dziesiatkimiesiecy==1 && miesiac==3) // przeskok z 12 miesiaca na 1
273.                         {
274.                         dziesiatkimiesiecy=0;
275.                         miesiac=1;
276.                         rok++;
277.                         }
278.                         if(rok==10)                                             // przeskok z XXX9 lat na XX(X+1)0 lat
279.                         {
280.                         rok=0;
281.                         dziesiatkiroku++;
282.                         }
283.                         if(dziesiatkiroku==10)                          // przeskok z XX99 lat na X(X+1)00 lat
284.                         {
285.                         dziesiatkiroku=0;
286.                         setkiroku++;
287.                         }
288.                         if(setkiroku==10)                                       // przeskok z X999 lat na (X+1)000 lat
289.                         {
290.                         setkiroku=0;
291.                         tysiaceroku++;
292.                         }
293.         }
294. }
295.  
296. // procedura obsługi przerwania od TimerA
297. #pragma vector=TIMERA0_VECTOR
298. __interrupt void Timer_A (void)
299. {
300.         ++licznik;
301.         _BIC_SR_IRQ(LPM3_bits);                         // wyjście z trybu LPM3
302. }