Rev 2972 Rev 2975
1 /* 1 /*
2 ChibiOS/RT - Copyright (C) 2006-2013 Giovanni Di Sirio 2 ChibiOS/RT - Copyright (C) 2006-2013 Giovanni Di Sirio
3   3  
4 Licensed under the Apache License, Version 2.0 (the "License"); 4 Licensed under the Apache License, Version 2.0 (the "License");
5 you may not use this file except in compliance with the License. 5 you may not use this file except in compliance with the License.
6 You may obtain a copy of the License at 6 You may obtain a copy of the License at
7   7  
8 http://www.apache.org/licenses/LICENSE-2.0 8 http://www.apache.org/licenses/LICENSE-2.0
9   9  
10 Unless required by applicable law or agreed to in writing, software 10 Unless required by applicable law or agreed to in writing, software
11 distributed under the License is distributed on an "AS IS" BASIS, 11 distributed under the License is distributed on an "AS IS" BASIS,
12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 See the License for the specific language governing permissions and 13 See the License for the specific language governing permissions and
14 limitations under the License. 14 limitations under the License.
15 */ 15 */
16   16  
17 #include "ch.h" 17 #include "ch.h"
18 #include "hal.h" 18 #include "hal.h"
19 #include "test.h" 19 #include "test.h"
20 #include "serial.h" 20 #include "serial.h"
21 #include "gpt.h" 21 #include "gpt.h"
22 #include <string.h> 22 #include <string.h>
23 #include "keil/GPS_dekoduj.h" 23 #include "keil/GPS_dekoduj.h"
24 #include <../../os/various/chprintf.h> 24 #include <../../os/various/chprintf.h>
25 #include <chstreams.h.> 25 #include <chstreams.h.>
26   26  
27 /*MAX delka prikazu, ktery uzivatel muze zadat*/ 27 /*MAX delka prikazu, ktery uzivatel muze zadat*/
28 #define MAX_DELKA_PRIKAZU 10 28 #define MAX_DELKA_PRIKAZU 10
29   29  
30 /*Velikost GPS bufferu*/ 30 /*Velikost GPS bufferu*/
31 #define GPS_BUFFER 500 31 #define GPS_BUFFER 500
32 #define PWM_PERIODA_NORMAL 20000 32 #define PWM_PERIODA_NORMAL 20000
33 #define PWM_SIRKA_NORMAL PWM_PERIODA_NORMAL/2 33 #define PWM_SIRKA_NORMAL PWM_PERIODA_NORMAL/2
34   34  
35 /*Pocet opakovani pro jednotlive faze odpalu (pocet = cas[s]*8) pro kompenzaci 8xrychlejsiho casovace na desce STM32F10xRxT01A */ 35 /*Pocet opakovani pro jednotlive faze odpalu (pocet = cas[s]*8) pro kompenzaci 8xrychlejsiho casovace na desce STM32F10xRxT01A */
-   36 #define TIMER_COMPENSATION 16
36 #define POCET_VENTIL (5*8) 37 #define POCET_VENTIL (5*TIMER_COMPENSATION)
37 #define POCET_LIS (1*8) 38 #define POCET_LIS (1*TIMER_COMPENSATION)
38 #define POCET_ZATAVENI (2*8) 39 #define POCET_ZATAVENI (10*TIMER_COMPENSATION)
39 #define POCET_STRECHA (5*8) 40 #define POCET_STRECHA (5*TIMER_COMPENSATION)
40 #define CEKANI_NA_STRECHU (10*8) 41 #define CEKANI_NA_STRECHU (10*TIMER_COMPENSATION)
41 #define CEKANI_NA_LIS (10*8) 42 #define CEKANI_NA_LIS (10*TIMER_COMPENSATION)
42   43  
43 /*makra pro cteni switch sensoru*/ 44 /*makra pro cteni switch sensoru*/
44 #define CTI_STRECHU palReadPad(STRECHA_SENS_PORT, STRECHA_SENS_STATE) 45 #define CTI_STRECHU palReadPad(STRECHA_SENS_PORT, STRECHA_SENS_STATE)
45 #define CTI_LIS palReadPad(LIS_SENS_PORT, LIS_SENS_STATE) 46 #define CTI_LIS palReadPad(LIS_SENS_PORT, LIS_SENS_STATE)
46   47  
47 extern NMEA_GPGGA GPGGA_informace; 48 extern NMEA_GPGGA GPGGA_informace;
48 Thread *tp_odpal = NULL; 49 Thread *tp_odpal = NULL;
49 uint8_t uvitaci_zprava[] = "\r\n\r\n* * * * * * * * * * * * * * * * * * * * * * * * * *\r\nVita vas Automaticky Vypoustec Meteobalonu 1.1\r\nZapojeni vyvodu:\r\n\tGPIOB10 - strecha\r\n\tGPIOB11 - ventil\r\n\tGPIOB12 - lis\r\n\tGPIOB13 - zataveni/odpojeni\r\nPrikazy:\r\n\t<odpal> zahajeni sekvence vypousteni\n\r\t<zrus> zruseni vypousteni\n\r\t<help> napoveda\r\n* * * * * * * * * * * * * * * * * * * * * * * * * *\r\n\r\n"; 50 uint8_t uvitaci_zprava[] = "\r\n\r\n* * * * * * * * * * * * * * * * * * * * * * * * * *\r\nVita vas Automaticky Vypoustec Meteobalonu 1.1\r\nZapojeni vyvodu:\r\n\tGPIOB10 - strecha\r\n\tGPIOB11 - ventil\r\n\tGPIOB12 - lis\r\n\tGPIOB13 - zataveni/odpojeni\r\nPrikazy:\r\n\t<odpal> zahajeni sekvence vypousteni\n\r\t<zrus> zruseni vypousteni\n\r\t<help> napoveda\r\n* * * * * * * * * * * * * * * * * * * * * * * * * *\r\n\r\n";
50   51  
51 //static PWMConfig pwmcfg = { 52 //static PWMConfig pwmcfg = {
52 //10000, /* 10kHz PWM clock frequency. */ 53 //10000, /* 10kHz PWM clock frequency. */
53 //PWM_PERIODA_NORMAL, /* PWM period 1S (in ticks). */ 54 //PWM_PERIODA_NORMAL, /* PWM period 1S (in ticks). */
54 /*NULL, 55 /*NULL,
55 { 56 {
56 {PWM_OUTPUT_ACTIVE_HIGH, NULL}, 57 {PWM_OUTPUT_ACTIVE_HIGH, NULL},
57 {PWM_OUTPUT_ACTIVE_HIGH, NULL}, 58 {PWM_OUTPUT_ACTIVE_HIGH, NULL},
58 {PWM_OUTPUT_DISABLED, NULL}, 59 {PWM_OUTPUT_DISABLED, NULL},
59 {PWM_OUTPUT_DISABLED, NULL} 60 {PWM_OUTPUT_DISABLED, NULL}
60 }, 61 },
61 HW dependent part.*/ 62 HW dependent part.*/
62 //0 63 //0
63 //}; 64 //};
64   65  
65 /* 66 /*
66 * Konfigurace USART2 67 * Konfigurace USART2
67 */ 68 */
68   69  
69 static const SerialConfig USART2_config = 70 static const SerialConfig USART2_config =
70 { 71 {
71 /*Speed*/ 72 /*Speed*/
72 9600, 73 9600,
73 /*Initialization value for the CR1 register.*/ 74 /*Initialization value for the CR1 register.*/
74 0, 75 0,
75 /*Initialization value for the CR2 register.*/ 76 /*Initialization value for the CR2 register.*/
76 USART_CR2_STOP1_BITS | USART_CR2_LINEN, 77 USART_CR2_STOP1_BITS | USART_CR2_LINEN,
77 /*Initialization value for the CR3 register.*/ 78 /*Initialization value for the CR3 register.*/
78 0 79 0
79 }; 80 };
80   81  
81   82  
82 /* 83 /*
83 * GPT2 callback. 84 * GPT2 callback.
84 */ 85 */
85 static void gpt2cb(GPTDriver *gptp) 86 static void gpt2cb(GPTDriver *gptp)
86 { 87 {
87 (void)gptp; 88 (void)gptp;
88 /* Wakes up the thread.*/ 89 /* Wakes up the thread.*/
89 chSysLockFromIsr(); 90 chSysLockFromIsr();
90 if (tp_odpal != NULL) { 91 if (tp_odpal != NULL) {
91 tp_odpal->p_u.rdymsg = (msg_t)50; /* Znaci, ze se vlakno probouzi kvuli preruseni od GPT*/ 92 tp_odpal->p_u.rdymsg = (msg_t)50; /* Znaci, ze se vlakno probouzi kvuli preruseni od GPT*/
92 chSchReadyI(tp_odpal); 93 chSchReadyI(tp_odpal);
93 tp_odpal = NULL; 94 tp_odpal = NULL;
94 } 95 }
95 chSysUnlockFromIsr(); 96 chSysUnlockFromIsr();
96 } 97 }
97   98  
98   99  
99 /* 100 /*
100 *Konfigurace casovace 2 101 *Konfigurace casovace 2
101 */ 102 */
102 static const GPTConfig gpt2cfg = 103 static const GPTConfig gpt2cfg =
103 { 104 {
104 500, /*500 Hz ? (puvodne 1000Hz) f*/ 105 1000, /* 1000Hz f*/
105 gpt2cb /*callback fce*/ 106 gpt2cb /*callback fce*/
106 }; 107 };
107   108  
108 /* 109 /*
109 * Vlakno pro blikani diodou 110 * Vlakno pro blikani diodou
110 */ 111 */
111 static WORKING_AREA(waThread1, 128); 112 static WORKING_AREA(waThread1, 128);
112 static msg_t Thread1(void *arg) { 113 static msg_t Thread1(void *arg) {
113 (void)arg; 114 (void)arg;
114 chRegSetThreadName("blinker"); 115 chRegSetThreadName("blinker");
115 while (TRUE) { 116 while (TRUE) {
116 palClearPad(GPIOB, GPIOB_LED4); 117 palClearPad(GPIOB, GPIOB_LED4);
117 chThdSleepMilliseconds(500); 118 chThdSleepMilliseconds(500);
118 palSetPad(GPIOB, GPIOB_LED4); 119 palSetPad(GPIOB, GPIOB_LED4);
119 chThdSleepMilliseconds(500); 120 chThdSleepMilliseconds(500);
120 } 121 }
121 } 122 }
122   123  
123 /* 124 /*
124 * Vlakno pro ovladani odpalovaci sekvence 125 * Vlakno pro ovladani odpalovaci sekvence
125 */ 126 */
126 static WORKING_AREA(waThread_odpal, 128); 127 static WORKING_AREA(waThread_odpal, 128);
127 static msg_t Thread_odpal(void *arg) { 128 static msg_t Thread_odpal(void *arg) {
128 uint8_t stav = 0; // rika, ve ktere fazi je odpalovani 129 uint8_t stav = 0; // rika, ve ktere fazi je odpalovani
129 uint8_t odpal_povolen = 0; 130 uint8_t odpal_povolen = 0;
130 uint8_t odpal_pomocna = 0; 131 uint8_t odpal_pomocna = 0;
131 uint16_t pocet_opakovani = 1; 132 uint16_t pocet_opakovani = 1;
132 uint16_t perioda_casovace = 500; // changing to 8*500 = 400 133 uint16_t perioda_casovace = 500; // changing to 8*500 = 400
133 (void)arg; 134 (void)arg;
134 chRegSetThreadName("Odpal_vlakno"); 135 chRegSetThreadName("Odpal_vlakno");
135 136
136 while (TRUE) 137 while (TRUE)
137 { 138 {
138 msg_t msg; 139 msg_t msg;
139   140  
140 /* Waiting for the IRQ to happen.*/ 141 /* Waiting for the IRQ to happen.*/
141 chSysLock(); 142 chSysLock();
142 tp_odpal = chThdSelf(); 143 tp_odpal = chThdSelf();
143 chSchGoSleepS(THD_STATE_SUSPENDED); 144 chSchGoSleepS(THD_STATE_SUSPENDED);
144 msg = chThdSelf()->p_u.rdymsg; /* Retrieving the message, optional.*/ 145 msg = chThdSelf()->p_u.rdymsg; /* Retrieving the message, optional.*/
145 chSysUnlock(); 146 chSysUnlock();
146 147
147 /* Perform processing here.*/ 148 /* Perform processing here.*/
148 if(msg == 1) 149 if(msg == 1)
149 { 150 {
150 odpal_povolen = 1; 151 odpal_povolen = 1;
151 odpal_pomocna++; 152 odpal_pomocna++;
152 stav = 0; 153 stav = 0;
153 pocet_opakovani = 1; 154 pocet_opakovani = 1;
154 } 155 }
155 else if (msg == 2) //Pokud se ma odpal zrusit v prubehu vypousteni 156 else if (msg == 2) //Pokud se ma odpal zrusit v prubehu vypousteni
156 { 157 {
157 /* 158 /*
158 * Pro jistotu se vypnou vsechny vystupy pri zruseni odpalu 159 * Pro jistotu se vypnou vsechny vystupy pri zruseni odpalu
159 */ 160 */
160 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN10); 161 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN10);
161 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN11); 162 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN11);
162 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN12); 163 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN12);
163 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN13); 164 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN13);
164 palSetPad(IND_LEDS_PORT, LED_STRECHA); 165 palSetPad(IND_LEDS_PORT, LED_STRECHA);
165 palSetPad(IND_LEDS_PORT, LED_LIS); 166 palSetPad(IND_LEDS_PORT, LED_LIS);
166 palSetPad(IND_LEDS_PORT, LED_VENTIL); 167 palSetPad(IND_LEDS_PORT, LED_VENTIL);
167 palSetPad(IND_LEDS_PORT, LED_ZATAVENI); 168 palSetPad(IND_LEDS_PORT, LED_ZATAVENI);
168 169
169 if(odpal_povolen == 1) 170 if(odpal_povolen == 1)
170 chprintf((BaseSequentialStream *)&SD1,"\r\nOdpal zrusen uzivatelem.\r\n"); 171 chprintf((BaseSequentialStream *)&SD1,"\r\nOdpal zrusen uzivatelem.\r\n");
171 else 172 else
172 chprintf((BaseSequentialStream *)&SD1,"Odpal nebyl aktivovan.\r\n"); 173 chprintf((BaseSequentialStream *)&SD1,"Odpal nebyl aktivovan.\r\n");
173 174
174 odpal_povolen = 0; 175 odpal_povolen = 0;
175 odpal_pomocna = 0; 176 odpal_pomocna = 0;
176 stav = 0; 177 stav = 0;
177 pocet_opakovani = 1; 178 pocet_opakovani = 1;
178 } 179 }
179 else if (msg == 50 && odpal_povolen == 1) // preruseni od GPT 180 else if (msg == 50 && odpal_povolen == 1) // preruseni od GPT
180 { 181 {
181 odpal_pomocna = 1; 182 odpal_pomocna = 1;
182 } 183 }
183 if (odpal_povolen == 1 && odpal_pomocna <= 1) 184 if (odpal_povolen == 1 && odpal_pomocna <= 1)
184 { 185 {
185 odpal_pomocna = 2; // aby nepretekla tato promenna 186 odpal_pomocna = 2; // aby nepretekla tato promenna
186 switch (stav) 187 switch (stav)
187 { 188 {
188 case 0: // ukonceni tohoto stavu pouze v pripade, ze je otevrena strecha 189 case 0: // ukonceni tohoto stavu pouze v pripade, ze je otevrena strecha
189 if (pocet_opakovani == 1) 190 if (pocet_opakovani == 1)
190 chprintf((BaseSequentialStream *)&SD1,"Vypousteni zahajeno!\r\n"); 191 chprintf((BaseSequentialStream *)&SD1,"Vypousteni zahajeno!\r\n");
191 192
192 if (pocet_opakovani <= POCET_STRECHA) 193 if (pocet_opakovani <= POCET_STRECHA)
193 { 194 {
194 chprintf((BaseSequentialStream *)&SD1,"(1/4)\tOtevirani vika... Strecha: %d, Zbyva: %3d \r",CTI_STRECHU,(POCET_STRECHA-pocet_opakovani)); 195 chprintf((BaseSequentialStream *)&SD1,"(1/4)\tOtevirani vika... Strecha: %d, Zbyva: %3d \r",CTI_STRECHU,(POCET_STRECHA-pocet_opakovani));
195 palSetPad(GPIOB, GPIOB_PIN10); 196 palSetPad(GPIOB, GPIOB_PIN10);
196 palClearPad(IND_LEDS_PORT, LED_STRECHA); 197 palClearPad(IND_LEDS_PORT, LED_STRECHA);
197 gptStartOneShot(&GPTD2,perioda_casovace); 198 gptStartOneShot(&GPTD2,perioda_casovace);
198 pocet_opakovani++; 199 pocet_opakovani++;
199 if (pocet_opakovani == (POCET_STRECHA+1)) 200 if (pocet_opakovani == (POCET_STRECHA+1))
200 { 201 {
201 chprintf((BaseSequentialStream *)&SD1,"\r\n"); 202 chprintf((BaseSequentialStream *)&SD1,"\r\n");
202 stav++; 203 stav++;
203 pocet_opakovani = 1; 204 pocet_opakovani = 1;
204 } 205 }
205 } 206 }
206 break; 207 break;
207 case 1: 208 case 1:
208 // kontrola strechy - maximalni cas prepalovani 209 // kontrola strechy - maximalni cas prepalovani
209 gptStartOneShot(&GPTD2,perioda_casovace); 210 gptStartOneShot(&GPTD2,perioda_casovace);
210 if (CTI_STRECHU) 211 if (CTI_STRECHU)
211 { 212 {
212 chprintf((BaseSequentialStream *)&SD1,"Strecha otevrena. Pokracovani v napousteni.\r\n"); 213 chprintf((BaseSequentialStream *)&SD1,"Strecha otevrena. Pokracovani v napousteni.\r\n");
213 pocet_opakovani = 1; 214 pocet_opakovani = 1;
214 stav++; 215 stav++;
215 } 216 }
216 else 217 else
217 { 218 {
218 if(pocet_opakovani <= CEKANI_NA_STRECHU){ 219 if(pocet_opakovani <= CEKANI_NA_STRECHU){
219 chprintf((BaseSequentialStream *)&SD1,"Cekani na otevreni strechy.\r"); 220 chprintf((BaseSequentialStream *)&SD1,"Cekani na otevreni strechy.\r");
220 pocet_opakovani++; 221 pocet_opakovani++;
221 } 222 }
222 else { // prekroceni maximalni doby pro odpaleni strechy 223 else { // prekroceni maximalni doby pro odpaleni strechy
223 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN10); 224 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN10);
224 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN11); 225 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN11);
225 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN12); 226 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN12);
226 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN13); 227 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN13);
227 palSetPad(IND_LEDS_PORT, LED_STRECHA); 228 palSetPad(IND_LEDS_PORT, LED_STRECHA);
228 palSetPad(IND_LEDS_PORT, LED_LIS); 229 palSetPad(IND_LEDS_PORT, LED_LIS);
229 palSetPad(IND_LEDS_PORT, LED_VENTIL); 230 palSetPad(IND_LEDS_PORT, LED_VENTIL);
230 palSetPad(IND_LEDS_PORT, LED_ZATAVENI); 231 palSetPad(IND_LEDS_PORT, LED_ZATAVENI);
231 chprintf((BaseSequentialStream *)&SD1,"\r\nNelze otevrit strechu.\r\n"); 232 chprintf((BaseSequentialStream *)&SD1,"\r\nNelze otevrit strechu.\r\n");
232 233
233 odpal_povolen = 0; 234 odpal_povolen = 0;
234 odpal_pomocna = 0; 235 odpal_pomocna = 0;
235 stav = 0; 236 stav = 0;
236 pocet_opakovani = 1; 237 pocet_opakovani = 1;
237 } 238 }
238 } 239 }
239 break; 240 break;
240 case 2: 241 case 2:
241 if (pocet_opakovani <= POCET_VENTIL) 242 if (pocet_opakovani <= POCET_VENTIL)
242 { 243 {
243 palClearPad(GPIOB, GPIOB_PIN10); 244 palClearPad(GPIOB, GPIOB_PIN10);
244 palSetPad(IND_LEDS_PORT, LED_STRECHA); 245 palSetPad(IND_LEDS_PORT, LED_STRECHA);
245 palSetPad(GPIOB, GPIOB_PIN11); 246 palSetPad(GPIOB, GPIOB_PIN11);
246 palClearPad(IND_LEDS_PORT, LED_VENTIL); 247 palClearPad(IND_LEDS_PORT, LED_VENTIL);
247 chprintf((BaseSequentialStream *)&SD1,"(2/4)\tVentil otevren -> nafukovani balonu... Strecha: %d, Zbyva: %3d\r",CTI_STRECHU,(POCET_VENTIL-pocet_opakovani)); 248 chprintf((BaseSequentialStream *)&SD1,"(2/4)\tVentil otevren -> nafukovani balonu... Strecha: %d, Zbyva: %3d\r",CTI_STRECHU,(POCET_VENTIL-pocet_opakovani));
248 gptStartOneShot(&GPTD2,perioda_casovace); 249 gptStartOneShot(&GPTD2,perioda_casovace);
249 pocet_opakovani++; 250 pocet_opakovani++;
250 if (pocet_opakovani == (POCET_VENTIL+1)) 251 if (pocet_opakovani == (POCET_VENTIL+1))
251 { 252 {
252 chprintf((BaseSequentialStream *)&SD1,"\r\n"); 253 chprintf((BaseSequentialStream *)&SD1,"\r\n");
253 stav++; 254 stav++;
254 pocet_opakovani = 1; 255 pocet_opakovani = 1;
255 } 256 }
256 } 257 }
257 break; 258 break;
258 case 3: 259 case 3:
259 if (pocet_opakovani <= POCET_LIS) 260 if (pocet_opakovani <= POCET_LIS)
260 { 261 {
261 palClearPad(GPIOB, GPIOB_PIN11); 262 palClearPad(GPIOB, GPIOB_PIN11);
262 palSetPad(IND_LEDS_PORT, LED_VENTIL); 263 palSetPad(IND_LEDS_PORT, LED_VENTIL);
263 palSetPad(GPIOB, GPIOB_PIN12); 264 palSetPad(GPIOB, GPIOB_PIN12);
264 palClearPad(IND_LEDS_PORT, LED_LIS); 265 palClearPad(IND_LEDS_PORT, LED_LIS);
265 chprintf((BaseSequentialStream *)&SD1,"(3/4)\tPrepalovani lisu... Lis: %d, Zbyva: %3d\r",CTI_LIS,(POCET_LIS-pocet_opakovani)); 266 chprintf((BaseSequentialStream *)&SD1,"(3/4)\tPrepalovani lisu... Lis: %d, Zbyva: %3d\r",CTI_LIS,(POCET_LIS-pocet_opakovani));
266 gptStartOneShot(&GPTD2,perioda_casovace); 267 gptStartOneShot(&GPTD2,perioda_casovace);
267 pocet_opakovani++; 268 pocet_opakovani++;
268 if (pocet_opakovani == (POCET_LIS+1)) 269 if (pocet_opakovani == (POCET_LIS+1))
269 { 270 {
270 chprintf((BaseSequentialStream *)&SD1,"\r\n"); 271 chprintf((BaseSequentialStream *)&SD1,"\r\n");
271 stav++; 272 stav++;
272 pocet_opakovani = 1; 273 pocet_opakovani = 1;
273 } 274 }
274 } 275 }
275 break; 276 break;
276 case 4: // kontrola prepaleni lisu 277 case 4: // kontrola prepaleni lisu
277 gptStartOneShot(&GPTD2,perioda_casovace); 278 gptStartOneShot(&GPTD2,perioda_casovace);
278 if (CTI_LIS) 279 if (CTI_LIS)
279 { 280 {
280 chprintf((BaseSequentialStream *)&SD1,"Lis stlacen. Pokracovani v pretavovani.\r\n"); 281 chprintf((BaseSequentialStream *)&SD1,"Lis stlacen. Pokracovani v pretavovani.\r\n");
281 pocet_opakovani = 1; 282 pocet_opakovani = 1;
282 stav++; 283 stav++;
283 } 284 }
284 else 285 else
285 { 286 {
286 if(pocet_opakovani <= CEKANI_NA_LIS){ 287 if(pocet_opakovani <= CEKANI_NA_LIS){
287 chprintf((BaseSequentialStream *)&SD1,"Cekani na stlaceni lisu.\r"); 288 chprintf((BaseSequentialStream *)&SD1,"Cekani na stlaceni lisu.\r");
288 pocet_opakovani++; 289 pocet_opakovani++;
289 } 290 }
290 else { // prekroceni maximalni doby pro slisovani 291 else { // prekroceni maximalni doby pro slisovani
291 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN10); 292 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN10);
292 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN11); 293 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN11);
293 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN12); 294 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN12);
294 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN13); 295 palClearPad(NFET_OUTPUTS_PORT, GPIOB_PIN13);
295 palSetPad(IND_LEDS_PORT, LED_STRECHA); 296 palSetPad(IND_LEDS_PORT, LED_STRECHA);
296 palSetPad(IND_LEDS_PORT, LED_LIS); 297 palSetPad(IND_LEDS_PORT, LED_LIS);
297 palSetPad(IND_LEDS_PORT, LED_VENTIL); 298 palSetPad(IND_LEDS_PORT, LED_VENTIL);
298 palSetPad(IND_LEDS_PORT, LED_ZATAVENI); 299 palSetPad(IND_LEDS_PORT, LED_ZATAVENI);
299 chprintf((BaseSequentialStream *)&SD1,"\r\nNelze spustit lis.\r\n"); 300 chprintf((BaseSequentialStream *)&SD1,"\r\nNelze spustit lis.\r\n");
300 301
301 odpal_povolen = 0; 302 odpal_povolen = 0;
302 odpal_pomocna = 0; 303 odpal_pomocna = 0;
303 stav = 0; 304 stav = 0;
304 pocet_opakovani = 1; 305 pocet_opakovani = 1;
305 } 306 }
306 } 307 }
307 break; 308 break;
308 case 5: 309 case 5:
309 if (pocet_opakovani <= POCET_ZATAVENI) 310 if (pocet_opakovani <= POCET_ZATAVENI)
310 { 311 {
311 palClearPad(GPIOB, GPIOB_PIN12); 312 palClearPad(GPIOB, GPIOB_PIN12);
312 palSetPad(IND_LEDS_PORT, LED_LIS); 313 palSetPad(IND_LEDS_PORT, LED_LIS);
313 palSetPad(GPIOB, GPIOB_PIN13); 314 palSetPad(GPIOB, GPIOB_PIN13);
314 palClearPad(IND_LEDS_PORT, LED_ZATAVENI); 315 palClearPad(IND_LEDS_PORT, LED_ZATAVENI);
315 chprintf((BaseSequentialStream *)&SD1,"(4/4)\tZatavovani balonu... Lis: %d, Zbyva: %3d \r",CTI_LIS,(POCET_ZATAVENI-pocet_opakovani)); 316 chprintf((BaseSequentialStream *)&SD1,"(4/4)\tZatavovani balonu... Lis: %d, Zbyva: %3d \r",CTI_LIS,(POCET_ZATAVENI-pocet_opakovani));
316 gptStartOneShot(&GPTD2,perioda_casovace); 317 gptStartOneShot(&GPTD2,perioda_casovace);
317 pocet_opakovani++; 318 pocet_opakovani++;
318 if (pocet_opakovani == (POCET_ZATAVENI+1)) 319 if (pocet_opakovani == (POCET_ZATAVENI+1))
319 { 320 {
320 chprintf((BaseSequentialStream *)&SD1,"\r\n"); 321 chprintf((BaseSequentialStream *)&SD1,"\r\n");
321 stav++; 322 stav++;
322 pocet_opakovani = 1; 323 pocet_opakovani = 1;
323 } 324 }
324 } 325 }
325 break; 326 break;
326 case 6: 327 case 6:
327 palClearPad(GPIOB, GPIOB_PIN13); 328 palClearPad(GPIOB, GPIOB_PIN13);
328 palSetPad(IND_LEDS_PORT, LED_ZATAVENI); 329 palSetPad(IND_LEDS_PORT, LED_ZATAVENI);
329 chprintf((BaseSequentialStream *)&SD1,"Vypousteni ukonceno!\r\n"); 330 chprintf((BaseSequentialStream *)&SD1,"Vypousteni ukonceno!\r\n");
330 odpal_povolen = 0; 331 odpal_povolen = 0;
331 odpal_pomocna = 0; 332 odpal_pomocna = 0;
332 stav = 0; 333 stav = 0;
333 break; 334 break;
334 default: 335 default:
335 chprintf((BaseSequentialStream *)&SD1,"NIC!\r\n"); 336 chprintf((BaseSequentialStream *)&SD1,"NIC!\r\n");
336 break; 337 break;
337 } 338 }
338 } 339 }
339 } 340 }
340 } 341 }
341   342  
342   343  
343 /* 344 /*
344 * Vlakno pro obsluhu GPS prijimace 345 * Vlakno pro obsluhu GPS prijimace
345 */ 346 */
346 static WORKING_AREA(waThread_GPS, 768); 347 static WORKING_AREA(waThread_GPS, 768);
347 static msg_t Thread_GPS(void *arg) { 348 static msg_t Thread_GPS(void *arg) {
348 /* 349 /*
349 * Nacita se jen nekolik NMEA zprav, aby se neplytvalo pameti na ulozeni kompletniho 350 * Nacita se jen nekolik NMEA zprav, aby se neplytvalo pameti na ulozeni kompletniho
350 * setu s tím rizikem, ze se nekdy nenacte aktualni informace o poloze. 351 * setu s tím rizikem, ze se nekdy nenacte aktualni informace o poloze.
351 */ 352 */
352 uint8_t inBuffer[GPS_BUFFER]; 353 uint8_t inBuffer[GPS_BUFFER];
353 char *zacatek_retezce; 354 char *zacatek_retezce;
354 char *konec_retezce; 355 char *konec_retezce;
355 uint8_t pocet_znaku; 356 uint8_t pocet_znaku;
356 uint8_t NMEA_zprava[100]; 357 uint8_t NMEA_zprava[100];
357   358  
358 (void)arg; 359 (void)arg;
359 chRegSetThreadName("GPS_NMEA"); 360 chRegSetThreadName("GPS_NMEA");
360   361  
361 while (TRUE) { 362 while (TRUE) {
362 chThdSleepMilliseconds(1000); //neni potreba data vycitat rychleji 363 chThdSleepMilliseconds(1000); //neni potreba data vycitat rychleji
363 sdRead(&SD2,inBuffer,GPS_BUFFER); 364 sdRead(&SD2,inBuffer,GPS_BUFFER);
364 365
365 /* 366 /*
366 *Nejprve se vycte cast NMEA dat, pote se vyhleda retezec GPGGA zpravy, ta se vyparsuje a pomoci fce 367 *Nejprve se vycte cast NMEA dat, pote se vyhleda retezec GPGGA zpravy, ta se vyparsuje a pomoci fce
367 *dekoduj_zpravu_GPS, ktera vyparsuje data o poloze a jine, a ulozi je do struktury GPGGA_informace. 368 *dekoduj_zpravu_GPS, ktera vyparsuje data o poloze a jine, a ulozi je do struktury GPGGA_informace.
368 */ 369 */
369   370  
370 if ((zacatek_retezce = strstr((char *)inBuffer,"$GPGGA")) != NULL) 371 if ((zacatek_retezce = strstr((char *)inBuffer,"$GPGGA")) != NULL)
371 { 372 {
372 if ((konec_retezce = strstr(zacatek_retezce,"*")) != NULL) 373 if ((konec_retezce = strstr(zacatek_retezce,"*")) != NULL)
373 { 374 {
374 pocet_znaku = (konec_retezce-zacatek_retezce)/sizeof(char); 375 pocet_znaku = (konec_retezce-zacatek_retezce)/sizeof(char);
375 if (pocet_znaku > 100) 376 if (pocet_znaku > 100)
376 { 377 {
377 pocet_znaku = 100; 378 pocet_znaku = 100;
378 } 379 }
379 strncpy((char *)NMEA_zprava,zacatek_retezce,pocet_znaku); 380 strncpy((char *)NMEA_zprava,zacatek_retezce,pocet_znaku);
380 dekoduj_zpravu_GPS(&NMEA_zprava[0],pocet_znaku); 381 dekoduj_zpravu_GPS(&NMEA_zprava[0],pocet_znaku);
381 sdWrite(&SD2,"Latitude: ",sizeof("Latitude: ")/sizeof(char)); 382 sdWrite(&SD2,"Latitude: ",sizeof("Latitude: ")/sizeof(char));
382 sdWrite(&SD2,GPGGA_informace.Latitude,sizeof(GPGGA_informace.Latitude)/sizeof(uint8_t)); 383 sdWrite(&SD2,GPGGA_informace.Latitude,sizeof(GPGGA_informace.Latitude)/sizeof(uint8_t));
383 sdWrite(&SD2,"\r\n",2); 384 sdWrite(&SD2,"\r\n",2);
384 sdWrite(&SD2,"Longitude: ",sizeof("Longitude: ")/sizeof(char)); 385 sdWrite(&SD2,"Longitude: ",sizeof("Longitude: ")/sizeof(char));
385 sdWrite(&SD2,GPGGA_informace.Longitude,sizeof(GPGGA_informace.Longitude)/sizeof(uint8_t)); 386 sdWrite(&SD2,GPGGA_informace.Longitude,sizeof(GPGGA_informace.Longitude)/sizeof(uint8_t));
386 sdWrite(&SD2,"\r\n",2); 387 sdWrite(&SD2,"\r\n",2);
387 sdWrite(&SD2,"Altitude: ",sizeof("Altitude: ")/sizeof(char)); 388 sdWrite(&SD2,"Altitude: ",sizeof("Altitude: ")/sizeof(char));
388 sdWrite(&SD2,GPGGA_informace.Altitude,sizeof(GPGGA_informace.Altitude)/sizeof(uint8_t)); 389 sdWrite(&SD2,GPGGA_informace.Altitude,sizeof(GPGGA_informace.Altitude)/sizeof(uint8_t));
389 sdWrite(&SD2,"\r\n",2); 390 sdWrite(&SD2,"\r\n",2);
390 sdWrite(&SD2,"Status: ",sizeof("Status: ")/sizeof(char)); 391 sdWrite(&SD2,"Status: ",sizeof("Status: ")/sizeof(char));
391 sdWrite(&SD2,&GPGGA_informace.Status_GPS,sizeof(GPGGA_informace.Status_GPS)/sizeof(uint8_t)); 392 sdWrite(&SD2,&GPGGA_informace.Status_GPS,sizeof(GPGGA_informace.Status_GPS)/sizeof(uint8_t));
392 sdWrite(&SD2,"\r\n",2); 393 sdWrite(&SD2,"\r\n",2);
393 sdWrite(&SD2,NMEA_zprava,pocet_znaku); 394 sdWrite(&SD2,NMEA_zprava,pocet_znaku);
394 sdWrite(&SD2,"\r\n",2); 395 sdWrite(&SD2,"\r\n",2);
395 } 396 }
396 else 397 else
397 { 398 {
398 sdWrite(&SD2,"\r\n",2); 399 sdWrite(&SD2,"\r\n",2);
399 sdWrite(&SD2,"Nenalezen ukoncovaci znak NMEA zpravy *\r\n",sizeof("Nenalezen ukoncovaci znak NMEA zpravy *\r\n")/sizeof(char)); 400 sdWrite(&SD2,"Nenalezen ukoncovaci znak NMEA zpravy *\r\n",sizeof("Nenalezen ukoncovaci znak NMEA zpravy *\r\n")/sizeof(char));
400 sdWrite(&SD2,inBuffer,GPS_BUFFER); 401 sdWrite(&SD2,inBuffer,GPS_BUFFER);
401 } 402 }
402 } 403 }
403 else 404 else
404 sdWrite(&SD2,"Nenalezen zacatek GPGGA zpravy\r\n",sizeof("Nenalezen zacatek GPGGA zpravy\r\n")/sizeof(char)); 405 sdWrite(&SD2,"Nenalezen zacatek GPGGA zpravy\r\n",sizeof("Nenalezen zacatek GPGGA zpravy\r\n")/sizeof(char));
405 406
406 } 407 }
407 } 408 }
408   409  
409 void dekodujPrikaz(char *prikaz) 410 void dekodujPrikaz(char *prikaz)
410 { 411 {
411 if(strcmp(prikaz,"odpal") == 0) 412 if(strcmp(prikaz,"odpal") == 0)
412 { 413 {
413 /* Wakes up the thread.*/ 414 /* Wakes up the thread.*/
414 chSysLockFromIsr(); 415 chSysLockFromIsr();
415 if (tp_odpal != NULL) { 416 if (tp_odpal != NULL) {
416 tp_odpal->p_u.rdymsg = (msg_t)1; /* odpal povolen*/ 417 tp_odpal->p_u.rdymsg = (msg_t)1; /* odpal povolen*/
417 chSchReadyI(tp_odpal); 418 chSchReadyI(tp_odpal);
418 tp_odpal = NULL; 419 tp_odpal = NULL;
419 } 420 }
420 chSysUnlockFromIsr(); 421 chSysUnlockFromIsr();
421   422  
422 } 423 }
423 else if (strcmp(prikaz,"zrus") == 0) 424 else if (strcmp(prikaz,"zrus") == 0)
424 { 425 {
425 /* Wakes up the thread.*/ 426 /* Wakes up the thread.*/
426 chSysLockFromIsr(); 427 chSysLockFromIsr();
427 if (tp_odpal != NULL) { 428 if (tp_odpal != NULL) {
428 tp_odpal->p_u.rdymsg = (msg_t)2; /* zakazano pokracovat v odpalovaci sekvenci*/ 429 tp_odpal->p_u.rdymsg = (msg_t)2; /* zakazano pokracovat v odpalovaci sekvenci*/
429 chSchReadyI(tp_odpal); 430 chSchReadyI(tp_odpal);
430 tp_odpal = NULL; 431 tp_odpal = NULL;
431 } 432 }
432 chSysUnlockFromIsr(); 433 chSysUnlockFromIsr();
433 } 434 }
434 else if (strcmp(prikaz,"help") == 0) 435 else if (strcmp(prikaz,"help") == 0)
435 { 436 {
436 sdWrite(&SD1, uvitaci_zprava, sizeof(uvitaci_zprava)/sizeof(uint8_t)); 437 sdWrite(&SD1, uvitaci_zprava, sizeof(uvitaci_zprava)/sizeof(uint8_t));
437 } 438 }
-   439 else if(strcmp(prikaz,"check") == 0)
-   440 {
-   441 chprintf((BaseSequentialStream *)&SD1,"\r\nStav strechy: ");
-   442 if(CTI_STRECHU)
-   443 chprintf((BaseSequentialStream *)&SD1,"Otevrena\r\n");
-   444 else
-   445 chprintf((BaseSequentialStream *)&SD1,"Zavrena\r\n");
-   446 chprintf((BaseSequentialStream *)&SD1,"Stav lisu: ");
-   447 if(CTI_LIS)
-   448 chprintf((BaseSequentialStream *)&SD1,"Aktivni\r\n");
-   449 else
-   450 chprintf((BaseSequentialStream *)&SD1,"Rozepnuty\r\n");
-   451 }
438 else 452 else
439 { 453 {
440 uint8_t zp_neplatny[] = "Neplatny prikaz!\r\n\t<odpal> pro zahajeni sekvence\n\r\t<zrus> pro zruseni vypousteni\n\r"; 454 uint8_t zp_neplatny[] = "Neplatny prikaz!\r\n\t<odpal> pro zahajeni sekvence\n\r\t<zrus> pro zruseni vypousteni\n\r";
441 sdWrite(&SD1,zp_neplatny,sizeof(zp_neplatny)/sizeof(uint8_t)); 455 sdWrite(&SD1,zp_neplatny,sizeof(zp_neplatny)/sizeof(uint8_t));
442 palTogglePad(GPIOB, GPIOB_LED3); 456 palTogglePad(GPIOB, GPIOB_LED3);
443 } 457 }
444 } 458 }
445   459  
446 /* 460 /*
447 * Application entry point. 461 * Application entry point.
448 */ 462 */
449 int main(void) { 463 int main(void) {
450 464
451 uint8_t znaky[20]; 465 uint8_t znaky[20];
452 char prikaz[MAX_DELKA_PRIKAZU + 1]; 466 char prikaz[MAX_DELKA_PRIKAZU + 1];
453 uint8_t pocet_znaku = 0; 467 uint8_t pocet_znaku = 0;
454   468  
455 /* 469 /*
456 * System initializations. 470 * System initializations.
457 * - HAL initialization, this also initializes the configured device drivers 471 * - HAL initialization, this also initializes the configured device drivers
458 * and performs the board-specific initializations. 472 * and performs the board-specific initializations.
459 * - Kernel initialization, the main() function becomes a thread and the 473 * - Kernel initialization, the main() function becomes a thread and the
460 * RTOS is active. 474 * RTOS is active.
461 */ 475 */
462 halInit(); 476 halInit();
463 chSysInit(); 477 chSysInit();
464   478  
465 /* 479 /*
466 * Activates the serial driver 1 using the driver default configuration. 480 * Activates the serial driver 1 using the driver default configuration.
467 * PA9 and PA10 are routed to USART1. 481 * PA9 and PA10 are routed to USART1.
468 * Komunikace s uzivatelem 482 * Komunikace s uzivatelem
469 */ 483 */
470 sdStart(&SD1, NULL); 484 sdStart(&SD1, NULL);
471 palSetPadMode(GPIOA, 9, PAL_MODE_STM32_ALTERNATE_OPENDRAIN); //TX 485 palSetPadMode(GPIOA, 9, PAL_MODE_STM32_ALTERNATE_OPENDRAIN); //TX
472 //palSetPadMode(GPIOA, 10, PAL_MODE_STM32_ALTERNATE_OPENDRAIN); //RX 486 //palSetPadMode(GPIOA, 10, PAL_MODE_STM32_ALTERNATE_OPENDRAIN); //RX
473   487  
474 /* 488 /*
475 * Activates the serial driver 2 using the driver default configuration. 489 * Activates the serial driver 2 using the driver default configuration.
476 * PA2 and PA3 are routed to USART2. 490 * PA2 and PA3 are routed to USART2.
477 *GPS 491 *GPS
478 */ 492 */
479 sdStart(&SD2, &USART2_config); 493 sdStart(&SD2, &USART2_config);
480 palSetPadMode(GPIOA, 2, PAL_MODE_STM32_ALTERNATE_PUSHPULL); //TX 494 palSetPadMode(GPIOA, 2, PAL_MODE_STM32_ALTERNATE_PUSHPULL); //TX
481 //palSetPadMode(GPIOA, 3, PAL_MODE_STM32_ALTERNATE_OPENDRAIN); //RX - overrides board.h PadValues 495 //palSetPadMode(GPIOA, 3, PAL_MODE_STM32_ALTERNATE_OPENDRAIN); //RX - overrides board.h PadValues
482 496
483 /* 497 /*
484 * LED na vyvojove desce 498 * LED na vyvojove desce
485 */ 499 */
486 palSetPadMode(GPIOB, GPIOB_LED3, PAL_MODE_OUTPUT_PUSHPULL); 500 palSetPadMode(GPIOB, GPIOB_LED3, PAL_MODE_OUTPUT_PUSHPULL);
487 501
488 /* 502 /*
489 * Initializes the PWM driver 4, routes the TIM4 outputs to the board LEDs. 503 * Initializes the PWM driver 4, routes the TIM4 outputs to the board LEDs.
490 */ 504 */
491 /*pwmStart(&PWMD4, &pwmcfg); 505 /*pwmStart(&PWMD4, &pwmcfg);
492 palSetPadMode(GPIOB, GPIOB_LED4, PAL_MODE_STM32_ALTERNATE_OPENDRAIN); 506 palSetPadMode(GPIOB, GPIOB_LED4, PAL_MODE_STM32_ALTERNATE_OPENDRAIN);
493 pwmEnableChannel(&PWMD4,0,PWM_SIRKA_NORMAL);*/ 507 pwmEnableChannel(&PWMD4,0,PWM_SIRKA_NORMAL);*/
494   508  
495 509
496 /* 510 /*
497 * Porty pro vypousteci sekvenci 511 * Porty pro vypousteci sekvenci
498 */ 512 */
499 palSetPadMode(GPIOB, GPIOB_PIN10, PAL_MODE_OUTPUT_PUSHPULL); 513 palSetPadMode(GPIOB, GPIOB_PIN10, PAL_MODE_OUTPUT_PUSHPULL);
500 palClearPad(GPIOB, GPIOB_PIN10); 514 palClearPad(GPIOB, GPIOB_PIN10);
501 palSetPadMode(GPIOB, GPIOB_PIN11, PAL_MODE_OUTPUT_PUSHPULL); 515 palSetPadMode(GPIOB, GPIOB_PIN11, PAL_MODE_OUTPUT_PUSHPULL);
502 palClearPad(GPIOB, GPIOB_PIN11); 516 palClearPad(GPIOB, GPIOB_PIN11);
503 palSetPadMode(GPIOB, GPIOB_PIN12, PAL_MODE_OUTPUT_PUSHPULL); 517 palSetPadMode(GPIOB, GPIOB_PIN12, PAL_MODE_OUTPUT_PUSHPULL);
504 palClearPad(GPIOB, GPIOB_PIN12); 518 palClearPad(GPIOB, GPIOB_PIN12);
505 palSetPadMode(GPIOB, GPIOB_PIN13, PAL_MODE_OUTPUT_PUSHPULL); 519 palSetPadMode(GPIOB, GPIOB_PIN13, PAL_MODE_OUTPUT_PUSHPULL);
506 palClearPad(GPIOB, GPIOB_PIN13); 520 palClearPad(GPIOB, GPIOB_PIN13);
507 palSetPad(IND_LEDS_PORT, LED_STRECHA); 521 palSetPad(IND_LEDS_PORT, LED_STRECHA);
508 palSetPad(IND_LEDS_PORT, LED_LIS); 522 palSetPad(IND_LEDS_PORT, LED_LIS);
509 palSetPad(IND_LEDS_PORT, LED_VENTIL); 523 palSetPad(IND_LEDS_PORT, LED_VENTIL);
510 palSetPad(IND_LEDS_PORT, LED_ZATAVENI); 524 palSetPad(IND_LEDS_PORT, LED_ZATAVENI);
511 525
512 /* 526 /*
513 * Aktivuje timer2 a timer3 prejde tak do aktivniho stavu 527 * Aktivuje timer2 a timer3 prejde tak do aktivniho stavu
514 */ 528 */
515 gptStart(&GPTD2,&gpt2cfg); 529 gptStart(&GPTD2,&gpt2cfg);
516   530  
517 chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); 531 chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
518 /* 532 /*
519 * Vytvori vlakno pro prijem dat z GPS modulu 533 * Vytvori vlakno pro prijem dat z GPS modulu
520 */ 534 */
521 chThdCreateStatic(waThread_GPS, sizeof(waThread_GPS), NORMALPRIO, Thread_GPS, NULL); 535 chThdCreateStatic(waThread_GPS, sizeof(waThread_GPS), NORMALPRIO, Thread_GPS, NULL);
522 536
523 /* 537 /*
524 * Vytvori vlakno pro odpalovaci sekvenci 538 * Vytvori vlakno pro odpalovaci sekvenci
525 */ 539 */
526 chThdCreateStatic (waThread_odpal, sizeof(waThread_odpal), NORMALPRIO, Thread_odpal, NULL); 540 chThdCreateStatic (waThread_odpal, sizeof(waThread_odpal), NORMALPRIO, Thread_odpal, NULL);
527 541
528 sdWrite(&SD1, uvitaci_zprava, sizeof(uvitaci_zprava)/sizeof(uint8_t)); 542 sdWrite(&SD1, uvitaci_zprava, sizeof(uvitaci_zprava)/sizeof(uint8_t));
529 /* 543 /*
530 * Normal main() thread activity, in this demo it does nothing except 544 * Normal main() thread activity, in this demo it does nothing except
531 * sleeping in a loop and check the button state, when the button is 545 * sleeping in a loop and check the button state, when the button is
532 * pressed the test procedure is launched with output on the serial 546 * pressed the test procedure is launched with output on the serial
533 * driver 1. 547 * driver 1.
534 */ 548 */
535   549  
536 while (TRUE) { 550 while (TRUE) {
537   551  
538 sdRead(&SD1,znaky,1); 552 sdRead(&SD1,znaky,1);
539 /*Kdyz uzivatel stiskne enter -> dekoduj a vykonej prikaz, nebo pokud je prikaz delsi, nez by mel byt, 553 /*Kdyz uzivatel stiskne enter -> dekoduj a vykonej prikaz, nebo pokud je prikaz delsi, nez by mel byt,
540 *prestane ukladat a upozorni uzivatele 554 *prestane ukladat a upozorni uzivatele
541 */ 555 */
542 if (znaky[0] == '\r' || pocet_znaku >= MAX_DELKA_PRIKAZU) 556 if (znaky[0] == '\r' || pocet_znaku >= MAX_DELKA_PRIKAZU)
543 { 557 {
544 pocet_znaku = 0; 558 pocet_znaku = 0;
545 dekodujPrikaz(prikaz); 559 dekodujPrikaz(prikaz);
546 prikaz[0] = 0; 560 prikaz[0] = 0;
547 } 561 }
548 /*Uklada prikaz*/ 562 /*Uklada prikaz*/
549 else if (znaky[0] == 's') // ukonci odpalovani 563 else if (znaky[0] == 's') // ukonci odpalovani
550 { 564 {
551 chSysLockFromIsr(); 565 chSysLockFromIsr();
552 if (tp_odpal != NULL) { 566 if (tp_odpal != NULL) {
553 tp_odpal->p_u.rdymsg = (msg_t)2; /* zakazano pokracovat v odpalovaci sekvenci*/ 567 tp_odpal->p_u.rdymsg = (msg_t)2; /* zakazano pokracovat v odpalovaci sekvenci*/
554 chSchReadyI(tp_odpal); 568 chSchReadyI(tp_odpal);
555 tp_odpal = NULL; 569 tp_odpal = NULL;
556 } 570 }
557 chSysUnlockFromIsr(); 571 chSysUnlockFromIsr();
558 } 572 }
559 else 573 else
560 { 574 {
561 prikaz[pocet_znaku + 1] = 0; 575 prikaz[pocet_znaku + 1] = 0;
562 prikaz[pocet_znaku++] = znaky[0]; 576 prikaz[pocet_znaku++] = znaky[0];
563 } 577 }
564 } 578 }
565 } 579 }