1. /****************************************************************************/
2. /*                   Program systemu prototypowego SP-AVR                   */
3. /* Autor:                                                                   */
4. /****************************************************************************/
5.  
6. #include <avr/io.h>                                     // Rejestry mikrokontrolera ATmega32
7. #include <avr/interrupt.h>                      // Przerwania mikrokontrolera
8. #include <stdio.h>                                      // Standardowe I/O
9. #include "key.h"                                        // Obsługa przycisków (SW0...SW7)
10. #include "led.h"                                        // Obsługa diod LED (LD0...LD7)
11. #include "lcd.h"                                        // Obsługa wyświetlacza LCD 2x16 znaków
12.  
13. #define TCYKL   25                                      // Czas cyklu obliczeń (25 x 4ms = 100ms)
14.  
15. volatile char cykl;                                     // Odmierzanie czasu cyklu (pętli głównej)
16. char buf[64];                                           // Bufor komunikatów LCD
17. //---------------------- Początek deklaracji użytkownika --------------------------------
18. //------------------------Deklaracje użytkownika--------------------------------------------------
19.  
20. volatile char c_in;                                             // odebrany znak (przez port szeregowy - przerwanie)
21.  
22.  
23. char UART_init(long baud)                               // inicjowanie portu szeregowego
24. {  
25.         char speed, err=0;
26.  
27.         speed = baud / 4800;
28.         switch(speed)
29.         {
30.                 case  1:
31.                         UBRRL = 103;                                            // 4800   (fosc=8MHz => UBRRL=103)
32.                         UBRRH = 0;
33.                         break;
34.                 case  2:
35.                         UBRRL = 51;                                                     // 9600   (fosc=8MHz => UBRRL=51)
36.                         UBRRH = 0;
37.                         break;
38.                 case  4:
39.                         UBRRL = 25;                                                     // 19200  (fosc=8MHz => UBRRL=25)
40.                         UBRRH = 0;
41.                         break;
42.                 case  8:
43.                         UBRRL = 12;                                                     // 38400  (fosc=8MHz => UBRRL=12)
44.                         UBRRH = 0;
45.                         break;
46.                 default:
47.                         UBRRL = 25;                                                     // 19200   (fosc=8MHz => UBRRL=25)
48.                         UBRRH = 0;
49.                         err = 1;                                                        // nietypowa predkość (ustawiona domyślnie)
50.                         break;
51.         }
52.        
53.         UCSRB =_BV(RXCIE)|_BV(RXEN)|_BV(TXEN);          // wł. przerwania od odb., wł. odbiornika i nadajnika
54.        
55.         UCSRC =_BV(URSEL)|_BV(UCSZ1)|_BV(UCSZ0);        // transmisja asynchroniczna, 8N1
56.        
57.         sei();                                                                          // globalne odblokowanie przerwań
58.        
59.         return err;
60. }
61.  
62. void COM_send(char c_out)                               // wysłanie jednego znaku do portu COM
63. {
64.         loop_until_bit_is_set(UCSRA, UDRE);                 // oczekiwanie na wysłanie poprzedniego znaku
65.         UDR = c_out;                                                            // wyślij nowy znak
66. }
67.  
68. char COM_recv(void)                                             // odbiór jednego znaku z portu COM
69. {
70.         char c = c_in;                                                          // odczyt znaku - przerwanie ( 0 = brak znaku, NULL)
71.         c_in = 0;                                                                       // zeruj flagę
72.         return c;                                                                       // zwroć znak
73. }
74.  
75. void send_str(char * s)                                                 // wysłanie tekstu do portu COM
76. {
77.         while (*s) COM_send(*s++);                                      // wysyłaj kolejno znaki tekstu
78. }
79.  
80. ISR (SIG_USART_RECV)                                                    // przerwanie od odbiornika
81. {
82.         c_in = UDR;                                                                     // odbiór znaku do bufora
83. }
84.  
85. //--------------------Koniec deklaracji użytkownika-----------------------------------------------    
86.  
87. char T1=30,T2=20,T3=50,stank=1,a,b,c,d,znak;
88. char stan=1,KL,LD,tim;
89.  
90. //---------------------- Koniec deklaracji użytkownika ----------------------------------
91. int main(void)
92. {
93.         DDRA  = 0xff;                                   // Kierunek portu A (diody LED): port wyjściowy
94.         DDRB  = 0x00;                                   // Kierunek portu B (klawisze) : port wejściowy
95.         PORTA = 0xff;                                   // Port A (diody LED): ustaw "1" (wygaszone diody)
96.         PORTB = 0xff;                                   // Port B (klawisze) : aktywne rezystory podciągające
97.        
98.         TCCR0 = _BV(WGM01)|_BV(CS02);   // Timer/Counter 0: tryb CTC, dzielnik=256
99.         OCR0  = 124;                                    // Limit zliczania T0: 0.125us x 256 x (124+1) = 4ms
100.         TIMSK = _BV(OCIE0);                             // Odblokowanie przewań T0 (Output Compare Match)
101.         sei();                                                  // Globalne włączenie obsługi przerwań
102.  
103.         LCD_init();                                             // Inicjowanie wyświetlacza LCD
104.         UART_init(9600);
105.         while(1)
106.         {
107.                 cykl = TCYKL;                           // Deklarowany czas cyklu (TCYKL x 4ms)
108.                 KEY_read();                                     // Odczyt stanu klawiszy aK1..aK4
109.                 //-------------- Początek kodu użytkownika --------------------------------------
110.                
111.                 switch (stan) {
112.                 case 1:
113.                         LD=0;
114.                         if (KL) {tim = T1; stan=2;} break;
115.                 case 2:
116.                         LD=1;
117.                         if (!KL) stan=1; else if (!tim) {stan =3; tim=T2;} break;
118.                 case 3:
119.                         LD=0;
120.                         if (!KL) stan=1; else if (!tim) {stan =4; tim=T3;} break;
121.                 case 4:
122.                         LD=1;
123.                         if (!tim && !KL) stan = 1; else if (!tim && KL) stan = 5; break;
124.                 case 5:
125.                         LD=0;
126.                         if (!KL) stan = 1; break;
127.                 }
128.                 znak = COM_recv() & 0x7f;
129.                 if (znak)
130.                 switch (stank) {
131.                 case 1: if (znak == ':') stank = 2; else stank = 1; break;
132.                 case 2:
133.                         if (znak >= '0' && znak <= '8') {stank = 3;a=znak-'0';}
134.                         else stank=1;break;
135.                 case 3:
136.                         if (znak >= '0' && znak <='9') {stank=4;b=znak-'0';}
137.                         else if (znak == '#' && a==0) {
138.                                 COM_send(':');
139.                                 COM_send(T1/10+'0');
140.                                 COM_send(T2/10+'0');
141.                                 COM_send(T3/100+'0');
142.                                 COM_send((T3%100)/10+'0');
143.                                 COM_send((4-(T1/10+T2/10+T3/10)%4)%4 + '0');
144.                                 COM_send('#'); stank=1;
145.                         } else stank=1; break;
146.                 case 4:
147.                         if (znak >='1' && znak <= '3') {stank=5;c=znak-'0';}
148.                         else if (znak == '#' && a < 2 && b == !a) {KL=a;stank=1;}
149.                         else stank=1; break;
150.                 case 5:
151.                         if (znak == 'A') {stank=6;d=znak-'0';}
152.                         else if (znak == '#' && a>1 && a<9 && b>1 && b<9 &&
153.                                 (a+b+c)%2==1){ T1=a*10;T2=b*10;stank=1;}
154.                         else stank=1; break;
155.                 case 6:
156.                         if (znak == '#' && a>=0 && a<=2 && (a==0)?(b>4):(b>=0) && b <= 9 && (a*10+b+c)%4==0)
157.                         { T3=a*100+b*10;stank=1;}
158.                         else stank=1; break;
159.                 }
160.                 L1=LD;
161.                 if (tim) --tim;
162.                 //-------------- Wyświetlacz LCD --------------
163.                 sprintf(buf,"K1=%dK2=%dK3=%dK4=%d",(int)aK1,(int)aK2,(int)aK3,(int)aK4);
164.                 LCD_xy(0,0);                            // Ustawienie kursora w linii 1
165.                 LCD_puts(buf);                          // Wyświetlenie zawartości bufora
166.                 sprintf(buf,"L1=%dL2=%dL3=%dL4=%d",(int)L1,(int)L2,(int)L3,(int)L4);
167.                 LCD_xy(0,1);                            // Ustawienie kursora w linii 2
168.                 LCD_puts(buf);                          // Wyświetlenie zawartości bufora
169.                
170.                 //-------------- Koniec kodu użytkownika ----------------------------------------
171.                 LED_set();                                      // Ustawienie diod LED
172.                 //KEY_mem();                            // Zapamiętanie stanu klawiszy w pK1..pK4
173.                
174.                 while(cykl);                            // Oczekiwanie na koniec cyklu oblicz.
175.         }
176.         return 0;
177. }
178.  
179. //---------------------- Funkcje obsługi przerwań ---------------------------------------
180.  
181. ISR(TIMER0_COMP_vect)                           // Przerwanie od Timer/Counter 0 (co 4ms)
182. {
183.         if(cykl) --cykl;                                // Odmierzanie czasu cyklu pętli głównej
184. }
185.  
186.