Mercurial > public > ostc4
comparison Small_CPU/Src/wireless.c @ 38:5f11787b4f42
include in ostc4 repository
author | heinrichsweikamp |
---|---|
date | Sat, 28 Apr 2018 11:52:34 +0200 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
37:ccc45c0e1ea2 | 38:5f11787b4f42 |
---|---|
1 /** | |
2 ****************************************************************************** | |
3 * @file wireless.c | |
4 * @author heinrichs weikamp gmbh | |
5 * @date 02-July-2015 | |
6 * @version V0.0.2 | |
7 * @since 24-March-2016 | |
8 * @brief Data transfer via magnetic field using Manchester code | |
9 * | |
10 @verbatim | |
11 ============================================================================== | |
12 ##### How to use ##### | |
13 ============================================================================== | |
14 history: | |
15 160324 V 0.0.2 für Bonex Sender (Only in old hardware. No longer supported) | |
16 | |
17 | |
18 PA2 triggers to falling edge | |
19 PA1 triggers to rising edge | |
20 see baseCPU2.c definitions of ports for details | |
21 time base is the systick of CMSIS with SysTick->VAL for sub ms info | |
22 | |
23 | |
24 start id is 4 ms low (fall to rise time) | |
25 old: followed by 2 ms high (but can continue with high on sending '0' next (Hi->Lo) | |
26 160324: followed by bit 0: high to low of byte 1 | |
27 | |
28 even index numbers are falling edge | |
29 odd index numbers are rising edge | |
30 | |
31 first bit ('1' or '0' can be evaluated with triggerTimeDiffArray[2] (falling edge) | |
32 if it is much longer than 2ms than the first bit is '0' | |
33 if it is 2ms than it is '1' | |
34 | |
35 // Manchester code: 1 = low to high; 0 = high to low; | |
36 bits are either | |
37 rising edge at the middle of the bit transfer -> 1 | |
38 falling edge at the middle of the bit transfer -> 0 | |
39 | |
40 an array is used with even index for falling and odd for rising | |
41 the next time difference array entry is set to 0 to identify the loss of any edge | |
42 the time index is stored as microseconds | |
43 and generated by systick and SysTick->VAL (that is counting down from ->LOAD) | |
44 | |
45 old: startTime is the first falling edge, hence the ver first falling edge of the start byte) | |
46 160324: startTime is the first rising edge | |
47 | |
48 160324: total transfer time (excluding start with 8 ms) 10*8*2ms + 2ms (stop bit) = 162 ms | |
49 | |
50 Definition: first bit is always '0' | |
51 old: to recognize second start bit easily! | |
52 old: hence after 2 ms there is a falling edge! | |
53 160324: after 1 ms is a falling edge of first bit with value 0 | |
54 | |
55 160324: | |
56 Measurement of send data: length 162 ms including stop bit | |
57 81 bit | |
58 | |
59 @endverbatim | |
60 ****************************************************************************** | |
61 * @attention | |
62 * | |
63 * <h2><center>© COPYRIGHT(c) 2016 heinrichs weikamp</center></h2> | |
64 * | |
65 ****************************************************************************** | |
66 */ | |
67 /* Includes ------------------------------------------------------------------*/ | |
68 #include "stm32f4xx_hal.h" | |
69 #include "wireless.h" | |
70 #include "scheduler.h" | |
71 | |
72 /* array starts with first falling edge | |
73 * old: beginning of first start byte, | |
74 * old: data starts on 3 | |
75 * new: beginning of first bit that is always 0 -> high->low | |
76 * new: data starts on 0 | |
77 */ | |
78 | |
79 #define ttdaSize (1200) | |
80 | |
81 #define TIMEOUTSIZE (20000) | |
82 | |
83 #define WIRELESS_OK (0) | |
84 #define WIRELESS_FAIL (1) | |
85 | |
86 #define FALLING (0) | |
87 #define RISING (1) | |
88 | |
89 //#define STEP_HALFBIT (1010) | |
90 #define STEP_HALFBIT (1000) | |
91 #define LIMIT_STARTBIT (5000) | |
92 #define MIN_TIME_STARTBIT (3800) | |
93 #define MAX_TIME_FIRST_STARTBIT (5200) | |
94 #define MIN_TIME_BOTH_STARTBITS (MIN_TIME_STARTBIT + MIN_TIME_STARTBIT) | |
95 #define MAX_TIME_BOTH_STARTBITS (MAX_TIME_FIRST_STARTBIT + 4200) | |
96 // includes necessary start bit (2000 us) and timing issues | |
97 #define HELPER_MAX_DATA_LENGTH_TOLERANCE (10*STEP_HALFBIT) | |
98 #define HELPER_MAX_DATA_BYTES (10) ///< 160324: 10, before 8 | |
99 #define MAX_DATA_BITS (HELPER_MAX_DATA_BYTES*8) | |
100 #define MAX_DATA_LENGTH ((STEP_HALFBIT*2*MAX_DATA_BITS) + HELPER_MAX_DATA_LENGTH_TOLERANCE) | |
101 | |
102 #define MAX_DIFF_IN_MS ((MAX_DATA_LENGTH+999)/1000) | |
103 | |
104 void wireless_reset(uint32_t timeMain, uint32_t timeSub); | |
105 | |
106 /* triggerTimeDiffArray in us with max 65 ms */ | |
107 | |
108 int32_t triggerNewArray[ttdaSize][2]; | |
109 | |
110 int32_t triggerNewArrayDebugStartBits[20][2]; | |
111 | |
112 //uint16_t triggerTimeDiffArray[ttdaSize]; | |
113 uint16_t ttdaPointer; | |
114 uint32_t startTimeMain; | |
115 | |
116 uint32_t subDivisorX1000; | |
117 uint8_t blockDataCapture = 0; | |
118 uint8_t evaluateRequest = 0; ///< | |
119 | |
120 uint8_t found_first_4ms_high = 0; ///< | |
121 uint8_t found_second_4ms_low = 0; ///< | |
122 | |
123 | |
124 | |
125 | |
126 // =============================================================================== | |
127 // wireless_init | |
128 /// @brief has to be called once to initialize the variables | |
129 // =============================================================================== | |
130 void wireless_init(void) | |
131 { | |
132 subDivisorX1000 = SysTick->LOAD; ///< never changes | |
133 wireless_reset(0,0); | |
134 ttdaPointer = 0; ///< is set back again by timeout or on error | |
135 blockDataCapture = 0; | |
136 //triggerTimeDiffArray[0] = 0; | |
137 } | |
138 | |
139 | |
140 /** | |
141 ****************************************************************************** | |
142 * @brief RECORDING functions | |
143 * @author heinrichs weikamp gmbh | |
144 * @date 03-July-2015 | |
145 * @version V0.0.1 | |
146 * @since 03-July-2015 | |
147 ****************************************************************************** | |
148 */ | |
149 | |
150 | |
151 // =============================================================================== | |
152 // wireless_getTime | |
153 /// @brief RECORDING | |
154 /// | |
155 /// @param | |
156 // =============================================================================== | |
157 void wireless_getTime(uint32_t *timeMain, uint32_t *timeSub) | |
158 { | |
159 uint32_t timeSub2, timeMain2; | |
160 | |
161 *timeSub = SysTick->VAL; | |
162 *timeMain = HAL_GetTick(); | |
163 timeSub2 = SysTick->VAL; | |
164 timeMain2 = HAL_GetTick(); | |
165 | |
166 /* | |
167 static uint32_t difference = 0; | |
168 if(ttdaPointer == 1) | |
169 difference = 7; //& breakpoint | |
170 */ | |
171 | |
172 if((timeSub2 > *timeSub) && (timeMain2 == *timeMain)) | |
173 *timeMain -= 1; | |
174 | |
175 *timeSub = subDivisorX1000 - *timeSub; | |
176 *timeSub *= 1000; | |
177 *timeSub /= subDivisorX1000; | |
178 } | |
179 | |
180 | |
181 | |
182 /* stored value _could be_ in multiples of 2 us | |
183 * to have 1000 for each byte | |
184 * 0000 is beginning of start bit (always 1) | |
185 * 1000 is beginning of first bit (if timing is perfect, otherwise less or more) | |
186 * ... | |
187 * XXXX000 is beginning of XXXX bit | |
188 * | |
189 */ | |
190 | |
191 // =============================================================================== | |
192 // wireless_time0keeper | |
193 /// @brief RECORDING | |
194 /// | |
195 /// @param | |
196 /// @return still in us | |
197 // =============================================================================== | |
198 int32_t wireless_time0keeper(uint8_t store1_or_diffOut0, uint32_t timeMain, uint32_t timeSub) | |
199 { | |
200 static uint32_t storeMain = 0, storeSub = 0; | |
201 | |
202 /* store time0 */ | |
203 if(store1_or_diffOut0) | |
204 { | |
205 storeMain = timeMain; | |
206 storeSub = timeSub; | |
207 return 0; | |
208 } | |
209 | |
210 /* evaluate time difference */ | |
211 int32_t diff = 0; | |
212 | |
213 if((timeMain < storeMain) || ((timeMain - storeMain) > MAX_DIFF_IN_MS)) | |
214 return -1; | |
215 | |
216 diff = timeMain - storeMain; | |
217 diff *= 1000; | |
218 diff += timeSub; | |
219 diff -= storeSub; | |
220 | |
221 return diff; | |
222 } | |
223 | |
224 | |
225 // =============================================================================== | |
226 // wireless_save_time0 | |
227 /// @brief RECORDING | |
228 /// | |
229 /// @param | |
230 // =============================================================================== | |
231 void wireless_save_time0(uint32_t timeMain, uint32_t timeSub) | |
232 { | |
233 wireless_time0keeper(1, timeMain, timeSub); | |
234 } | |
235 | |
236 | |
237 // =============================================================================== | |
238 // wireless_get_time_since_time0 | |
239 /// @brief RECORDING | |
240 /// | |
241 /// @param | |
242 /// @return | |
243 // =============================================================================== | |
244 int32_t wireless_get_time_since_time0(uint32_t timeMain, uint32_t timeSub) | |
245 { | |
246 return wireless_time0keeper(0, timeMain, timeSub); | |
247 } | |
248 | |
249 | |
250 // =============================================================================== | |
251 // wireless_get_time_since_previous | |
252 /// @brief RECORDING | |
253 /// | |
254 /// @param | |
255 /// @return | |
256 // =============================================================================== | |
257 int32_t wireless_get_time_since_previous(uint8_t fallingOrRising, uint32_t timeMain, uint32_t timeSub) | |
258 { | |
259 int32_t absoluteTimeDiff = wireless_time0keeper(0, timeMain, timeSub); | |
260 | |
261 if(fallingOrRising == FALLING) // same array | |
262 { | |
263 return (absoluteTimeDiff - triggerNewArray[ttdaPointer][FALLING]); | |
264 } | |
265 else | |
266 if(ttdaPointer > 0) | |
267 { | |
268 return (absoluteTimeDiff - triggerNewArray[ttdaPointer - 1][RISING]); | |
269 } | |
270 else // not possible | |
271 return -1; | |
272 } | |
273 | |
274 | |
275 // =============================================================================== | |
276 // wireless_reset | |
277 /// @brief RECORDING | |
278 /// | |
279 /// @param | |
280 // =============================================================================== | |
281 void wireless_reset(uint32_t timeMain, uint32_t timeSub) | |
282 { | |
283 found_first_4ms_high = 0; | |
284 found_second_4ms_low = 0; | |
285 ttdaPointer = 0; | |
286 startTimeMain = 0; | |
287 evaluateRequest = 0; | |
288 wireless_save_time0(timeMain, timeSub); | |
289 triggerNewArray[ttdaPointer][FALLING] = 0; | |
290 triggerNewArray[ttdaPointer][RISING] = 0; | |
291 } | |
292 | |
293 | |
294 | |
295 | |
296 // =============================================================================== | |
297 // wireless_trigger_FallingEdgeSignalHigh | |
298 /// @brief RECORDING | |
299 /// | |
300 // =============================================================================== | |
301 void wireless_trigger_FallingEdgeSignalHigh(void) | |
302 { | |
303 uint32_t timeSub, timeMain; | |
304 int32_t timeDifference; | |
305 | |
306 wireless_getTime(&timeMain, &timeSub); | |
307 | |
308 if((blockDataCapture) || (evaluateRequest == 1)) | |
309 return; | |
310 | |
311 if(evaluateRequest == 2) | |
312 wireless_reset(0, 0); | |
313 | |
314 if(!found_first_4ms_high) // trying to get first start 4ms | |
315 { | |
316 if(ttdaPointer == 0) | |
317 { | |
318 wireless_reset(timeMain, timeSub); | |
319 } | |
320 else | |
321 { | |
322 timeDifference = wireless_get_time_since_time0(timeMain, timeSub); | |
323 if((timeDifference > 0) && (timeDifference <= LIMIT_STARTBIT)) | |
324 { | |
325 triggerNewArray[ttdaPointer][0] = timeDifference; | |
326 } | |
327 else | |
328 { | |
329 wireless_reset(timeMain, timeSub); | |
330 } | |
331 } | |
332 } | |
333 else // here comes the very important time0 for all following data | |
334 if(!found_second_4ms_low) ///< the beginning of the very first is recorded here :-) | |
335 { | |
336 timeDifference = wireless_get_time_since_time0(timeMain, timeSub); | |
337 if((timeDifference > 0) && (timeDifference >= MIN_TIME_BOTH_STARTBITS) && (timeDifference <= MAX_TIME_BOTH_STARTBITS)) | |
338 { | |
339 // now we are ready for data | |
340 for(int i=0;i<20;i++) | |
341 { | |
342 if(i <= ttdaPointer) | |
343 { | |
344 triggerNewArrayDebugStartBits[i][FALLING] = triggerNewArray[i][FALLING]; | |
345 triggerNewArrayDebugStartBits[i][RISING] = triggerNewArray[i][FALLING]; | |
346 } | |
347 else | |
348 { | |
349 triggerNewArrayDebugStartBits[i][FALLING] = 0; | |
350 triggerNewArrayDebugStartBits[i][RISING] = 0; | |
351 } | |
352 } | |
353 wireless_reset(timeMain, timeSub); ///< reset all including ttdaPointer and more | |
354 startTimeMain = timeMain; ///< set again | |
355 found_first_4ms_high = 1; ///< set again | |
356 found_second_4ms_low = 1; ///< set now: ready for recording | |
357 } | |
358 } | |
359 else | |
360 { | |
361 timeDifference = wireless_get_time_since_time0(timeMain, timeSub); | |
362 | |
363 if((timeDifference > MAX_DATA_LENGTH) || (ttdaPointer > (ttdaSize - 2))) | |
364 { | |
365 evaluateRequest = 1; | |
366 } | |
367 else | |
368 { | |
369 triggerNewArray[ttdaPointer][FALLING] = timeDifference; | |
370 triggerNewArray[ttdaPointer][RISING] = 0; | |
371 } | |
372 } | |
373 } | |
374 | |
375 | |
376 // =============================================================================== | |
377 // wireless_trigger_RisingEdgeSilence | |
378 /// @brief RECORDING | |
379 /// | |
380 // =============================================================================== | |
381 void wireless_trigger_RisingEdgeSilence(void) | |
382 { | |
383 uint32_t timeSub, timeMain; | |
384 int32_t timeDifference; | |
385 | |
386 wireless_getTime(&timeMain, &timeSub); | |
387 | |
388 if((blockDataCapture) || (evaluateRequest == 1)) | |
389 return; | |
390 | |
391 if(evaluateRequest == 2) | |
392 { | |
393 wireless_reset(0, 0); | |
394 return; // Falling Edge first | |
395 } | |
396 | |
397 timeDifference = wireless_get_time_since_time0(timeMain, timeSub); | |
398 | |
399 if(!found_first_4ms_high) | |
400 { | |
401 if((timeDifference > 0) && (timeDifference <= MAX_TIME_FIRST_STARTBIT)) | |
402 { | |
403 triggerNewArray[ttdaPointer++][RISING] = timeDifference; | |
404 triggerNewArray[ttdaPointer][FALLING] = 0; | |
405 | |
406 if(timeDifference >= MIN_TIME_STARTBIT) ///< start bit is the 4 ms | |
407 { | |
408 found_first_4ms_high = 1; | |
409 found_second_4ms_low = 0; | |
410 } | |
411 } | |
412 } | |
413 else | |
414 { | |
415 if((timeDifference > MAX_DATA_LENGTH) || (ttdaPointer > (ttdaSize - 2))) | |
416 { | |
417 evaluateRequest = 1; | |
418 } | |
419 else | |
420 { | |
421 triggerNewArray[ttdaPointer++][RISING] = timeDifference; | |
422 triggerNewArray[ttdaPointer][FALLING] = 0; | |
423 } | |
424 } | |
425 } | |
426 | |
427 | |
428 // =============================================================================== | |
429 // wireless_position_next | |
430 /// @brief RECORDING | |
431 /// | |
432 /// @param | |
433 /// @return | |
434 // =============================================================================== | |
435 uint8_t wireless_position_next(uint16_t *ttdaPointerNow, uint8_t *typeNow) | |
436 { | |
437 if(*typeNow == FALLING) | |
438 *typeNow = RISING; | |
439 else if(*ttdaPointerNow < (ttdaSize - 1)) | |
440 { | |
441 *ttdaPointerNow += 1; | |
442 *typeNow = FALLING; | |
443 } | |
444 else | |
445 { | |
446 return WIRELESS_FAIL; | |
447 } | |
448 return WIRELESS_OK; | |
449 | |
450 } | |
451 | |
452 | |
453 // =============================================================================== | |
454 // wireless_position_previous | |
455 /// @brief RECORDING | |
456 /// | |
457 /// @param | |
458 /// @return | |
459 // =============================================================================== | |
460 uint8_t wireless_position_previous(uint16_t *ttdaPointerNow, uint8_t *typeNow) | |
461 { | |
462 if(*typeNow == RISING) | |
463 *typeNow = FALLING; | |
464 else if(*ttdaPointerNow > 0) | |
465 { | |
466 *ttdaPointerNow -= 1; | |
467 *typeNow = RISING; | |
468 } | |
469 else | |
470 { | |
471 return WIRELESS_FAIL; | |
472 } | |
473 return WIRELESS_OK; | |
474 } | |
475 | |
476 | |
477 // =============================================================================== | |
478 // wireless_position_compare | |
479 /// @brief RECORDING | |
480 /// | |
481 /// @param | |
482 /// @return | |
483 // =============================================================================== | |
484 int8_t wireless_position_compare(uint16_t ttdaPointerLeft, uint8_t typeLeft, uint16_t ttdaPointerRight, uint8_t typeRight) | |
485 { | |
486 if(ttdaPointerLeft < ttdaPointerRight) | |
487 return -1; | |
488 else | |
489 if(ttdaPointerLeft > ttdaPointerRight) | |
490 return 1; | |
491 else | |
492 if(typeLeft < typeRight) | |
493 return -1; | |
494 else | |
495 if(typeLeft > typeRight) | |
496 return 1; | |
497 else | |
498 return 0; | |
499 } | |
500 | |
501 | |
502 // =============================================================================== | |
503 // wireless_debug | |
504 /// @brief | |
505 /// | |
506 /// @param | |
507 /// @return | |
508 // =============================================================================== | |
509 /* outlined because of errors while compiling | |
510 void wireless_debug(int8_t *adcData, uint16_t max_size_adc) | |
511 { | |
512 // debug | |
513 uint32_t dataVisual[201]; | |
514 uint8_t dataVisualValue[201]; | |
515 int8_t dataVisualResult[201]; | |
516 | |
517 dataVisualValue[0] = 1; | |
518 | |
519 for(int i=0;i<201;i++) | |
520 dataVisualResult[i] = -1; | |
521 | |
522 for(int i=0;i<201-4;i +=4) | |
523 { | |
524 dataVisualValue[i] = 1; | |
525 dataVisualValue[i+1] = 1; | |
526 dataVisualValue[i+2] = 0; | |
527 dataVisualValue[i+3] = 0; | |
528 } | |
529 | |
530 dataVisual[0] = triggerNewArray[0][FALLING]; | |
531 | |
532 int j = 1; | |
533 uint32_t valueStore = 0; | |
534 for(int i=0;i<50;i++) | |
535 { | |
536 valueStore = triggerNewArray[i][FALLING]; | |
537 dataVisual[j++] = valueStore; | |
538 dataVisual[j++] = valueStore + 1; | |
539 valueStore = triggerNewArray[i][RISING]; | |
540 dataVisual[j++] = valueStore; | |
541 dataVisual[j++] = valueStore + 1; | |
542 } | |
543 | |
544 | |
545 if(max_size_adc > 0) | |
546 { | |
547 int jStep = 0; | |
548 int jData = 0; | |
549 for(int i=0;i<201;i++) | |
550 { | |
551 if(dataVisual[i] >= jStep) | |
552 { | |
553 if(adcData[jData] > 0) | |
554 dataVisualResult[i] = 1; | |
555 else | |
556 dataVisualResult[i] = 0; | |
557 jStep += STEP_HALFBIT + STEP_HALFBIT; | |
558 jData++; | |
559 if(jData >= max_size_adc) | |
560 break; | |
561 } | |
562 } | |
563 } | |
564 } | |
565 */ | |
566 | |
567 // =============================================================================== | |
568 // wireless_debug_test_failed_AACCF1010203 | |
569 /// @brief | |
570 /// | |
571 /// @param | |
572 /// @return | |
573 // =============================================================================== | |
574 uint8_t wireless_debug_test_failed_AACCF1010203(uint8_t *data) | |
575 { | |
576 if(data[0] != 0xAA) | |
577 return 1; | |
578 if(data[1] != 0xCC) | |
579 return 1; | |
580 if(data[2] != 0xF1) | |
581 return 1; | |
582 if(data[3] != 0x01) | |
583 return 1; | |
584 if(data[4] != 0x02) | |
585 return 0; | |
586 if(data[5] != 0x03) | |
587 return 1; | |
588 | |
589 return 0; | |
590 } | |
591 | |
592 | |
593 // =============================================================================== | |
594 // wireless_check_crc_failed | |
595 /// @brief | |
596 /// | |
597 /// @param | |
598 /// @return | |
599 // =============================================================================== | |
600 uint8_t wireless_check_crc_failed(uint8_t *dataOut, uint8_t maxData) | |
601 { | |
602 return (wireless_debug_test_failed_AACCF1010203(dataOut)); | |
603 } | |
604 | |
605 | |
606 /** | |
607 ****************************************************************************** | |
608 * @brief EVALUATION functions | |
609 * @author heinrichs weikamp gmbh | |
610 * @date 03-July-2015 | |
611 * @version V0.0.2 | |
612 * @since 14-July-2015 | |
613 ****************************************************************************** | |
614 */ | |
615 | |
616 // =============================================================================== | |
617 // wireless_time0keeper | |
618 /// @brief EVALUATION | |
619 /// | |
620 /// @param | |
621 /// @return | |
622 // =============================================================================== | |
623 uint8_t wireless_evaluate_internal_loop(uint8_t *dataOut, uint8_t maxData, int32_t shift, uint8_t *confidence) | |
624 { | |
625 // variables | |
626 int iOut = 0; | |
627 int jAdc = 0; | |
628 | |
629 int8_t adcData[MAX_DATA_BITS]; | |
630 uint16_t adcPointer = 0; | |
631 | |
632 int8_t bitLeft = 0; | |
633 int8_t bitRight = 0; | |
634 | |
635 uint16_t ttdaPointerStart = 0; | |
636 uint16_t ttdaPointerEnd = 0; | |
637 uint8_t typeStart = RISING; | |
638 uint8_t typeEnd = RISING; | |
639 int32_t startTimeHalfBit = 0; | |
640 int32_t endTimeHalfBit = 0; | |
641 int32_t startOfThisPeak = 0; | |
642 int32_t endOfThisPeak = 0; | |
643 uint8_t wirelessErrorStatus = 0; | |
644 uint8_t timeToStop = 0; | |
645 int32_t valueSingle = 0; | |
646 int32_t halfbitTemp = 0; | |
647 int confidenceTemp = 0; | |
648 | |
649 // safety end for all loops coming | |
650 triggerNewArray[ttdaPointer][RISING] = INT32_MAX; | |
651 | |
652 ttdaPointerStart = 0; | |
653 ttdaPointerEnd = 0; | |
654 typeStart = RISING; | |
655 typeEnd = RISING; | |
656 startTimeHalfBit = 0; | |
657 endTimeHalfBit = shift; | |
658 adcPointer = 0; | |
659 | |
660 while(!timeToStop) | |
661 { | |
662 // start is latest start | |
663 ttdaPointerEnd = ttdaPointerStart; | |
664 typeEnd = typeStart; | |
665 for(int doItTwice=0;doItTwice<2;doItTwice++) | |
666 { | |
667 startTimeHalfBit = endTimeHalfBit; | |
668 endTimeHalfBit += STEP_HALFBIT; | |
669 // find the end for this half bit; this will include values that continue to the next halfbit and negative values | |
670 while(triggerNewArray[ttdaPointerEnd][typeEnd] < endTimeHalfBit) | |
671 wireless_position_next(&ttdaPointerEnd,&typeEnd); | |
672 | |
673 if(triggerNewArray[ttdaPointerEnd][typeEnd] == INT32_MAX) | |
674 { | |
675 timeToStop = 1; | |
676 break; | |
677 } | |
678 startOfThisPeak = startTimeHalfBit; | |
679 wirelessErrorStatus = 0; | |
680 halfbitTemp = 0; | |
681 while(!wirelessErrorStatus && (wireless_position_compare(ttdaPointerStart,typeStart, ttdaPointerEnd,typeEnd) <= 0)) | |
682 { | |
683 endOfThisPeak = triggerNewArray[ttdaPointerStart][typeStart]; | |
684 if(endOfThisPeak <= startOfThisPeak) | |
685 { | |
686 wireless_position_next(&ttdaPointerStart,&typeStart); | |
687 } | |
688 else | |
689 { | |
690 // TODO: what about time difference errors? | |
691 if(endOfThisPeak >= endTimeHalfBit) | |
692 valueSingle = endTimeHalfBit - startOfThisPeak; | |
693 else | |
694 valueSingle = endOfThisPeak - startOfThisPeak; | |
695 | |
696 if(typeStart == RISING) | |
697 { | |
698 halfbitTemp += valueSingle; | |
699 } | |
700 // next, also valid for every next halfbit | |
701 if(endOfThisPeak <= endTimeHalfBit) | |
702 { | |
703 startOfThisPeak = endOfThisPeak; | |
704 wireless_position_next(&ttdaPointerStart,&typeStart); | |
705 } | |
706 else | |
707 { | |
708 startOfThisPeak = endTimeHalfBit; | |
709 } | |
710 // should not be necessary, anyway | |
711 if(startOfThisPeak == endTimeHalfBit) | |
712 break; | |
713 } | |
714 } | |
715 // store | |
716 halfbitTemp *= 100; | |
717 halfbitTemp /= STEP_HALFBIT; | |
718 if(halfbitTemp > 100) halfbitTemp = 100; | |
719 if(doItTwice == 0) | |
720 { | |
721 bitLeft = halfbitTemp; | |
722 } | |
723 else | |
724 { | |
725 bitRight = halfbitTemp; | |
726 } | |
727 } | |
728 // Gewichtung und Bit Generierung | |
729 adcData[adcPointer++] = (int8_t)((bitLeft - bitRight)); // possitive value | |
730 if(adcPointer >= MAX_DATA_BITS) | |
731 timeToStop = 1; | |
732 } | |
733 | |
734 // Auswertung | |
735 jAdc = 0; | |
736 iOut = 0; | |
737 | |
738 for(int i=0;i<maxData;i++) | |
739 { | |
740 dataOut[i] = 0; | |
741 for(int j=0;j<8;j++) | |
742 { | |
743 dataOut[i] *= 2; | |
744 if((adcData[jAdc++] > 0)) | |
745 dataOut[i] |= 1; | |
746 if(jAdc >= adcPointer) | |
747 { | |
748 j++; | |
749 while(j<8) | |
750 { | |
751 jAdc = adcPointer + 1; // end signal | |
752 dataOut[i] *= 2; | |
753 j++; | |
754 } | |
755 break; | |
756 } | |
757 } | |
758 if(jAdc > adcPointer) | |
759 break; | |
760 iOut++; | |
761 } | |
762 | |
763 confidenceTemp = 0; | |
764 for(int i=0;i<adcPointer;i++) | |
765 { | |
766 if(adcData[i] < 0) | |
767 confidenceTemp -= adcData[i]; | |
768 else | |
769 confidenceTemp += adcData[i]; | |
770 } | |
771 // confidence in adcData is 0 to 127 only | |
772 confidenceTemp *= 2; | |
773 *confidence = (uint8_t)(confidenceTemp/adcPointer); | |
774 | |
775 /* | |
776 if( (iOut>= 5) && wireless_debug_test_failed_AACCF1010203(dataOut)) | |
777 wireless_debug(adcData,MAX_DATA_BITS); | |
778 */ | |
779 return iOut; | |
780 | |
781 } | |
782 | |
783 | |
784 // =============================================================================== | |
785 // wireless_evaluate_crc_error | |
786 /// @brief EVALUATION | |
787 /// | |
788 /// @param | |
789 /// @return | |
790 // =============================================================================== | |
791 uint8_t wireless_evaluate_crc_error(uint8_t *dataIn, uint8_t maxData) | |
792 { | |
793 uint8_t crcTest = 0; | |
794 for(int i=0; i< maxData; i++) | |
795 crcTest ^= dataIn[i]; | |
796 | |
797 return crcTest; | |
798 } | |
799 | |
800 | |
801 // =============================================================================== | |
802 // wireless_evaluate | |
803 /// @brief EVALUATION | |
804 /// | |
805 /// @param | |
806 /// @return | |
807 // =============================================================================== | |
808 uint8_t wireless_evaluate(uint8_t *dataOut, uint8_t maxData, uint8_t *confidence) | |
809 { | |
810 uint32_t timeTick; | |
811 uint32_t timeElapsed; | |
812 | |
813 timeTick = HAL_GetTick(); | |
814 timeElapsed = time_elapsed_ms(startTimeMain,timeTick); | |
815 | |
816 uint8_t start = 0; | |
817 int iOut = 0; | |
818 | |
819 // check condition for start | |
820 if(evaluateRequest == 2) | |
821 return 0; | |
822 | |
823 if(evaluateRequest == 1) | |
824 start = 1; | |
825 | |
826 if((ttdaPointer > 10) && (timeElapsed > (MAX_DATA_LENGTH/1000))) | |
827 start = 1; | |
828 | |
829 if(!start) | |
830 return 0; | |
831 | |
832 // start | |
833 blockDataCapture = 1; | |
834 | |
835 // evaluate | |
836 iOut = wireless_evaluate_internal_loop(dataOut, maxData, 0, confidence); | |
837 | |
838 | |
839 /* | |
840 for(int i=0; i>=-500; i -= 100) | |
841 { | |
842 iOut = wireless_evaluate_internal_loop(dataOut, maxData, i, confidence); | |
843 if(iOut < 5) | |
844 break; | |
845 if(wireless_check_crc_failed(dataOut,iOut) == 0) | |
846 break; | |
847 } | |
848 */ | |
849 // end | |
850 evaluateRequest = 2; | |
851 blockDataCapture = 0; | |
852 | |
853 return iOut; | |
854 } | |
855 | |
856 /************************ (C) COPYRIGHT heinrichs weikamp *****END OF FILE****/ |