1 /*!
2 * @file tsc_acq.c
3 *
4 * @brief This file contains all functions to manage the acquisition in general.
5 *
6 * @version V1.0.1
7 *
8 * @date 2022-09-20
9 *
10 * @attention
11 *
12 * Copyright (C) 2020-2022 Geehy Semiconductor
13 *
14 * You may not use this file except in compliance with the
15 * GEEHY COPYRIGHT NOTICE (GEEHY SOFTWARE PACKAGE LICENSE).
16 *
17 * The program is only for reference, which is distributed in the hope
18 * that it will be useful and instructional for customers to develop
19 * their software. Unless required by applicable law or agreed to in
20 * writing, the program is distributed on an "AS IS" BASIS, WITHOUT
21 * ANY WARRANTY OR CONDITIONS OF ANY KIND, either express or implied.
22 * See the GEEHY SOFTWARE PACKAGE LICENSE for the governing permissions
23 * and limitations under the License.
24 */
25
26 /* Includes */
27 #include "tsc.h"
28 #include "tsc_acq.h"
29 #include "apm32f0xx_int.h"
30
31 /** @addtogroup TSC_Driver_Library TSC Driver Library
32 @{
33 */
34
35 /** @addtogroup TSC_Acquisition_Driver TSC Acquisition Driver
36 @{
37 */
38
39 /** @defgroup TSC_Acquisition_Macros Macros
40 @{
41 */
42
43 /**@} end of group TSC_Acquisition_Macros */
44
45 /** @defgroup TSC_Acquisition_Enumerations Enumerations
46 @{
47 */
48
49 /**@} end of group TSC_Acquisition_Enumerations */
50
51 /** @defgroup TSC_Acquisition_Structures Structures
52 @{
53 */
54
55 /**@} end of group TSC_Acquisition_Structures */
56
57 /** @defgroup TSC_Acquisition_Variables Variables
58 @{
59 */
60
61 uint32_t DelayDischarge;
62
63 /**@} end of group TSC_Acquisition_Variables */
64
65 /** @defgroup TSC_Acquisition_Functions Functions
66 @{
67 */
68
69 void SoftDelay(uint32_t val);
70
71 /*!
72 * @brief Output Open-Drain for Sampling Capacitor in GPIOA
73 *
74 * @param None
75 *
76 * @retval pin value
77 */
TSC_Acq_GPIOA_SAMPCAP(void)78 uint32_t TSC_Acq_GPIOA_SAMPCAP(void)
79 {
80 uint32_t pin = 0;
81 #if TOUCH_TSC_GROUP1_IO1 == SAMPCAP
82 pin |= GPIO_PIN_0;
83 #endif
84 #if TOUCH_TSC_GROUP1_IO2 == SAMPCAP
85 pin |= GPIO_PIN_1;
86 #endif
87 #if TOUCH_TSC_GROUP1_IO3 == SAMPCAP
88 pin |= GPIO_PIN_2;
89 #endif
90 #if TOUCH_TSC_GROUP1_IO4 == SAMPCAP
91 pin |= GPIO_PIN_3;
92 #endif
93 #if TOUCH_TSC_GROUP2_IO1 == SAMPCAP
94 pin |= GPIO_PIN_4;
95 #endif
96 #if TOUCH_TSC_GROUP2_IO2 == SAMPCAP
97 pin |= GPIO_PIN_5;
98 #endif
99 #if TOUCH_TSC_GROUP2_IO3 == SAMPCAP
100 pin |= GPIO_PIN_6;
101 #endif
102 #if TOUCH_TSC_GROUP2_IO4 == SAMPCAP
103 pin |= GPIO_PIN_7;
104 #endif
105 #if TOUCH_TSC_GROUP4_IO1 == SAMPCAP
106 pin |= GPIO_PIN_9;
107 #endif
108 #if TOUCH_TSC_GROUP4_IO2 == SAMPCAP
109 pin |= GPIO_PIN_10;
110 #endif
111 #if TOUCH_TSC_GROUP4_IO3 == SAMPCAP
112 pin |= GPIO_PIN_11;
113 #endif
114 #if TOUCH_TSC_GROUP4_IO4 == SAMPCAP
115 pin |= GPIO_PIN_12;
116 #endif
117 return pin;
118 }
119
120 /*!
121 * @brief Output Open-Drain for Sampling Capacitor in GPIOB
122 *
123 * @param None
124 *
125 * @retval pin value
126 */
TSC_Acq_GPIOB_SAMPCAP(void)127 uint32_t TSC_Acq_GPIOB_SAMPCAP(void)
128 {
129 uint32_t pin = 0;
130 #if TOUCH_TSC_GROUP3_IO2 == SAMPCAP
131 pin |= GPIO_PIN_0;
132 #endif
133 #if TOUCH_TSC_GROUP3_IO3 == SAMPCAP
134 pin |= GPIO_PIN_1;
135 #endif
136 #if TOUCH_TSC_GROUP3_IO4 == SAMPCAP
137 pin |= GPIO_PIN_2;
138 #endif
139 #if TOUCH_TSC_GROUP5_IO1 == SAMPCAP
140 pin |= GPIO_PIN_3;
141 #endif
142 #if TOUCH_TSC_GROUP5_IO2 == SAMPCAP
143 pin |= GPIO_PIN_4;
144 #endif
145 #if TOUCH_TSC_GROUP5_IO3 == SAMPCAP
146 pin |= GPIO_PIN_6;
147 #endif
148 #if TOUCH_TSC_GROUP5_IO4 == SAMPCAP
149 pin |= GPIO_PIN_7;
150 #endif
151 #if TOUCH_TSC_GROUP6_IO1 == SAMPCAP
152 pin |= GPIO_PIN_11;
153 #endif
154 #if TOUCH_TSC_GROUP6_IO2 == SAMPCAP
155 pin |= GPIO_PIN_12;
156 #endif
157 #if TOUCH_TSC_GROUP6_IO3 == SAMPCAP
158 pin |= GPIO_PIN_13;
159 #endif
160 #if TOUCH_TSC_GROUP6_IO4 == SAMPCAP
161 pin |= GPIO_PIN_14;
162 #endif
163 return pin;
164 }
165
166 /*!
167 * @brief Output Open-Drain for Sampling Capacitor in GPIOC
168 *
169 * @param None
170 *
171 * @retval pin value
172 */
TSC_Acq_GPIOC_SAMPCAP(void)173 uint32_t TSC_Acq_GPIOC_SAMPCAP(void)
174 {
175 uint32_t pin = 0;
176 #if TOUCH_TSC_GROUP3_IO1 == SAMPCAP
177 pin |= GPIO_PIN_5;
178 #endif
179 return pin;
180 }
181
182 /*!
183 * @brief Output Open-Drain for Sampling Capacitor in GPIOD
184 *
185 * @param None
186 *
187 * @retval pin value
188 */
189 #if (TSC_GROUP8_ENABLED > 0)
TSC_Acq_GPIOD_SAMPCAP(void)190 uint32_t TSC_Acq_GPIOD_SAMPCAP(void)
191 {
192 uint32_t pin = 0;
193 #if TOUCH_TSC_GROUP8_IO1 == SAMPCAP
194 pin |= GPIO_PIN_12;
195 #endif
196 #if TOUCH_TSC_GROUP8_IO2 == SAMPCAP
197 pin |= GPIO_PIN_13;
198 #endif
199 #if TOUCH_TSC_GROUP8_IO3 == SAMPCAP
200 pin |= GPIO_PIN_14;
201 #endif
202 #if TOUCH_TSC_GROUP8_IO4 == SAMPCAP
203 pin |= GPIO_PIN_15;
204 #endif
205 return pin;
206 }
207 #endif
208
209 /*!
210 * @brief Output Open-Drain for Sampling Capacitor in GPIOE
211 *
212 * @param None
213 *
214 * @retval pin value
215 */
216 #if (TSC_GROUP7_ENABLED > 0)
TSC_Acq_GPIOE_SAMPCAP(void)217 uint32_t TSC_Acq_GPIOE_SAMPCAP(void)
218 {
219 pin = 0;
220 #if TOUCH_TSC_GROUP7_IO1 == SAMPCAP
221 pin |= GPIO_PIN_2;
222 #endif
223 #if TOUCH_TSC_GROUP7_IO2 == SAMPCAP
224 pin |= GPIO_PIN_3;
225 #endif
226 #if TOUCH_TSC_GROUP7_IO3 == SAMPCAP
227 pin |= GPIO_PIN_4;
228 #endif
229 #if TOUCH_TSC_GROUP7_IO4 == SAMPCAP
230 pin |= GPIO_PIN_5;
231 #endif
232 return pin;
233 }
234 #endif
235
236 /*!
237 * @brief Output Push-Pull for Channel and Shield GPIOA
238 *
239 * @param None
240 *
241 * @retval pin value
242 */
TSC_Acq_GPIOA_CHANNEL_SHIELD(void)243 uint32_t TSC_Acq_GPIOA_CHANNEL_SHIELD(void)
244 {
245 uint32_t pin = 0;
246 #if (TOUCH_TSC_GROUP1_IO1 == CHANNEL) || (TOUCH_TSC_GROUP1_IO1 == SHIELD)
247 pin |= GPIO_PIN_0;
248 #endif
249 #if (TOUCH_TSC_GROUP1_IO2 == CHANNEL) || (TOUCH_TSC_GROUP1_IO2 == SHIELD)
250 pin |= GPIO_PIN_1;
251 #endif
252 #if (TOUCH_TSC_GROUP1_IO3 == CHANNEL) || (TOUCH_TSC_GROUP1_IO3 == SHIELD)
253 pin |= GPIO_PIN_2;
254 #endif
255 #if (TOUCH_TSC_GROUP1_IO4 == CHANNEL) || (TOUCH_TSC_GROUP1_IO4 == SHIELD)
256 pin |= GPIO_PIN_3;
257 #endif
258 #if (TOUCH_TSC_GROUP2_IO1 == CHANNEL) || (TOUCH_TSC_GROUP2_IO1 == SHIELD)
259 pin |= GPIO_PIN_4;
260 #endif
261 #if (TOUCH_TSC_GROUP2_IO2 == CHANNEL) || (TOUCH_TSC_GROUP2_IO2 == SHIELD)
262 pin |= GPIO_PIN_5;
263 #endif
264 #if (TOUCH_TSC_GROUP2_IO3 == CHANNEL) || (TOUCH_TSC_GROUP2_IO3 == SHIELD)
265 pin |= GPIO_PIN_6;
266 #endif
267 #if (TOUCH_TSC_GROUP2_IO4 == CHANNEL) || (TOUCH_TSC_GROUP2_IO4 == SHIELD)
268 pin |= GPIO_PIN_7;
269 #endif
270 #if (TOUCH_TSC_GROUP4_IO1 == CHANNEL) || (TOUCH_TSC_GROUP4_IO1 == SHIELD)
271 pin |= GPIO_PIN_9;
272 #endif
273 #if (TOUCH_TSC_GROUP4_IO2 == CHANNEL) || (TOUCH_TSC_GROUP4_IO2 == SHIELD)
274 pin |= GPIO_PIN_10;
275 #endif
276 #if (TOUCH_TSC_GROUP4_IO3 == CHANNEL) || (TOUCH_TSC_GROUP4_IO3 == SHIELD)
277 pin |= GPIO_PIN_11;
278 #endif
279 #if (TOUCH_TSC_GROUP4_IO4 == CHANNEL) || (TOUCH_TSC_GROUP4_IO4 == SHIELD)
280 pin |= GPIO_PIN_12;
281 #endif
282 return pin;
283 }
284
285 /*!
286 * @brief Output Push-Pull for Channel and Shield GPIOB
287 *
288 * @param None
289 *
290 * @retval pin value
291 */
TSC_Acq_GPIOB_CHANNEL_SHIELD(void)292 uint32_t TSC_Acq_GPIOB_CHANNEL_SHIELD(void)
293 {
294 uint32_t pin = 0;
295 #if (TOUCH_TSC_GROUP3_IO2 == CHANNEL) || (TOUCH_TSC_GROUP3_IO2 == SHIELD)
296 pin |= GPIO_PIN_0;
297 #endif
298 #if (TOUCH_TSC_GROUP3_IO3 == CHANNEL) || (TOUCH_TSC_GROUP3_IO3 == SHIELD)
299 pin |= GPIO_PIN_1;
300 #endif
301 #if (TOUCH_TSC_GROUP3_IO4 == CHANNEL) || (TOUCH_TSC_GROUP3_IO4 == SHIELD)
302 pin |= GPIO_PIN_2;
303 #endif
304 #if (TOUCH_TSC_GROUP5_IO1 == CHANNEL) || (TOUCH_TSC_GROUP5_IO1 == SHIELD)
305 pin |= GPIO_PIN_3;
306 #endif
307 #if (TOUCH_TSC_GROUP5_IO2 == CHANNEL) || (TOUCH_TSC_GROUP5_IO2 == SHIELD)
308 pin |= GPIO_PIN_4;
309 #endif
310 #if (TOUCH_TSC_GROUP5_IO3 == CHANNEL) || (TOUCH_TSC_GROUP5_IO3 == SHIELD)
311 pin |= GPIO_PIN_6;
312 #endif
313 #if (TOUCH_TSC_GROUP5_IO4 == CHANNEL) || (TOUCH_TSC_GROUP5_IO4 == SHIELD)
314 pin |= GPIO_PIN_7;
315 #endif
316 #if (TOUCH_TSC_GROUP6_IO1 == CHANNEL) || (TOUCH_TSC_GROUP6_IO1 == SHIELD)
317 pin |= GPIO_PIN_11;
318 #endif
319 #if (TOUCH_TSC_GROUP6_IO2 == CHANNEL) || (TOUCH_TSC_GROUP6_IO2 == SHIELD)
320 pin |= GPIO_PIN_12;
321 #endif
322 #if (TOUCH_TSC_GROUP6_IO3 == CHANNEL) || (TOUCH_TSC_GROUP6_IO3 == SHIELD)
323 pin |= GPIO_PIN_13;
324 #endif
325 #if (TOUCH_TSC_GROUP6_IO4 == CHANNEL) || (TOUCH_TSC_GROUP6_IO4 == SHIELD)
326 pin |= GPIO_PIN_14;
327 #endif
328 return pin;
329 }
330
331 /*!
332 * @brief Output Push-Pull for Channel and Shield GPIOC
333 *
334 * @param None
335 *
336 * @retval pin value
337 */
TSC_Acq_GPIOC_CHANNEL_SHIELD(void)338 uint32_t TSC_Acq_GPIOC_CHANNEL_SHIELD(void)
339 {
340 uint32_t pin = 0;
341 #if (TOUCH_TSC_GROUP3_IO1 == CHANNEL) || (TOUCH_TSC_GROUP3_IO1 == SHIELD)
342 pin |= GPIO_PIN_5;
343 #endif
344 return pin;
345 }
346
347 /*!
348 * @brief Output Push-Pull for Channel and Shield GPIOD
349 *
350 * @param None
351 *
352 * @retval pin value
353 */
354 #if (TSC_GROUP8_ENABLED > 0)
TSC_Acq_GPIOD_CHANNEL_SHIELD(void)355 uint32_t TSC_Acq_GPIOD_CHANNEL_SHIELD(void)
356 {
357 uint32_t pin = 0;
358 #if (TOUCH_TSC_GROUP8_IO1 == CHANNEL) || (TOUCH_TSC_GROUP8_IO1 == SHIELD)
359 pin |= GPIO_PIN_12;
360 #endif
361 #if (TOUCH_TSC_GROUP8_IO2 == CHANNEL) || (TOUCH_TSC_GROUP8_IO2 == SHIELD)
362 pin |= GPIO_PIN_13;
363 #endif
364 #if (TOUCH_TSC_GROUP8_IO3 == CHANNEL) || (TOUCH_TSC_GROUP8_IO3 == SHIELD)
365 pin |= GPIO_PIN_14;
366 #endif
367 #if (TOUCH_TSC_GROUP8_IO4 == CHANNEL) || (TOUCH_TSC_GROUP8_IO4 == SHIELD)
368 pin |= GPIO_PIN_15;
369 #endif
370 return pin;
371 }
372 #endif
373
374 /*!
375 * @brief Output Push-Pull for Channel and Shield GPIOE
376 *
377 * @param None
378 *
379 * @retval pin value
380 */
381 #if (TSC_GROUP7_ENABLED > 0)
TSC_Acq_GPIOE_CHANNEL_SHIELD(void)382 uint32_t TSC_Acq_GPIOE_CHANNEL_SHIELD(void)
383 {
384 uint32_t pin = 0;
385 #if (TOUCH_TSC_GROUP7_IO1 == CHANNEL) || (TOUCH_TSC_GROUP7_IO1 == SHIELD)
386 pin |= GPIO_PIN_2;
387 #endif
388 #if (TOUCH_TSC_GROUP7_IO2 == CHANNEL) || (TOUCH_TSC_GROUP7_IO2 == SHIELD)
389 pin |= GPIO_PIN_3;
390 #endif
391 #if (TOUCH_TSC_GROUP7_IO3 == CHANNEL) || (TOUCH_TSC_GROUP7_IO3 == SHIELD)
392 pin |= GPIO_PIN_4;
393 #endif
394 #if (TOUCH_TSC_GROUP7_IO4 == CHANNEL) || (TOUCH_TSC_GROUP7_IO4 == SHIELD)
395 pin |= GPIO_PIN_5;
396 #endif
397 return pin;
398 #endif
399
400 /*!
401 * @brief Alternate-Function AF3 for GPIOA in ALFL register
402 *
403 * @param None
404 *
405 * @retval ALFL value
406 */
407 uint32_t TSC_Acq_GPIOA_AF3_L(void)
408 {
409 uint32_t val_ALFL = 0;
410 #if TOUCH_TSC_GROUP1_IO1 != NU
411 val_ALFL |= (uint32_t)((uint32_t)3 << (0 * 4));
412 #endif
413 #if TOUCH_TSC_GROUP1_IO2 != NU
414 val_ALFL |= (uint32_t)((uint32_t)3 << (1 * 4));
415 #endif
416 #if TOUCH_TSC_GROUP1_IO3 != NU
417 val_ALFL |= (uint32_t)((uint32_t)3 << (2 * 4));
418 #endif
419 #if TOUCH_TSC_GROUP1_IO4 != NU
420 val_ALFL |= (uint32_t)((uint32_t)3 << (3 * 4));
421 #endif
422 #if TOUCH_TSC_GROUP2_IO1 != NU
423 val_ALFL |= (uint32_t)((uint32_t)3 << (4 * 4));
424 #endif
425 #if TOUCH_TSC_GROUP2_IO2 != NU
426 val_ALFL |= (uint32_t)((uint32_t)3 << (5 * 4));
427 #endif
428 #if TOUCH_TSC_GROUP2_IO3 != NU
429 val_ALFL |= (uint32_t)((uint32_t)3 << (6 * 4));
430 #endif
431 #if TOUCH_TSC_GROUP2_IO4 != NU
432 val_ALFL |= (uint32_t)((uint32_t)3 << (7 * 4));
433 #endif
434 return val_ALFL;
435 }
436
437 /*!
438 * @brief Alternate-Function AF3 for GPIOA in ALFH register
439 *
440 * @param None
441 *
442 * @retval ALFH value
443 */
444 uint32_t TSC_Acq_GPIOA_AF3_H(void)
445 {
446 uint32_t val_ALFH = 0;
447 #if TOUCH_TSC_GROUP4_IO1 != NU
448 val_ALFH |= (uint32_t)((uint32_t)3 << (1 * 4));
449 #endif
450 #if TOUCH_TSC_GROUP4_IO2 != NU
451 val_ALFH |= (uint32_t)((uint32_t)3 << (2 * 4));
452 #endif
453 #if TOUCH_TSC_GROUP4_IO3 != NU
454 val_ALFH |= (uint32_t)((uint32_t)3 << (3 * 4));
455 #endif
456 #if TOUCH_TSC_GROUP4_IO4 != NU
457 val_ALFH |= (uint32_t)((uint32_t)3 << (4 * 4));
458 #endif
459 return val_ALFH;
460 }
461
462 /*!
463 * @brief Alternate-Function AF3 for GPIOB in ALFL register
464 *
465 * @param None
466 *
467 * @retval ALFL value
468 */
469 uint32_t TSC_Acq_GPIOB_AF3_L(void)
470 {
471 uint32_t val_ALFL = 0;
472 #if TOUCH_TSC_GROUP3_IO2 != NU
473 val_ALFL |= (uint32_t)((uint32_t)3 << (0 * 4));
474 #endif
475 #if TOUCH_TSC_GROUP3_IO3 != NU
476 val_ALFL |= (uint32_t)((uint32_t)3 << (1 * 4));
477 #endif
478 #if TOUCH_TSC_GROUP3_IO4 != NU
479 val_ALFL |= (uint32_t)((uint32_t)3 << (2 * 4));
480 #endif
481 #if TOUCH_TSC_GROUP5_IO1 != NU
482 val_ALFL |= (uint32_t)((uint32_t)3 << (3 * 4));
483 #endif
484 #if TOUCH_TSC_GROUP5_IO2 != NU
485 val_ALFL |= (uint32_t)((uint32_t)3 << (4 * 4));
486 #endif
487 #if TOUCH_TSC_GROUP5_IO3 != NU
488 val_ALFL |= (uint32_t)((uint32_t)3 << (6 * 4));
489 #endif
490 #if TOUCH_TSC_GROUP5_IO4 != NU
491 val_ALFL |= (uint32_t)((uint32_t)3 << (7 * 4));
492 #endif
493 return val_ALFL;
494 }
495
496 /*!
497 * @brief Alternate-Function AF3 for GPIOB in ALFH register
498 *
499 * @param None
500 *
501 * @retval ALFH value
502 */
503 uint32_t TSC_Acq_GPIOB_AF3_H(void)
504 {
505 uint32_t val_ALFH = 0;
506 #if TOUCH_TSC_GROUP6_IO1 != NU
507 val_ALFH |= (uint32_t)((uint32_t)3 << (3 * 4));
508 #endif
509 #if TOUCH_TSC_GROUP6_IO2 != NU
510 val_ALFH |= (uint32_t)((uint32_t)3 << (4 * 4));
511 #endif
512 #if TOUCH_TSC_GROUP6_IO3 != NU
513 val_ALFH |= (uint32_t)((uint32_t)3 << (5 * 4));
514 #endif
515 #if TOUCH_TSC_GROUP6_IO4 != NU
516 val_ALFH |= (uint32_t)((uint32_t)3 << (6 * 4));
517 #endif
518 return val_ALFH;
519 }
520
521 /*!
522 * @brief Alternate-Function AF1 for GPIOD in ALFH register
523 *
524 * @param None
525 *
526 * @retval ALFH value
527 */
528 #if (TSC_GROUP8_ENABLED > 0)
529 uint32_t TSC_Acq_GPIOD_AF1_H(void)
530 {
531 uint32_t val_ALFH = 0;
532 #if TOUCH_TSC_GROUP8_IO1 != NU
533 val_ALFH |= (uint32_t)((uint32_t)1 << (4 * 4));
534 #endif
535 #if TOUCH_TSC_GROUP8_IO2 != NU
536 val_ALFH |= (uint32_t)((uint32_t)1 << (5 * 4));
537 #endif
538 #if TOUCH_TSC_GROUP8_IO3 != NU
539 val_ALFH |= (uint32_t)((uint32_t)1 << (6 * 4));
540 #endif
541 #if TOUCH_TSC_GROUP8_IO4 != NU
542 val_ALFH |= (uint32_t)((uint32_t)1 << (7 * 4));
543 #endif
544 return val_ALFH;
545 }
546 #endif
547
548 /*!
549 * @brief Alternate-Function AF1 for GPIOE in ALFL register
550 *
551 * @param None
552 *
553 * @retval ALFL value
554 */
555 #if (TSC_GROUP7_ENABLED > 0)
556 uint32_t TSC_Acq_GPIOE_AF1_L(void)
557 {
558 uint32_t val_ALFL = 0;
559 #if TOUCH_TSC_GROUP7_IO1 != NU
560 val_ALFL |= (uint32_t)((uint32_t)1 << (2 * 4));
561 #endif
562 #if TOUCH_TSC_GROUP7_IO2 != NU
563 val_ALFL |= (uint32_t)((uint32_t)1 << (3 * 4));
564 #endif
565 #if TOUCH_TSC_GROUP7_IO3 != NU
566 val_ALFL |= (uint32_t)((uint32_t)1 << (4 * 4));
567 #endif
568 #if TOUCH_TSC_GROUP7_IO4 != NU
569 val_ALFL |= (uint32_t)((uint32_t)1 << (5 * 4));
570 #endif
571 return val_ALFL;
572 }
573 #endif
574
575 /*!
576 * @brief Disable Schmitt trigger hysteresis GPIO in IOHCTRL register
577 *
578 * @param None
579 *
580 * @retval IOHCTRL value
581 */
582 uint32_t TSC_Acq_Schmitt_Trigger_Hysteresis(void)
583 {
584 uint32_t val_IOHCTRL = 0xFFFFFFFF;
585 #if TOUCH_TSC_GROUP1_IO1 != NU
586 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 0);
587 #endif
588 #if TOUCH_TSC_GROUP1_IO2 != NU
589 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 1);
590 #endif
591 #if TOUCH_TSC_GROUP1_IO3 != NU
592 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 2);
593 #endif
594 #if TOUCH_TSC_GROUP1_IO4 != NU
595 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 3);
596 #endif
597 #if TOUCH_TSC_GROUP2_IO1 != NU
598 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 4);
599 #endif
600 #if TOUCH_TSC_GROUP2_IO2 != NU
601 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 5);
602 #endif
603 #if TOUCH_TSC_GROUP2_IO3 != NU
604 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 6);
605 #endif
606 #if TOUCH_TSC_GROUP2_IO4 != NU
607 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 7);
608 #endif
609 #if TOUCH_TSC_GROUP3_IO1 != NU
610 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 8);
611 #endif
612 #if TOUCH_TSC_GROUP3_IO2 != NU
613 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 9);
614 #endif
615 #if TOUCH_TSC_GROUP3_IO3 != NU
616 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 10);
617 #endif
618 #if TOUCH_TSC_GROUP3_IO4 != NU
619 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 11);
620 #endif
621 #if TOUCH_TSC_GROUP4_IO1 != NU
622 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 12);
623 #endif
624 #if TOUCH_TSC_GROUP4_IO2 != NU
625 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 13);
626 #endif
627 #if TOUCH_TSC_GROUP4_IO3 != NU
628 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 14);
629 #endif
630 #if TOUCH_TSC_GROUP4_IO4 != NU
631 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 15);
632 #endif
633 #if TOUCH_TSC_GROUP5_IO1 != NU
634 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 16);
635 #endif
636 #if TOUCH_TSC_GROUP5_IO2 != NU
637 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 17);
638 #endif
639 #if TOUCH_TSC_GROUP5_IO3 != NU
640 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 18);
641 #endif
642 #if TOUCH_TSC_GROUP5_IO4 != NU
643 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 19);
644 #endif
645 #if TOUCH_TSC_GROUP6_IO1 != NU
646 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 20);
647 #endif
648 #if TOUCH_TSC_GROUP6_IO2 != NU
649 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 21);
650 #endif
651 #if TOUCH_TSC_GROUP6_IO3 != NU
652 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 22);
653 #endif
654 #if TOUCH_TSC_GROUP6_IO4 != NU
655 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 23);
656 #endif
657 #if (TSC_GROUP7_ENABLED > 0)
658 #if TOUCH_TSC_GROUP7_IO1 != NU
659 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 24);
660 #endif
661 #if TOUCH_TSC_GROUP7_IO2 != NU
662 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 25);
663 #endif
664 #if TOUCH_TSC_GROUP7_IO3 != NU
665 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 26);
666 #endif
667 #if TOUCH_TSC_GROUP7_IO4 != NU
668 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 27);
669 #endif
670 #endif /*!< TSC_GROUP7_ENABLED */
671 #if (TSC_GROUP8_ENABLED > 0)
672 #if TOUCH_TSC_GROUP8_IO1 != NU
673 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 28);
674 #endif
675 #if TOUCH_TSC_GROUP8_IO2 != NU
676 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 29);
677 #endif
678 #if TOUCH_TSC_GROUP8_IO3 != NU
679 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 30);
680 #endif
681 #if TOUCH_TSC_GROUP8_IO4 != NU
682 val_IOHCTRL &= (uint32_t)~((uint32_t)1 << 31);
683 #endif
684 #endif /*!< TSC_GROUP8_ENABLED */
685 return val_IOHCTRL;
686 }
687
688 /*!
689 * @brief Sampling Capacitor GPIO in IOSMPCTRL register
690 *
691 * @param None
692 *
693 * @retval IOSMPCTRL value
694 */
695 uint32_t TSC_Acq_Sampling_Capacitor(void)
696 {
697 uint32_t val_IOSMPCTRL = 0;
698 #if TOUCH_TSC_GROUP1_IO1 == SAMPCAP
699 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 0);
700 #endif
701 #if TOUCH_TSC_GROUP1_IO2 == SAMPCAP
702 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 1);
703 #endif
704 #if TOUCH_TSC_GROUP1_IO3 == SAMPCAP
705 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 2);
706 #endif
707 #if TOUCH_TSC_GROUP1_IO4 == SAMPCAP
708 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 3);
709 #endif
710 #if TOUCH_TSC_GROUP2_IO1 == SAMPCAP
711 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 4);
712 #endif
713 #if TOUCH_TSC_GROUP2_IO2 == SAMPCAP
714 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 5);
715 #endif
716 #if TOUCH_TSC_GROUP2_IO3 == SAMPCAP
717 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 6);
718 #endif
719 #if TOUCH_TSC_GROUP2_IO4 == SAMPCAP
720 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 7);
721 #endif
722 #if TOUCH_TSC_GROUP3_IO1 == SAMPCAP
723 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 8);
724 #endif
725 #if TOUCH_TSC_GROUP3_IO2 == SAMPCAP
726 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 9);
727 #endif
728 #if TOUCH_TSC_GROUP3_IO3 == SAMPCAP
729 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 10);
730 #endif
731 #if TOUCH_TSC_GROUP3_IO4 == SAMPCAP
732 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 11);
733 #endif
734 #if TOUCH_TSC_GROUP4_IO1 == SAMPCAP
735 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 12);
736 #endif
737 #if TOUCH_TSC_GROUP4_IO2 == SAMPCAP
738 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 13);
739 #endif
740 #if TOUCH_TSC_GROUP4_IO3 == SAMPCAP
741 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 14);
742 #endif
743 #if TOUCH_TSC_GROUP4_IO4 == SAMPCAP
744 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 15);
745 #endif
746 #if TOUCH_TSC_GROUP5_IO1 == SAMPCAP
747 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 16);
748 #endif
749 #if TOUCH_TSC_GROUP5_IO2 == SAMPCAP
750 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 17);
751 #endif
752 #if TOUCH_TSC_GROUP5_IO3 == SAMPCAP
753 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 18);
754 #endif
755 #if TOUCH_TSC_GROUP5_IO4 == SAMPCAP
756 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 19);
757 #endif
758 #if TOUCH_TSC_GROUP6_IO1 == SAMPCAP
759 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 20);
760 #endif
761 #if TOUCH_TSC_GROUP6_IO2 == SAMPCAP
762 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 21);
763 #endif
764 #if TOUCH_TSC_GROUP6_IO3 == SAMPCAP
765 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 22);
766 #endif
767 #if TOUCH_TSC_GROUP6_IO4 == SAMPCAP
768 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 23);
769 #endif
770 #if (TSC_GROUP7_ENABLED > 0)
771 #if TOUCH_TSC_GROUP7_IO1 == SAMPCAP
772 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 24);
773 #endif
774 #if TOUCH_TSC_GROUP7_IO2 == SAMPCAP
775 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 25);
776 #endif
777 #if TOUCH_TSC_GROUP7_IO3 == SAMPCAP
778 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 26);
779 #endif
780 #if TOUCH_TSC_GROUP7_IO4 == SAMPCAP
781 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 27);
782 #endif
783 #endif /*!< TSC_GROUP7_ENABLED */
784 #if (TSC_GROUP8_ENABLED > 0)
785 #if TOUCH_TSC_GROUP8_IO1 == SAMPCAP
786 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 28);
787 #endif
788 #if TOUCH_TSC_GROUP8_IO2 == SAMPCAP
789 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 29);
790 #endif
791 #if TOUCH_TSC_GROUP8_IO3 == SAMPCAP
792 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 30);
793 #endif
794 #if TOUCH_TSC_GROUP8_IO4 == SAMPCAP
795 val_IOSMPCTRL |= (uint32_t)((uint32_t)1 << 31);
796 #endif
797 #endif /*!< TSC_GROUP8_ENABLED */
798 return val_IOSMPCTRL;
799 }
800
801 /*!
802 * @brief Config the Touch Sensing GPIO
803 *
804 * @param None
805 *
806 * @retval None
807 *
808 * @note NU: Not Used IO
809 * CHANNEL: Channel IO
810 * SHIELD: Channel IO but not acquired
811 * SAMPCAP: Sampling Capacitor IO
812 */
813 void TSC_Acq_ConfigGPIO(void)
814 {
815 GPIO_Config_T gpioConfig;
816
817 RCM_EnableAHBPeriphClock(RCM_AHB_PERIPH_GPIOA | RCM_AHB_PERIPH_GPIOB | RCM_AHB_PERIPH_GPIOC);
818 #if (TSC_GROUP7_ENABLED > 0) || (TSC_GROUP8_ENABLED > 0)
819 RCM_EnableAHBPeriphClock(RCM_AHB_PERIPH_GPIOD | RCM_AHB_PERIPH_GPIOE);
820 #endif
821
822 /* Alternate function Output Open-Drain for Sampling Capacitor IOs */
823 gpioConfig.mode = GPIO_MODE_AF;
824 gpioConfig.outtype = GPIO_OUT_TYPE_OD;
825 gpioConfig.speed = GPIO_SPEED_2MHz;
826 gpioConfig.pupd = GPIO_PUPD_NO;
827
828 /* GPIOA */
829 gpioConfig.pin = TSC_Acq_GPIOA_SAMPCAP();
830 GPIO_Config(GPIOA, &gpioConfig);
831
832 /* GPIOB */
833 gpioConfig.pin = TSC_Acq_GPIOB_SAMPCAP();
834 GPIO_Config(GPIOB, &gpioConfig);
835
836 /* GPIOC */
837 gpioConfig.pin = TSC_Acq_GPIOC_SAMPCAP();
838 GPIO_Config(GPIOC, &gpioConfig);
839
840 /* GPIOD */
841 #if (TSC_GROUP8_ENABLED > 0)
842 gpioConfig.pin = TSC_Acq_GPIOD_SAMPCAP();
843 GPIO_Config(GPIOD, &gpioConfig);
844 #endif
845
846 /* GPIOE */
847 #if (TSC_GROUP7_ENABLED > 0)
848 gpioConfig.pin = TSC_Acq_GPIOE_SAMPCAP();
849 GPIO_Config(GPIOE, &gpioConfig);
850 #endif
851
852 /* Alternate function Output Push-Pull for Channel and Shield IOs */
853 gpioConfig.outtype = GPIO_OUT_TYPE_PP;
854
855 /* GPIOA */
856 gpioConfig.pin = TSC_Acq_GPIOA_CHANNEL_SHIELD();
857 GPIO_Config(GPIOA, &gpioConfig);
858
859 /* GPIOB */
860 gpioConfig.pin = TSC_Acq_GPIOB_CHANNEL_SHIELD();
861 GPIO_Config(GPIOB, &gpioConfig);
862
863 /* GPIOC */
864 gpioConfig.pin = TSC_Acq_GPIOC_CHANNEL_SHIELD();
865 GPIO_Config(GPIOC, &gpioConfig);
866
867 /* GPIOD */
868 #if (TSC_GROUP8_ENABLED > 0)
869 gpioConfig.pin = TSC_Acq_GPIOD_CHANNEL_SHIELD();
870 GPIO_Config(GPIOD, &gpioConfig);
871 #endif
872
873 /* GPIOE */
874 #if (TSC_GROUP7_ENABLED > 0)
875 gpioConfig.pin = TSC_Acq_GPIOE_CHANNEL_SHIELD();
876 GPIO_Config(GPIOE, &gpioConfig);
877 #endif
878
879 /* Config Alternate-Function AF3 for GPIOA and GPIOB */
880 /* GPIOA */
881 GPIOA->ALFL |= TSC_Acq_GPIOA_AF3_L();
882 GPIOA->ALFH |= TSC_Acq_GPIOA_AF3_H();
883
884 /* GPIOB */
885 GPIOB->ALFL |= TSC_Acq_GPIOB_AF3_L();
886 GPIOB->ALFH |= TSC_Acq_GPIOB_AF3_H();
887
888 /* Config Alternate-Function AF1 for GPIOD and GPIOE */
889 /* GPIOD */
890 #if (TSC_GROUP8_ENABLED > 0)
891 GPIOD->ALFH |= TSC_Acq_GPIOD_AF1_H();
892 #endif
893
894 /* GPIOE */
895 #if (TSC_GROUP7_ENABLED > 0)
896 GPIOE->ALFL |= TSC_Acq_GPIOE_AF1_L();
897 #endif
898
899 RCM_EnableAHBPeriphClock(RCM_AHB_PERIPH_TSC);
900
901 /* Disable Schmitt trigger hysteresis on all used TSC IOs */
902 TSC->IOHCTRL &= TSC_Acq_Schmitt_Trigger_Hysteresis();
903
904 /* Config Sampling Capacitor IOs */
905 TSC->IOSMPCTRL |= TSC_Acq_Sampling_Capacitor();
906 }
907
908 /*!
909 * @brief Configurate the acquisition module
910 *
911 * @param None
912 *
913 * @retval pointer to a TSC_STATUS_T structure
914 */
915 TSC_STATUS_T TSC_Acq_Config(void)
916 {
917 #if TOUCH_TSC_GPIO_CONFIG > 0
918 TSC_Acq_ConfigGPIO();
919 #endif
920
921 RCM_EnableAHBPeriphClock(RCM_AHB_PERIPH_TSC);
922
923 /* TSC enabled */
924 TSC->CTRL = 0x01;
925
926 /* Config CTPHSEL */
927 #if TOUCH_TSC_CTPHSEL > 0
928 TSC->CTRL |= (uint32_t)((uint32_t)TOUCH_TSC_CTPHSEL << 28) & 0xF0000000;
929 #endif
930
931 /* Config CTPLSEL */
932 #if TOUCH_TSC_CTPLSEL > 0
933 TSC->CTRL |= (uint32_t)((uint32_t)TOUCH_TSC_CTPLSEL << 24) & 0x0F000000;
934 #endif
935
936 /* Config Spread Spectrum */
937 #if TOUCH_TSC_USE_SSEN > 0
938 TSC->CTRL |= (uint32_t)((uint32_t)TOUCH_TSC_USE_SSEN << 16) & 0x00010000;
939 TSC->CTRL |= (uint32_t)((uint32_t)TOUCH_TSC_SSERRVSEL << 17) & 0x00FE0000;
940 TSC->CTRL |= (uint32_t)((uint32_t)TOUCH_TSC_SSCDFSEL << 15) & 0x00008000;
941 #endif
942
943 /* Config Prescaler */
944 #if TOUCH_TSC_PGCDFSEL > 0
945 TSC->CTRL |= (uint32_t)((uint32_t)TOUCH_TSC_PGCDFSEL << 12) & 0x00007000;
946 #endif
947
948 /* Config Max Count */
949 #if TOUCH_TSC_MCNTVSEL > 0
950 TSC->CTRL |= (uint32_t)((uint32_t)TOUCH_TSC_MCNTVSEL << 5) & 0x000000E0;
951 #endif
952
953 /* Config IO default in Output PP Low to discharge all capacitors */
954 TSC->CTRL &= (uint32_t)(~(1 << 4));
955
956 /* Config Synchronization Mode */
957 #if TOUCH_TSC_AMCFG > 0
958 /* Config Synchronization Pin in Alternate-Function mode */
959 RCM_EnableAHBPeriphClock(RCM_AHB_PERIPH_GPIOB);
960
961 #if TOUCH_TSC_SYNC_PIN == 0 /*!< PB8 */
962 GPIOB->MODE &= 0xFFFCFFFF;
963 GPIOB->MODE |= 0x00020000;
964 GPIOB->ALFH |= 0x00000003;
965 #else /*!< PB10 */
966 GPIOB->MODE &= 0xFFCFFFFF;
967 GPIOB->MODE |= 0x00200000;
968 GPIOB->ALFH |= 0x00000300;
969 #endif
970
971 /* Config Synchronization Polarity */
972 TSC->CTRL |= (uint32_t)((uint32_t)TOUCH_TSC_SYNC_POL << 3) & 0x00000008;
973
974 /* Config acquisition mode */
975 TSC->CTRL |= (uint32_t)((uint32_t)TOUCH_TSC_AMCFG << 2) & 0x00000004;
976 #endif
977
978 #if TOUCH_USE_ACQ_INTERRUPT > 0
979 /* Config both EOAIEN and MCEIEN interrupts */
980 TSC->INTEN |= 0x03;
981 /* Configure NVIC */
982 NVIC_EnableIRQRequest(TSC_IRQn, 0)
983 #endif
984
985 /* Configure the delay that will be used to discharge the capacitors */
986 DelayDischarge = (uint32_t)((TOUCH_DELAY_DISCHARGE_ALL * (uint32_t)(SystemCoreClock / 1000000)) / 48);
987 return TSC_STATUS_OK;
988 }
989
990 /*!
991 * @brief Configures a Block
992 *
993 * @param idxBlock: Index of the Block
994 *
995 * @retval pointer to a TSC_STATUS_T structure
996 */
997 TSC_STATUS_T TSC_Acq_ConfigBlock(TSC_tIndex_T idxBlock)
998 {
999 uint32_t idxChannel;
1000 uint32_t objStatus;
1001 uint32_t Gx, IOy;
1002 CONST TSC_Block_T* block = &(TSC_Globals.Block_Array[idxBlock]);
1003 CONST TSC_Channel_Src_T* pchSrc = block->p_chSrc;
1004 CONST TSC_Channel_Dest_T* pchDest = block->p_chDest;
1005
1006 /* Mark the current block processed */
1007 TSC_Globals.For_Block = idxBlock;
1008 /* Enable the Gx_IOy used as channels (channels + shield) */
1009 TSC->IOCHCTRL = block->msk_IOCHCTRL_channels;
1010 /* Enable acquisition on selected Groups */
1011 TSC->IOGCSTS = block->msk_IOGCSTS_groups;
1012
1013 for (idxChannel = 0; idxChannel < block->NumChannel; idxChannel++)
1014 {
1015 /* Read Object status flag */
1016 objStatus = block->p_chData[pchDest->IdxDest].Flag.ObjStatus;
1017
1018 if (objStatus != TSC_OBJ_STATUS_ON)
1019 {
1020 /* Read the Channel Group mask */
1021 Gx = pchSrc->msk_IOGCSTS_group;
1022 /* Stop acquisition of the Group */
1023 TSC->IOGCSTS &= (uint32_t)~Gx;
1024
1025 if (objStatus == TSC_OBJ_STATUS_OFF)
1026 {
1027 /* Read the Channel IO mask */
1028 IOy = pchSrc->msk_IOCHCTRL_channel;
1029 /* Stop Burst of the Channel */
1030 TSC->IOCHCTRL &= (uint32_t)~IOy;
1031 }
1032 }
1033 /* Next channel */
1034 pchSrc++;
1035 pchDest++;
1036 }
1037 return TSC_STATUS_OK;
1038 }
1039
1040 /*!
1041 * @brief Start acquisition on a previously configured block
1042 *
1043 * @param None
1044 *
1045 * @retval None
1046 */
1047 void TSC_Acq_StartPerConfigBlock(void)
1048 {
1049 /* Clear both EOAIC and MCEIC flag */
1050 TSC->INTFCLR |= 0x03;
1051
1052 /* Wait capacitors discharge */
1053 SoftDelay(DelayDischarge);
1054
1055 #if TOUCH_TSC_IODEF > 0
1056 /* Config IO default in Input Floating */
1057 TSC->CTRL |= (1 << 4);
1058 #endif
1059
1060 /* Start acquisition */
1061 TSC->CTRL |= 0x02;
1062 }
1063
1064 /*!
1065 * @brief Wait end of acquisition
1066 *
1067 * @param None
1068 *
1069 * @retval None
1070 */
1071 TSC_STATUS_T TSC_Acq_WaitBlockEOA(void)
1072 {
1073 TSC_STATUS_T retval = TSC_STATUS_BUSY;
1074
1075 /* Check EOAFLG flag */
1076 if (TSC->INTSTS & 0x01)
1077 {
1078 #if TOUCH_TSC_IODEF > 0
1079 /* Config IO default in Output PP Low to discharge all capacitors */
1080 TSC->CTRL &= (uint32_t)(~(1 << 4));
1081 #endif
1082
1083 /* Check MCEFLG flag */
1084 if (TSC->INTSTS & 0x02)
1085 {
1086 retval = TSC_STATUS_ERROR;
1087 }
1088 else
1089 {
1090 retval = TSC_STATUS_OK;
1091 }
1092 }
1093 return retval;
1094 }
1095
1096 /*!
1097 * @brief Return the current measure
1098 *
1099 * @param index: Index of the measure source
1100 *
1101 * @retval Measure
1102 */
1103 TSC_tMeas_T TSC_Acq_ReadMeasurVal(TSC_tIndex_T index)
1104 {
1105 return ((TSC_tMeas_T)(TSC->IOGxCNT[index].IOGCNT));
1106 }
1107
1108 /*!
1109 * @brief Compute the Delta value
1110 *
1111 * @param refVal: Reference value
1112 *
1113 * @param measVal: Measurement value
1114 *
1115 * @retval Delta value
1116 */
1117 TSC_tDelta_T TSC_Acq_ComputeDelta(TSC_tRefer_T refVal, TSC_tMeas_T measVal)
1118 {
1119 return ((TSC_tDelta_T)(refVal - measVal));
1120 }
1121
1122 /*!
1123 * @brief Compute the Measurement value
1124 *
1125 * @param refVal: Reference value
1126 *
1127 * @param deltaVal: delta Delta value
1128 *
1129 * @retval Measurement value
1130 */
1131 TSC_tMeas_T TSC_Acq_ComputeMeas(TSC_tRefer_T refVal, TSC_tDelta_T deltaVal)
1132 {
1133 return ((TSC_tMeas_T)(refVal - deltaVal));
1134 }
1135
1136 /*!
1137 * @brief Check noise (not used)
1138 *
1139 * @param None
1140 *
1141 * @retval pointer to a TSC_STATUS_T structure
1142 */
1143 TSC_ACQ_STATUS_T TSC_Acq_CheckNoise(void)
1144 {
1145 return TSC_ACQ_STATUS_OK;
1146 }
1147
1148 /*!
1149 * @brief Check if a filter must be used on the current channel (not used)
1150 *
1151 * @param pCh: Pointer on the channel data information
1152 *
1153 * @retval Result TRUE if a filter can be applied
1154 */
1155 TSC_BOOL_T TSC_Acq_UseFilter(TSC_Channel_Data_T * pCh)
1156 {
1157 return TSC_TRUE;
1158 }
1159
1160 /*!
1161 * @brief Test if the Reference is incorrect (not used)
1162 *
1163 * @param pCh: Pointer on the channel data information
1164 *
1165 * @retval Result TRUE if the Reference is out of range
1166 */
1167 TSC_BOOL_T TSC_Acq_TestReferenceRange(TSC_Channel_Data_T * pCh)
1168 {
1169 return TSC_FALSE;
1170 }
1171
1172 /*!
1173 * @brief Test if the measure has crossed the reference target (not used)
1174 *
1175 * @param pCh: Pointer on the channel data information
1176 *
1177 * @param newMeas: Measure of the last acquisition on this channel
1178 *
1179 * @retval Result TRUE if the Reference is valid
1180 */
1181 TSC_BOOL_T TSC_Acq_TestFirstReference(TSC_Channel_Data_T * pCh, TSC_tMeas_T newMeas)
1182 {
1183 return TSC_TRUE;
1184 }
1185
1186 /*!
1187 * @brief Software delay (private routine)
1188 *
1189 * @param val: Wait delay
1190 *
1191 * @retval None
1192 *
1193 * @note Measurements done with HCLK=48MHz and Keil/MDK-ARM compiler
1194 * val = 500: ~ 53
1195 * val = 1000: ~106
1196 * val = 2000: ~210
1197 */
1198 void SoftDelay(uint32_t val)
1199 {
1200 uint32_t i;
1201 for (i = val; i > 0; i--)
1202 {}
1203 }
1204
1205 /*!
1206 * @brief Read all channels measurement of a Block, calculate delta
1207 *
1208 * @param idxBlock: Index of the Block to access
1209 *
1210 * @param mfilter: Pointer to the measure filter
1211 *
1212 * @param dfilter: Pointer to the delta filter
1213 *
1214 * @retval Status
1215 */
1216 TSC_STATUS_T TSC_Acq_ReadBlockResult(TSC_tIndex_T idxBlock, TSC_pMeasFilter_T mfilter, TSC_pDeltaFilter_T dfilter)
1217 {
1218 TSC_STATUS_T retval = TSC_STATUS_OK;
1219 TSC_tIndex_T idxChannel;
1220 TSC_tIndexDest_T idxDest;
1221 TSC_tMeas_T oldMeas, newMeas;
1222 TSC_tDelta_T newDelta;
1223 CONST TSC_Block_T* block = &(TSC_Globals.Block_Array[idxBlock]);
1224 CONST TSC_Channel_Dest_T* pchDest = block->p_chDest;
1225 CONST TSC_Channel_Src_T* pchSrc = block->p_chSrc;
1226
1227 /* For all channels in the block copy the measure + calculate delta and store them */
1228 for (idxChannel = 0; idxChannel < block->NumChannel; idxChannel++)
1229 {
1230 idxDest = pchDest->IdxDest;
1231
1232 if (block->p_chData[idxDest].Flag.ObjStatus == TSC_OBJ_STATUS_ON)
1233 {
1234 block->p_chData[idxDest].Flag.DataReady = TSC_DATA_READY;
1235 newMeas = TSC_Acq_ReadMeasurVal(pchSrc->IdxSrc);
1236
1237 #if TOUCH_USE_MEAS > 0
1238 oldMeas = block->p_chData[idxDest].Meas;
1239 #else
1240 oldMeas = newMeas;
1241 #endif
1242
1243 #if TOUCH_USE_MEAS > 0
1244 block->p_chData[idxDest].Meas = newMeas;
1245 #endif
1246
1247 /* Check acquisition value min/max */
1248 if (newMeas > TSC_Params.AcqMax)
1249 {
1250 block->p_chData[idxDest].Flag.AcqStatus = TSC_ACQ_STATUS_ERROR_MAX;
1251 block->p_chData[idxDest].Delta = 0;
1252 retval = TSC_STATUS_ERROR;
1253 }
1254 else
1255 {
1256 if (newMeas < TSC_Params.AcqMin)
1257 {
1258 block->p_chData[idxDest].Flag.AcqStatus = TSC_ACQ_STATUS_ERROR_MIN;
1259 block->p_chData[idxDest].Delta = 0;
1260 retval = TSC_STATUS_ERROR;
1261 }
1262 else /*!< The measure is OK */
1263 {
1264 if (TSC_Acq_UseFilter(&block->p_chData[idxDest]) == 0)
1265 {
1266 block->p_chData[idxDest].Delta = TSC_Acq_ComputeDelta(block->p_chData[idxDest].Refer, newMeas);
1267 block->p_chData[idxDest].Flag.AcqStatus = TSC_Acq_CheckNoise();
1268 }
1269 else
1270 {
1271 /* Measure filter*/
1272 if (mfilter)
1273 {
1274 newMeas = mfilter(oldMeas, newMeas);
1275 /* Store the measure */
1276 #if TOUCH_USE_MEAS > 0
1277 block->p_chData[idxDest].Meas = newMeas;
1278 #endif
1279 }
1280
1281 newDelta = TSC_Acq_ComputeDelta(block->p_chData[idxDest].Refer, newMeas);
1282 block->p_chData[idxDest].Flag.AcqStatus = TSC_Acq_CheckNoise();
1283
1284 /* Delta filter */
1285 if (dfilter == 0)
1286 {
1287 block->p_chData[idxDest].Delta = newDelta;
1288 }
1289 else
1290 {
1291 block->p_chData[idxDest].Delta = dfilter(newDelta);
1292 }
1293 }
1294 }
1295 }
1296 }
1297 pchDest++;
1298 pchSrc++;
1299 }
1300 return retval;
1301 }
1302
1303 /*!
1304 * @brief Calibrate a Block
1305 *
1306 * @param idxBlock: Index of the Block
1307 *
1308 * @retval Status
1309 */
1310 TSC_STATUS_T TSC_Acq_CalibrateBlock(TSC_tIndex_T idxBlock)
1311 {
1312 TSC_STATUS_T retval;
1313 TSC_STATUS_T acqStatus;
1314 TSC_tIndex_T idxChannel;
1315 TSC_tIndexDest_T idxDest;
1316 TSC_tMeas_T newMeas;
1317 static TSC_tIndex_T goCalibration = 0;
1318 static TSC_tNum_T doneCalibration = 0;
1319 static TSC_tNum_T CalibDiv;
1320 CONST TSC_Block_T* block;
1321 CONST TSC_Channel_Dest_T* pchDest;
1322 CONST TSC_Channel_Src_T* pchSrc;
1323
1324 block = &(TSC_Globals.Block_Array[idxBlock]);
1325
1326 if (goCalibration)/*!< Calibration is on-going */
1327 {
1328 acqStatus = TSC_Acq_WaitBlockEOA();
1329
1330 switch (acqStatus)
1331 {
1332 case TSC_STATUS_OK:
1333 pchDest = block->p_chDest;
1334 pchSrc = block->p_chSrc;
1335
1336 for (idxChannel = 0; idxChannel < block->NumChannel; idxChannel++)
1337 {
1338 idxDest = pchDest->IdxDest;
1339 newMeas = TSC_Acq_ReadMeasurVal(pchSrc->IdxSrc);
1340
1341 if ((newMeas < TSC_Params.AcqMin) || (newMeas > TSC_Params.AcqMax))
1342 {
1343 TSC_acq_ClearBlockData(idxBlock);
1344 goCalibration = 0;
1345 return TSC_STATUS_ERROR;
1346 }
1347 else
1348 {
1349 block->p_chData[idxDest].Refer += newMeas;
1350 }
1351 pchDest++;
1352 pchSrc++;
1353 }
1354
1355 doneCalibration--;
1356 if (doneCalibration)
1357 {
1358 TSC_Acq_StartPerConfigBlock();
1359 retval = TSC_STATUS_BUSY;
1360 }
1361 else
1362 {
1363 pchDest = block->p_chDest;
1364
1365 for (idxChannel = 0; idxChannel < block->NumChannel; idxChannel++)
1366 {
1367 idxDest = pchDest->IdxDest;
1368 /* Divide the Reference by the number of samples */
1369 block->p_chData[idxDest].Refer >>= CalibDiv;
1370 pchDest++;
1371 }
1372 goCalibration = 0;
1373 retval = TSC_STATUS_OK;
1374 }
1375 break;
1376 case TSC_STATUS_ERROR:
1377 TSC_acq_ClearBlockData(idxBlock);
1378 goCalibration = 0;
1379 retval = TSC_STATUS_ERROR;
1380 break;
1381 default:
1382 retval = TSC_STATUS_BUSY;
1383 break;
1384 }
1385 }
1386 else /*!< Calibration is done */
1387 {
1388 if (TSC_Params.NumCalibSample == 4)
1389 {
1390 CalibDiv = 2;
1391 }
1392 else if (TSC_Params.NumCalibSample == 16)
1393 {
1394 CalibDiv = 4;
1395 }
1396 else
1397 {
1398 TSC_Params.NumCalibSample = 8;
1399 CalibDiv = 3;
1400 }
1401
1402 TSC_acq_ClearBlockData(idxBlock);
1403
1404 if (TSC_Acq_ConfigBlock(idxBlock))
1405 {
1406 TSC_acq_ClearBlockData(idxBlock);
1407 goCalibration = 0;
1408 retval = TSC_STATUS_ERROR;
1409 }
1410 else
1411 {
1412 TSC_Acq_StartPerConfigBlock();
1413 goCalibration = 1;
1414 doneCalibration = TSC_Params.NumCalibSample;
1415 retval = TSC_STATUS_BUSY;
1416 }
1417 }
1418 return retval;
1419 }
1420
1421 /*!
1422 * @brief Clear Reference and delta on all channels of a Block
1423 *
1424 * @param idxBlock: Index of the Block
1425 *
1426 * @retval None
1427 */
1428 void TSC_acq_ClearBlockData(TSC_tIndex_T idxBlock)
1429 {
1430 TSC_tIndex_T idxChannel;
1431 TSC_tIndexDest_T idx_Dest;
1432 CONST TSC_Block_T* block = &(TSC_Globals.Block_Array[idxBlock]);
1433 CONST TSC_Channel_Dest_T* pchDest = block->p_chDest;
1434
1435 for (idxChannel = 0; idxChannel < block->NumChannel; idxChannel++)
1436 {
1437 idx_Dest = pchDest->IdxDest;
1438 block->p_chData[idx_Dest].Refer = 0;
1439 block->p_chData[idx_Dest].Delta = 0;
1440 pchDest++;
1441 }
1442 }
1443
1444 #if TOUCH_USE_ZONE > 0
1445
1446 /*!
1447 * @brief Configures a Zone
1448 *
1449 * @param zone: Zone to configure
1450 *
1451 * @param idxBlock: Index of the Block to access
1452 *
1453 * @retval Status
1454 */
1455 TSC_STATUS_T TSC_Acq_ConfigZone(CONST TSC_Zone_T * zone, TSC_tIndex_T idxBlock)
1456 {
1457 TSC_STATUS_T retval;
1458 TSC_Globals.For_Zone = zone;
1459
1460 do
1461 {
1462 retval = TSC_Acq_ConfigBlock(zone->indexBlock[idxBlock]);
1463 TSC_Globals.For_Block = zone->indexBlock[idxBlock];
1464 idxBlock++;
1465 }
1466 while ((idxBlock < zone->numBlock) && (retval == TSC_STATUS_ERROR));
1467
1468 TSC_Globals.Index_For_Zone = idxBlock;
1469
1470 #if TOUCH_PXS_LOW_POWER_MODE > 0
1471 if (idxBlock < zone->numBlock)
1472 {
1473 resetPXSLowPower();
1474 }
1475 #endif
1476
1477 return (retval);
1478 }
1479 #endif
1480
1481 /**@} end of group TSC_Acquisition_Functions */
1482 /**@} end of group TSC_Acquisition_Driver */
1483 /**@} end of group TSC_Driver_Library */
1484