Rev 2945 Rev 2946
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   24  
25 static void pwmpcb(PWMDriver *pwmp); 25 static void pwmpcb(PWMDriver *pwmp);
26 static void adccb(ADCDriver *adcp, adcsample_t *buffer, size_t n); 26 static void adccb(ADCDriver *adcp, adcsample_t *buffer, size_t n);
27   27  
28 /* Total number of channels to be sampled by a single ADC operation.*/ 28 /* Total number of channels to be sampled by a single ADC operation.*/
29 #define ADC_GRP1_NUM_CHANNELS 2 29 #define ADC_GRP1_NUM_CHANNELS 2
30   30  
31 /* Depth of the conversion buffer, channels are sampled four times each.*/ 31 /* Depth of the conversion buffer, channels are sampled four times each.*/
32 #define ADC_GRP1_BUF_DEPTH 4 32 #define ADC_GRP1_BUF_DEPTH 4
33   33  
34 /*MAX delka prikazu, ktery uzivatel muze zadat*/ 34 /*MAX delka prikazu, ktery uzivatel muze zadat*/
35 #define MAX_DELKA_PRIKAZU 10 35 #define MAX_DELKA_PRIKAZU 10
36   36  
37 /*Velikost GPS bufferu*/ 37 /*Velikost GPS bufferu*/
38 #define GPS_BUFFER 500 38 #define GPS_BUFFER 500
39   39  
40 extern NMEA_GPGGA GPGGA_informace; 40 extern NMEA_GPGGA GPGGA_informace;
41 Thread *tp_odpal = NULL; 41 Thread *tp_odpal = NULL;
42 /* 42 /*
43 * ADC samples buffer. 43 * ADC samples buffer.
44 */ 44 */
45 static adcsample_t samples[ADC_GRP1_NUM_CHANNELS * ADC_GRP1_BUF_DEPTH]; 45 static adcsample_t samples[ADC_GRP1_NUM_CHANNELS * ADC_GRP1_BUF_DEPTH];
46   46  
47 /* 47 /*
48 * ADC conversion group. 48 * ADC conversion group.
49 * Mode: Linear buffer, 4 samples of 2 channels, SW triggered. 49 * Mode: Linear buffer, 4 samples of 2 channels, SW triggered.
50 * Channels: IN10 (48 cycles sample time) 50 * Channels: IN10 (48 cycles sample time)
51 * Sensor (192 cycles sample time) 51 * Sensor (192 cycles sample time)
52 */ 52 */
53 static const ADCConversionGroup adcgrpcfg = { 53 static const ADCConversionGroup adcgrpcfg = {
54 FALSE, 54 FALSE,
55 ADC_GRP1_NUM_CHANNELS, 55 ADC_GRP1_NUM_CHANNELS,
56 adccb, 56 adccb,
57 NULL, 57 NULL,
58 /* HW dependent part.*/ 58 /* HW dependent part.*/
59 0, /* CR1 */ 59 0, /* CR1 */
60 ADC_CR2_SWSTART, /* CR2 */ 60 ADC_CR2_SWSTART, /* CR2 */
61 0, 61 0,
62 ADC_SMPR2_SMP_AN10(ADC_SAMPLE_48) | ADC_SMPR2_SMP_SENSOR(ADC_SAMPLE_192), 62 ADC_SMPR2_SMP_AN10(ADC_SAMPLE_48) | ADC_SMPR2_SMP_SENSOR(ADC_SAMPLE_192),
63 0, 63 0,
64 ADC_SQR1_NUM_CH(ADC_GRP1_NUM_CHANNELS), 64 ADC_SQR1_NUM_CH(ADC_GRP1_NUM_CHANNELS),
65 0, 65 0,
66 0, 66 0,
67 0, 67 0,
68 ADC_SQR5_SQ2_N(ADC_CHANNEL_IN10) | ADC_SQR5_SQ1_N(ADC_CHANNEL_SENSOR) 68 ADC_SQR5_SQ2_N(ADC_CHANNEL_IN10) | ADC_SQR5_SQ1_N(ADC_CHANNEL_SENSOR)
69 }; 69 };
70 /* 70 /*
71 * Konfigurace USART2 71 * Konfigurace USART2
72 */ 72 */
73   73  
74 static const SerialConfig USART2_config = 74 static const SerialConfig USART2_config =
75 { 75 {
76 /*Speed*/ 76 /*Speed*/
77 9600, 77 9600,
78 /*Initialization value for the CR1 register.*/ 78 /*Initialization value for the CR1 register.*/
79 0, 79 0,
80 /*Initialization value for the CR2 register.*/ 80 /*Initialization value for the CR2 register.*/
81 USART_CR2_STOP1_BITS | USART_CR2_LINEN, 81 USART_CR2_STOP1_BITS | USART_CR2_LINEN,
82 /*Initialization value for the CR3 register.*/ 82 /*Initialization value for the CR3 register.*/
83 0 83 0
84 }; 84 };
85 //GPTDriver GPTD2; 85 //GPTDriver GPTD2;
86 /* 86 /*
87 * GPT2 callback. 87 * GPT2 callback.
88 */ 88 */
89 static void gpt2cb(GPTDriver *gptp) 89 static void gpt2cb(GPTDriver *gptp)
90 { 90 {
91 (void)gptp; 91 (void)gptp;
92 palTogglePad(GPIOB, GPIOB_LED4); 92 palTogglePad(GPIOB, GPIOB_LED4);
93 /* Wakes up the thread.*/ 93 /* Wakes up the thread.*/
94 chSysLockFromIsr(); 94 chSysLockFromIsr();
95 if (tp_odpal != NULL) { 95 if (tp_odpal != NULL) {
96 //tp_odpal->p_u.rdymsg = (msg_t)55; /* Sending the message, optional.*/ 96 //tp_odpal->p_u.rdymsg = (msg_t)55; /* Sending the message, optional.*/
97 chSchReadyI(tp_odpal); 97 chSchReadyI(tp_odpal);
98 tp_odpal = NULL; 98 tp_odpal = NULL;
99 } 99 }
100 chSysUnlockFromIsr(); 100 chSysUnlockFromIsr();
101 } 101 }
102   102  
103 /* 103 /*
104 *Konfigurace casovace 2 104 *Konfigurace casovace 2
105 */ 105 */
106 static const GPTConfig gpt2cfg = 106 static const GPTConfig gpt2cfg =
107 { 107 {
108 1000, /*1000Hz f*/ 108 1000, /*1000Hz f*/
109 gpt2cb /*callback fce*/ 109 gpt2cb /*callback fce*/
110 }; 110 };
111   111  
112   112  
113   113  
114 /* 114 /*
115 * PWM configuration structure. 115 * PWM configuration structure.
116 * Cyclic callback enabled, channels 1 and 2 enabled without callbacks, 116 * Cyclic callback enabled, channels 1 and 2 enabled without callbacks,
117 * the active state is a logic one. 117 * the active state is a logic one.
118 */ 118 */
119 static PWMConfig pwmcfg = { 119 static PWMConfig pwmcfg = {
120 10000, /* 10kHz PWM clock frequency. */ 120 10000, /* 10kHz PWM clock frequency. */
121 10000, /* PWM period 1S (in ticks). */ 121 10000, /* PWM period 1S (in ticks). */
122 pwmpcb, 122 pwmpcb,
123 { 123 {
124 {PWM_OUTPUT_ACTIVE_HIGH, NULL}, 124 {PWM_OUTPUT_ACTIVE_HIGH, NULL},
125 {PWM_OUTPUT_ACTIVE_HIGH, NULL}, 125 {PWM_OUTPUT_ACTIVE_HIGH, NULL},
126 {PWM_OUTPUT_DISABLED, NULL}, 126 {PWM_OUTPUT_DISABLED, NULL},
127 {PWM_OUTPUT_DISABLED, NULL} 127 {PWM_OUTPUT_DISABLED, NULL}
128 }, 128 },
129 /* HW dependent part.*/ 129 /* HW dependent part.*/
130 0 130 0
131 }; 131 };
132   132  
133 /* 133 /*
134 * USART konfigurace 134 * USART konfigurace
135 */ 135 */
136   136  
137   137  
138 /* 138 /*
139 * PWM cyclic callback. 139 * PWM cyclic callback.
140 * A new ADC conversion is started. 140 * A new ADC conversion is started.
141 */ 141 */
142 static void pwmpcb(PWMDriver *pwmp) { 142 static void pwmpcb(PWMDriver *pwmp) {
143   143  
144 (void)pwmp; 144 (void)pwmp;
145   145  
146 /* Starts an asynchronous ADC conversion operation, the conversion 146 /* Starts an asynchronous ADC conversion operation, the conversion
147 will be executed in parallel to the current PWM cycle and will 147 will be executed in parallel to the current PWM cycle and will
148 terminate before the next PWM cycle.*/ 148 terminate before the next PWM cycle.*/
149 chSysLockFromIsr(); 149 chSysLockFromIsr();
150 adcStartConversionI(&ADCD1, &adcgrpcfg, samples, ADC_GRP1_BUF_DEPTH); 150 adcStartConversionI(&ADCD1, &adcgrpcfg, samples, ADC_GRP1_BUF_DEPTH);
151 chSysUnlockFromIsr(); 151 chSysUnlockFromIsr();
152 } 152 }
153   153  
154 /* 154 /*
155 * ADC end conversion callback. 155 * ADC end conversion callback.
156 * The PWM channels are reprogrammed using the latest ADC samples. 156 * The PWM channels are reprogrammed using the latest ADC samples.
157 * The latest samples are transmitted into a single SPI transaction. 157 * The latest samples are transmitted into a single SPI transaction.
158 */ 158 */
159 void adccb(ADCDriver *adcp, adcsample_t *buffer, size_t n) { 159 void adccb(ADCDriver *adcp, adcsample_t *buffer, size_t n) {
160   160  
161 (void) buffer; (void) n; 161 (void) buffer; (void) n;
162 /* Note, only in the ADC_COMPLETE state because the ADC driver fires an 162 /* Note, only in the ADC_COMPLETE state because the ADC driver fires an
163 intermediate callback when the buffer is half full.*/ 163 intermediate callback when the buffer is half full.*/
164 if (adcp->state == ADC_COMPLETE) { 164 if (adcp->state == ADC_COMPLETE) {
165 adcsample_t avg_ch1, avg_ch2; 165 adcsample_t avg_ch1, avg_ch2;
166   166  
167 /* Calculates the average values from the ADC samples.*/ 167 /* Calculates the average values from the ADC samples.*/
168 avg_ch1 = (samples[0] + samples[2] + samples[4] + samples[6]) / 4; 168 avg_ch1 = (samples[0] + samples[2] + samples[4] + samples[6]) / 4;
169 avg_ch2 = (samples[1] + samples[3] + samples[5] + samples[7]) / 4; 169 avg_ch2 = (samples[1] + samples[3] + samples[5] + samples[7]) / 4;
170   170  
171 chSysLockFromIsr(); 171 chSysLockFromIsr();
172   172  
173 /* Changes the channels pulse width, the change will be effective 173 /* Changes the channels pulse width, the change will be effective
174 starting from the next cycle.*/ 174 starting from the next cycle.*/
175 pwmEnableChannelI(&PWMD4, 0, PWM_FRACTION_TO_WIDTH(&PWMD4, 4096, avg_ch1)); 175 pwmEnableChannelI(&PWMD4, 0, PWM_FRACTION_TO_WIDTH(&PWMD4, 4096, avg_ch1));
176 pwmEnableChannelI(&PWMD4, 1, PWM_FRACTION_TO_WIDTH(&PWMD4, 4096, avg_ch2)); 176 pwmEnableChannelI(&PWMD4, 1, PWM_FRACTION_TO_WIDTH(&PWMD4, 4096, avg_ch2));
177   177  
178   178  
179 chSysUnlockFromIsr(); 179 chSysUnlockFromIsr();
180 } 180 }
181 } 181 }
182   182  
183 /* 183 /*
184 * Vlakno pro ovladani odpalovaci sekvence 184 * Vlakno pro ovladani odpalovaci sekvence
185 */ 185 */
186 static WORKING_AREA(waThread_odpal, 128); 186 static WORKING_AREA(waThread_odpal, 128);
187 static msg_t Thread_odpal(void *arg) { 187 static msg_t Thread_odpal(void *arg) {
188 uint8_t stav = 0; // rika, ve ktere fazi je odpalovani 188 uint8_t stav = 0; // rika, ve ktere fazi je odpalovani
189 uint8_t odpal_povolen = 0; 189 uint8_t odpal_povolen = 0;
190 (void)arg; 190 (void)arg;
191 chRegSetThreadName("Odpal_vlakno"); 191 chRegSetThreadName("Odpal_vlakno");
192 while (TRUE) 192 while (TRUE)
193 { 193 {
194 msg_t msg; 194 msg_t msg;
195   195  
196 /* Waiting for the IRQ to happen.*/ 196 /* Waiting for the IRQ to happen.*/
197 chSysLock(); 197 chSysLock();
198 tp_odpal = chThdSelf(); 198 tp_odpal = chThdSelf();
199 chSchGoSleepS(THD_STATE_SUSPENDED); 199 chSchGoSleepS(THD_STATE_SUSPENDED);
200 msg = chThdSelf()->p_u.rdymsg; /* Retrieving the message, optional.*/ 200 msg = chThdSelf()->p_u.rdymsg; /* Retrieving the message, optional.*/
201 chSysUnlock(); 201 chSysUnlock();
202 /* Perform processing here.*/ 202 /* Perform processing here.*/
203 if(msg == 1) 203 if(msg == 1)
204 { 204 {
205 odpal_povolen = 1; 205 odpal_povolen = 1;
206 } 206 }
207 if (odpal_povolen == 1) 207 if (odpal_povolen == 1)
208 { 208 {
209 switch (stav) 209 switch (stav)
210 { 210 {
211 case 0: 211 case 0:
212 sdWrite(&SD1,"0",2); 212 sdWrite(&SD1,"0",2);
213 gptStartOneShot(&GPTD2,1000); 213 gptStartOneShot(&GPTD2,1000);
214 break; 214 break;
215 case 1: 215 case 1:
216 sdWrite(&SD1,"1",2); 216 sdWrite(&SD1,"1",2);
217 gptStartOneShot(&GPTD2,1500); 217 gptStartOneShot(&GPTD2,1500);
218 break; 218 break;
219 case 2: 219 case 2:
220 sdWrite(&SD1,"2",2); 220 sdWrite(&SD1,"2",2);
221 gptStartOneShot(&GPTD2,2000); 221 gptStartOneShot(&GPTD2,2000);
222 break; 222 break;
223 case 3: 223 case 3:
224 sdWrite(&SD1,"3",2); 224 sdWrite(&SD1,"3",2);
225 gptStartOneShot(&GPTD2,3000); 225 gptStartOneShot(&GPTD2,3000);
226 break; 226 break;
227 case 4: 227 case 4:
228 sdWrite(&SD1,"4",2); 228 sdWrite(&SD1,"4",2);
229 gptStartOneShot(&GPTD2,5000); 229 gptStartOneShot(&GPTD2,5000);
230 break; 230 break;
231 default: 231 default:
232 sdWrite(&SD1,"konec",6); //posledni krok 232 sdWrite(&SD1,"konec",6); //posledni krok
233 odpal_povolen = 0; 233 odpal_povolen = 0;
234 stav = 0; 234 stav = 0;
235 break; 235 break;
236 } 236 }
237 stav++; 237 stav++;
238 } 238 }
239 } 239 }
240 } 240 }
241   241  
242   242  
243 /* 243 /*
244 * Vlakno pro obsluhu GPS prijimace 244 * Vlakno pro obsluhu GPS prijimace
245 */ 245 */
246 static WORKING_AREA(waThread_GPS, 768); 246 static WORKING_AREA(waThread_GPS, 768);
247 static msg_t Thread_GPS(void *arg) { 247 static msg_t Thread_GPS(void *arg) {
248 /* 248 /*
249 * Nacita se jen nekolik NMEA zprav, aby se neplytvalo pameti na ulozeni kompletniho 249 * Nacita se jen nekolik NMEA zprav, aby se neplytvalo pameti na ulozeni kompletniho
250 * setu s tím rizikem, ze se nekdy nenacte aktualni informace o poloze. 250 * setu s tím rizikem, ze se nekdy nenacte aktualni informace o poloze.
251 */ 251 */
252 uint8_t inBuffer[GPS_BUFFER]; 252 uint8_t inBuffer[GPS_BUFFER];
253 char *zacatek_retezce; 253 char *zacatek_retezce;
254 char *konec_retezce; 254 char *konec_retezce;
255 uint8_t pocet_znaku; 255 uint8_t pocet_znaku;
256 uint8_t NMEA_zprava[100]; 256 uint8_t NMEA_zprava[100];
257   257  
258 (void)arg; 258 (void)arg;
259 chRegSetThreadName("GPS_NMEA"); 259 chRegSetThreadName("GPS_NMEA");
260 /* 260 /*
261 * Activates the serial driver 2 using the driver default configuration. 261 * Activates the serial driver 2 using the driver default configuration.
262 * PA2 and PA3 are routed to USART2. 262 * PA2 and PA3 are routed to USART2.
263 */ 263 */
264   264  
265 sdStart(&SD2, &USART2_config); 265 sdStart(&SD2, &USART2_config);
266 palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7)); //TX 266 palSetPadMode(GPIOA, 2, PAL_MODE_ALTERNATE(7)); //TX
267 palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7)); //RX 267 palSetPadMode(GPIOA, 3, PAL_MODE_ALTERNATE(7)); //RX
268 268
269   269  
270 while (TRUE) { 270 while (TRUE) {
271 chThdSleepMilliseconds(1000); //neni potreba data vycitat rychleji 271 chThdSleepMilliseconds(1000); //neni potreba data vycitat rychleji
272 sdRead(&SD2,inBuffer,GPS_BUFFER); 272 sdRead(&SD2,inBuffer,GPS_BUFFER);
273 273
274 /* 274 /*
275 *Nejprve se vycte cast NMEA dat, pote se vyhleda retezec GPGGA zpravy, ta se vyparsuje a pomoci fce 275 *Nejprve se vycte cast NMEA dat, pote se vyhleda retezec GPGGA zpravy, ta se vyparsuje a pomoci fce
276 *dekoduj_zpravu_GPS, ktera vyparsuje data o poloze a jine, a ulozi je do struktury GPGGA_informace. 276 *dekoduj_zpravu_GPS, ktera vyparsuje data o poloze a jine, a ulozi je do struktury GPGGA_informace.
277 */ 277 */
278   278  
279 if ((zacatek_retezce = strstr((char *)inBuffer,"$GPGGA")) != NULL) 279 if ((zacatek_retezce = strstr((char *)inBuffer,"$GPGGA")) != NULL)
280 { 280 {
281 if ((konec_retezce = strstr(zacatek_retezce,"*")) != NULL) 281 if ((konec_retezce = strstr(zacatek_retezce,"*")) != NULL)
282 { 282 {
283 pocet_znaku = (konec_retezce-zacatek_retezce)/sizeof(char); 283 pocet_znaku = (konec_retezce-zacatek_retezce)/sizeof(char);
284 if (pocet_znaku > 100) 284 if (pocet_znaku > 100)
285 { 285 {
286 pocet_znaku = 100; 286 pocet_znaku = 100;
287 } 287 }
288 strncpy((char *)NMEA_zprava,zacatek_retezce,pocet_znaku); 288 strncpy((char *)NMEA_zprava,zacatek_retezce,pocet_znaku);
289 dekoduj_zpravu_GPS(&NMEA_zprava[0],pocet_znaku); 289 dekoduj_zpravu_GPS(&NMEA_zprava[0],pocet_znaku);
290 sdWrite(&SD2,"Latitude: ",sizeof("Latitude: ")/sizeof(char)); 290 sdWrite(&SD2,"Latitude: ",sizeof("Latitude: ")/sizeof(char));
291 sdWrite(&SD2,GPGGA_informace.Latitude,sizeof(GPGGA_informace.Latitude)/sizeof(uint8_t)); 291 sdWrite(&SD2,GPGGA_informace.Latitude,sizeof(GPGGA_informace.Latitude)/sizeof(uint8_t));
292 sdWrite(&SD2,"\r\n",2); 292 sdWrite(&SD2,"\r\n",2);
293 sdWrite(&SD2,"Longitude: ",sizeof("Longitude: ")/sizeof(char)); 293 sdWrite(&SD2,"Longitude: ",sizeof("Longitude: ")/sizeof(char));
294 sdWrite(&SD2,GPGGA_informace.Longitude,sizeof(GPGGA_informace.Longitude)/sizeof(uint8_t)); 294 sdWrite(&SD2,GPGGA_informace.Longitude,sizeof(GPGGA_informace.Longitude)/sizeof(uint8_t));
295 sdWrite(&SD2,"\r\n",2); 295 sdWrite(&SD2,"\r\n",2);
296 sdWrite(&SD2,"Altitude: ",sizeof("Altitude: ")/sizeof(char)); 296 sdWrite(&SD2,"Altitude: ",sizeof("Altitude: ")/sizeof(char));
297 sdWrite(&SD2,GPGGA_informace.Altitude,sizeof(GPGGA_informace.Altitude)/sizeof(uint8_t)); 297 sdWrite(&SD2,GPGGA_informace.Altitude,sizeof(GPGGA_informace.Altitude)/sizeof(uint8_t));
298 sdWrite(&SD2,"\r\n",2); 298 sdWrite(&SD2,"\r\n",2);
299 sdWrite(&SD2,"Status: ",sizeof("Status: ")/sizeof(char)); 299 sdWrite(&SD2,"Status: ",sizeof("Status: ")/sizeof(char));
300 sdWrite(&SD2,&GPGGA_informace.Status_GPS,sizeof(GPGGA_informace.Status_GPS)/sizeof(uint8_t)); 300 sdWrite(&SD2,&GPGGA_informace.Status_GPS,sizeof(GPGGA_informace.Status_GPS)/sizeof(uint8_t));
301 sdWrite(&SD2,"\r\n",2); 301 sdWrite(&SD2,"\r\n",2);
302 sdWrite(&SD2,NMEA_zprava,pocet_znaku); 302 sdWrite(&SD2,NMEA_zprava,pocet_znaku);
303 sdWrite(&SD2,"\r\n",2); 303 sdWrite(&SD2,"\r\n",2);
304 } 304 }
305 else 305 else
306 { 306 {
307 sdWrite(&SD2,"\r\n",2); 307 sdWrite(&SD2,"\r\n",2);
308 sdWrite(&SD2,"Nenalezen ukoncovaci znak NMEA zpravy *",sizeof("Nenalezen ukoncovaci znak NMEA zpravy *")/sizeof(char)); 308 sdWrite(&SD2,"Nenalezen ukoncovaci znak NMEA zpravy *",sizeof("Nenalezen ukoncovaci znak NMEA zpravy *")/sizeof(char));
309 sdWrite(&SD2,inBuffer,GPS_BUFFER); 309 sdWrite(&SD2,inBuffer,GPS_BUFFER);
310 sdWrite(&SD2,"\r\n",2); 310 sdWrite(&SD2,"\r\n",2);
311 } 311 }
312 } 312 }
313 else 313 else
314 sdWrite(&SD2,"Nenalezen zacatek GPGGA zpravy",sizeof("Nenalezen zacatek GPGGA zpravy")/sizeof(char)); 314 sdWrite(&SD2,"Nenalezen zacatek GPGGA zpravy",sizeof("Nenalezen zacatek GPGGA zpravy")/sizeof(char));
315 315
316 } 316 }
317 } 317 }
318   318  
319 /* 319 /*
320 * This is a periodic thread that does absolutely nothing except increasing 320 * This is a periodic thread that does absolutely nothing except increasing
321 * a seconds counter. 321 * a seconds counter.
322 */ 322 */
323 static WORKING_AREA(waThread1, 128); 323 static WORKING_AREA(waThread1, 128);
324 static msg_t Thread1(void *arg) { 324 static msg_t Thread1(void *arg) {
325 static uint32_t seconds_counter; 325 static uint32_t seconds_counter;
326   326  
327 (void)arg; 327 (void)arg;
328 chRegSetThreadName("counter"); 328 chRegSetThreadName("counter");
329 while (TRUE) { 329 while (TRUE) {
330 chThdSleepMilliseconds(1000); 330 chThdSleepMilliseconds(1000);
331 seconds_counter++; 331 seconds_counter++;
332 } 332 }
333 } 333 }
334   334  
335 void dekodujPrikaz(char *prikaz) 335 void dekodujPrikaz(char *prikaz)
336 { 336 {
337 //int8_t porov; 337 //int8_t porov;
338 //porov = strcmp(prikaz,"ahoj"); 338 //porov = strcmp(prikaz,"ahoj");
339 if(strcmp(prikaz,"odpal") == 0) 339 if(strcmp(prikaz,"odpal") == 0)
340 { 340 {
341 /* Wakes up the thread.*/ 341 /* Wakes up the thread.*/
342 chSysLockFromIsr(); 342 chSysLockFromIsr();
343 if (tp_odpal != NULL) { 343 if (tp_odpal != NULL) {
344 tp_odpal->p_u.rdymsg = (msg_t)1; /* odpal povolen*/ 344 tp_odpal->p_u.rdymsg = (msg_t)1; /* odpal povolen*/
345 chSchReadyI(tp_odpal); 345 chSchReadyI(tp_odpal);
346 tp_odpal = NULL; 346 tp_odpal = NULL;
347 } 347 }
348 chSysUnlockFromIsr(); 348 chSysUnlockFromIsr();
349 palTogglePad(GPIOB, GPIOB_LED4); 349 palTogglePad(GPIOB, GPIOB_LED4);
350 } 350 }
351 else if (strcmp(prikaz,"zdar") == 0) 351 else if (strcmp(prikaz,"zdar") == 0)
352 { 352 {
353 palTogglePad(GPIOB, GPIOB_LED3); 353 palTogglePad(GPIOB, GPIOB_LED3);
354 } 354 }
355 else 355 else
356 { 356 {
357 uint8_t zp_neplatny[] = "Neplatny prikaz, spravny format *<prikaz>\n\r"; 357 uint8_t zp_neplatny[] = "Neplatny prikaz, spravny format *<prikaz>\n\r";
358 sdWrite(&SD1,zp_neplatny,sizeof(zp_neplatny)/sizeof(uint8_t)); 358 sdWrite(&SD1,zp_neplatny,sizeof(zp_neplatny)/sizeof(uint8_t));
359 palTogglePad(GPIOB, GPIOB_LED3); 359 palTogglePad(GPIOB, GPIOB_LED3);
360 } 360 }
361 } 361 }
362 362
363   363  
364   364  
365 /* 365 /*
366 * Application entry point. 366 * Application entry point.
367 */ 367 */
368 int main(void) { 368 int main(void) {
369 uint8_t znaky[20]; 369 uint8_t znaky[20];
370 char prikaz[MAX_DELKA_PRIKAZU + 1]; 370 char prikaz[MAX_DELKA_PRIKAZU + 1];
371 uint8_t uk_pri = 0; 371 uint8_t pocet_znaku = 0;
372 uint8_t zapis = 0; // pokud je prijata '*', zacina se s rozpoznanim prikazu az do '\n' -  
373   372  
374 /* 373 /*
375 * System initializations. 374 * System initializations.
376 * - HAL initialization, this also initializes the configured device drivers 375 * - HAL initialization, this also initializes the configured device drivers
377 * and performs the board-specific initializations. 376 * and performs the board-specific initializations.
378 * - Kernel initialization, the main() function becomes a thread and the 377 * - Kernel initialization, the main() function becomes a thread and the
379 * RTOS is active. 378 * RTOS is active.
380 */ 379 */
381 halInit(); 380 halInit();
382 chSysInit(); 381 chSysInit();
383   382  
384 /* 383 /*
385 * Activates the serial driver 1 using the driver default configuration. 384 * Activates the serial driver 1 using the driver default configuration.
386 * PA9 and PA10 are routed to USART1. 385 * PA9 and PA10 are routed to USART1.
387 */ 386 */
388 sdStart(&SD1, NULL); 387 sdStart(&SD1, NULL);
389 palSetPadMode(GPIOA, 9, PAL_MODE_ALTERNATE(7)); //TX 388 palSetPadMode(GPIOA, 9, PAL_MODE_ALTERNATE(7)); //TX
390 palSetPadMode(GPIOA, 10, PAL_MODE_ALTERNATE(7)); //RX 389 palSetPadMode(GPIOA, 10, PAL_MODE_ALTERNATE(7)); //RX
391   390  
392 //gptObjectInit(&GPTD2); 391 //gptObjectInit(&GPTD2);
393 /* 392 /*
394 * aktivuje timer2 a prejde tak do aktivniho stavu 393 * aktivuje timer2 a prejde tak do aktivniho stavu
395 */ 394 */
396 gptStart(&GPTD2,&gpt2cfg); 395 gptStart(&GPTD2,&gpt2cfg);
397 396
398 /* 397 /*
399 * If the user button is pressed after the reset then the test suite is 398 * If the user button is pressed after the reset then the test suite is
400 * executed immediately before activating the various device drivers in 399 * executed immediately before activating the various device drivers in
401 * order to not alter the benchmark scores. 400 * order to not alter the benchmark scores.
402 */ 401 */
403 if (palReadPad(GPIOA, GPIOA_BUTTON)) 402 if (palReadPad(GPIOA, GPIOA_BUTTON))
404 TestThread(&SD1); 403 TestThread(&SD1);
405   404  
406 /* 405 /*
407 * Initializes the SPI driver 2. The SPI2 signals are routed as follow: 406 * Initializes the SPI driver 2. The SPI2 signals are routed as follow:
408 * PB12 - NSS. 407 * PB12 - NSS.
409 * PB13 - SCK. 408 * PB13 - SCK.
410 * PB14 - MISO. 409 * PB14 - MISO.
411 * PB15 - MOSI. 410 * PB15 - MOSI.
412 */ 411 */
413 palSetPad(GPIOB, 12); 412 palSetPad(GPIOB, 12);
414 palSetPadMode(GPIOB, 12, PAL_MODE_OUTPUT_PUSHPULL | 413 palSetPadMode(GPIOB, 12, PAL_MODE_OUTPUT_PUSHPULL |
415 PAL_STM32_OSPEED_HIGHEST); /* NSS. */ 414 PAL_STM32_OSPEED_HIGHEST); /* NSS. */
416 palSetPadMode(GPIOB, 13, PAL_MODE_ALTERNATE(5) | 415 palSetPadMode(GPIOB, 13, PAL_MODE_ALTERNATE(5) |
417 PAL_STM32_OSPEED_HIGHEST); /* SCK. */ 416 PAL_STM32_OSPEED_HIGHEST); /* SCK. */
418 palSetPadMode(GPIOB, 14, PAL_MODE_ALTERNATE(5)); /* MISO. */ 417 palSetPadMode(GPIOB, 14, PAL_MODE_ALTERNATE(5)); /* MISO. */
419 palSetPadMode(GPIOB, 15, PAL_MODE_ALTERNATE(5) | 418 palSetPadMode(GPIOB, 15, PAL_MODE_ALTERNATE(5) |
420 PAL_STM32_OSPEED_HIGHEST); /* MOSI. */ 419 PAL_STM32_OSPEED_HIGHEST); /* MOSI. */
421   420  
422 /* 421 /*
423 * Initializes the ADC driver 1 and enable the thermal sensor. 422 * Initializes the ADC driver 1 and enable the thermal sensor.
424 * The pin PC0 on the port GPIOC is programmed as analog input. 423 * The pin PC0 on the port GPIOC is programmed as analog input.
425 */ 424 */
426 adcStart(&ADCD1, NULL); 425 adcStart(&ADCD1, NULL);
427 adcSTM32EnableTSVREFE(); 426 adcSTM32EnableTSVREFE();
428 palSetPadMode(GPIOC, 0, PAL_MODE_INPUT_ANALOG); 427 palSetPadMode(GPIOC, 0, PAL_MODE_INPUT_ANALOG);
429   428  
430 /* 429 /*
431 * Initializes the PWM driver 4, routes the TIM4 outputs to the board LEDs. 430 * Initializes the PWM driver 4, routes the TIM4 outputs to the board LEDs.
432 */ 431 */
433 pwmStart(&PWMD4, &pwmcfg); 432 pwmStart(&PWMD4, &pwmcfg);
434 //palSetPadMode(GPIOB, GPIOB_LED4, PAL_MODE_ALTERNATE(2)); 433 //palSetPadMode(GPIOB, GPIOB_LED4, PAL_MODE_ALTERNATE(2));
435 palSetPadMode(GPIOB, GPIOB_LED3, PAL_MODE_ALTERNATE(2)); 434 palSetPadMode(GPIOB, GPIOB_LED3, PAL_MODE_ALTERNATE(2));
436 /* 435 /*
437 * Zelena led aktivace portu 436 * Zelena led aktivace portu
438 */ 437 */
439   438  
440 palSetPadMode(GPIOB, GPIOB_LED4, PAL_MODE_OUTPUT_PUSHPULL); 439 palSetPadMode(GPIOB, GPIOB_LED4, PAL_MODE_OUTPUT_PUSHPULL);
441 palSetPadMode(GPIOB, GPIOB_LED3, PAL_MODE_OUTPUT_PUSHPULL); 440 palSetPadMode(GPIOB, GPIOB_LED3, PAL_MODE_OUTPUT_PUSHPULL);
442 //test_println("ahoj"); -  
443 /*sdRead(&SD1,znaky,5); -  
444 sdWrite(&SD1,"\n",1); -  
445 sdWrite(&SD1,znaky,2); -  
446 palWritePad(GPIOB, GPIOB_LED4, PAL_HIGH); -  
447 */ 441  
448 /* 442 /*
449 * Creates the example thread. 443 * Creates the example thread.
450 */ 444 */
451 chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL); 445 chThdCreateStatic(waThread1, sizeof(waThread1), NORMALPRIO, Thread1, NULL);
452   446  
453 /* 447 /*
454 * Vytvori vlakno pro prijem dat z GPS modulu 448 * Vytvori vlakno pro prijem dat z GPS modulu
455 */ 449 */
456 chThdCreateStatic(waThread_GPS, sizeof(waThread_GPS), NORMALPRIO, Thread_GPS, NULL); 450 chThdCreateStatic(waThread_GPS, sizeof(waThread_GPS), NORMALPRIO, Thread_GPS, NULL);
457 /* 451 /*
458 * Vytvori vlakno pro odpalovaci sekvenci 452 * Vytvori vlakno pro odpalovaci sekvenci
459 */ 453 */
460 (void)chThdCreateStatic (waThread_odpal, sizeof(waThread_odpal), NORMALPRIO, Thread_odpal, NULL); 454 (void)chThdCreateStatic (waThread_odpal, sizeof(waThread_odpal), NORMALPRIO, Thread_odpal, NULL);
461   455  
462   456  
463 /* 457 /*
464 * Normal main() thread activity, in this demo it does nothing except 458 * Normal main() thread activity, in this demo it does nothing except
465 * sleeping in a loop and check the button state, when the button is 459 * sleeping in a loop and check the button state, when the button is
466 * pressed the test procedure is launched with output on the serial 460 * pressed the test procedure is launched with output on the serial
467 * driver 1. 461 * driver 1.
468 */ 462 */
469 while (TRUE) { 463 while (TRUE) {
470   464  
471 sdRead(&SD1,znaky,1); 465 sdRead(&SD1,znaky,1);
472 /*Kdyz uzivatel stiskne enter -> dekoduj a vykonej prikaz*/ 466 /*Kdyz uzivatel stiskne enter -> dekoduj a vykonej prikaz*/
473 if (znaky[0] == '\r') 467 if (znaky[0] == '\r')
474 { 468 {
475 uk_pri = 0; 469 pocet_znaku = 0;
476 zapis = 0; -  
477 dekodujPrikaz(prikaz); 470 dekodujPrikaz(prikaz);
478 prikaz[0] = 0; 471 prikaz[0] = 0;
479 } 472 }
480 /*Uklada prikaz*/ 473 /*Uklada prikaz*/
481 if (zapis == 1 && uk_pri < MAX_DELKA_PRIKAZU) 474 else if (pocet_znaku < MAX_DELKA_PRIKAZU)
482 { 475 {
483 prikaz[uk_pri++] = znaky[0]; 476 prikaz[pocet_znaku + 1] = 0;
484 prikaz[uk_pri + 1] = 0; 477 prikaz[pocet_znaku++] = znaky[0];
485 } 478 }
486 /*Pokud je prikaz delsi, nez by mel byt, prestane ukladat a upozorni uzivatele*/ 479 /*Pokud je prikaz delsi, nez by mel byt, prestane ukladat a upozorni uzivatele*/
487 else if (zapis == 1 && uk_pri == MAX_DELKA_PRIKAZU) 480 else
488 { 481 {
489 uk_pri = 0; 482 pocet_znaku = 0;
490 zapis = 0; -  
491 dekodujPrikaz(prikaz); 483 dekodujPrikaz(prikaz);
492 } 484 }
493 /*Uzivatel zacal zadavat prikaz*/ -  
494 if(znaky[0] == '*' && zapis == 0) -  
495 zapis = 1; -  
496   -  
497 485 /*
498 if (palReadPad(GPIOA, GPIOA_BUTTON)) 486 if (palReadPad(GPIOA, GPIOA_BUTTON))
499   487  
500 TestThread(&SD1); 488 TestThread(&SD1);
501 chThdSleepMilliseconds(500); 489 chThdSleepMilliseconds(500);
-   490 */
502 } 491 }
503 } 492 }