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