1 /**
2 ******************************************************************************
3 * @file lib_cmp.c
4 * @author Application Team
5 * @version V1.1.0
6 * @date 2019-10-28
7 * @brief CMP library.
8 ******************************************************************************
9 * @attention
10 *
11 ******************************************************************************
12 */
13 #include "lib_cmp.h"
14
15 /* CMP1 reset values */
16 #define CMP1_REG2_Msk (0x13UL)
17 #define CMP1_REG3_Msk (0x02UL)
18 #define CMP1_REG5_Msk (0x03UL)
19 #define CMP1_REGF_Msk (0x01UL)
20 #define CMP1_CTRL_Msk (0x300003UL)
21 #define CMP1_INTSTS_Msk (0x04UL)
22 #define CMP1_INTEN_Msk (0x04UL)
23 #define CMP1_THR_Msk (0xFFFFUL)
24 #define CMP1_CTL_Msk (0x300FFUL)
25 /* CMP2 reset values */
26 #define CMP2_REG2_Msk (0x2CUL)
27 #define CMP2_REG3_Msk (0x04UL)
28 #define CMP2_REG5_Msk (0x0CUL)
29 #define CMP2_REGF_Msk (0x02UL)
30 #define CMP2_CTRL_Msk (0xC0000CUL)
31 #define CMP2_INTSTS_Msk (0x08UL)
32 #define CMP2_INTEN_Msk (0x08UL)
33 #define CMP2_THR_Msk (0xFFFF0000UL)
34 #define CMP2_CTL_Msk (0x30FF00UL)
35
36 /**
37 * @brief Initializes the Comparator peripheral registers to their default reset values.
38 * @param CMPx:
39 CMP_1
40 CMP_2
41 * @retval None
42 */
CMP_DeInit(uint32_t CMPx)43 void CMP_DeInit(uint32_t CMPx)
44 {
45 /* Check parameters */
46 assert_parameters(IS_CMP(CMPx));
47
48 if (CMPx == CMP_1)
49 {
50 ANA->REG2 &= ~CMP1_REG2_Msk;
51 ANA->REG3 &= ~CMP1_REG3_Msk;
52 ANA->REG5 &= ~CMP1_REG5_Msk;
53 ANA->REGF &= ~CMP1_REGF_Msk;
54 ANA->CTRL &= ~CMP1_CTRL_Msk;
55 ANA->INTSTS = CMP1_INTSTS_Msk;
56 ANA->INTEN &= ~CMP1_INTEN_Msk;
57 ANA->CMPTHR &= ~CMP1_THR_Msk;
58 ANA->CMPCTL &= ~CMP1_CTL_Msk;
59 ANA->CMPCNT1 = 0;
60 }
61 else
62 {
63 ANA->REG2 &= ~CMP2_REG2_Msk;
64 ANA->REG3 &= ~CMP2_REG3_Msk;
65 ANA->REG5 &= ~CMP2_REG5_Msk;
66 ANA->REGF &= ~CMP2_REGF_Msk;
67 ANA->CTRL &= ~CMP2_CTRL_Msk;
68 ANA->INTSTS = CMP2_INTSTS_Msk;
69 ANA->INTEN &= ~CMP2_INTEN_Msk;
70 ANA->CMPTHR &= ~CMP2_THR_Msk;
71 ANA->CMPCTL &= ~CMP2_CTL_Msk;
72 ANA->CMPCNT2 = 0;
73 }
74 }
75
76 /**
77 * @brief Initializes comparator.
78 * @param CMPx:
79 CMP_1
80 CMP_2
81 InitStruct: Comparator configuration
82 DebSel:
83 CMP_DEB_NONE
84 CMP_DEB_RTCCLK_2
85 CMP_DEB_RTCCLK_3
86 CMP_DEB_RTCCLK_4
87 SignalSourceSel:
88 CMP_SIGNALSRC_PPIN_TO_VREF
89 CMP_SIGNALSRC_PPIN_TO_BGPREF
90 CMP_SIGNALSRC_PBAT_TO_VREF
91 CMP_SIGNALSRC_PBAT_TO_BGPREF
92 CMP_SIGNALSRC_NPIN_TO_VREF
93 CMP_SIGNALSRC_NPIN_TO_BGPREF
94 CMP_SIGNALSRC_PPIN_TO_NPIN
95 CMP_SIGNALSRC_PBAT_TO_NPIN
96 BiasSel:
97 CMP_BIAS_20nA
98 CMP_BIAS_100nA
99 CMP_BIAS_500nA
100 * @retval None
101 */
CMP_Init(uint32_t CMPx,CMP_TypeDef * InitStruct)102 void CMP_Init(uint32_t CMPx, CMP_TypeDef *InitStruct)
103 {
104 uint32_t tmp;
105
106 /* Check parameters */
107 assert_parameters(IS_CMP(CMPx));
108 assert_parameters(IS_CMP_DEB(InitStruct->DebSel));
109 assert_parameters(IS_CMP_SIGNALSRC(InitStruct->SignalSourceSel));
110 assert_parameters(IS_CMP_BIAS(InitStruct->BiasSel));
111
112 /* CMP1 Configure */
113 if (CMPx == CMP_1)
114 {
115 tmp = ANA->CTRL;
116 tmp &= ~ANA_CTRL_CMP1DEB;
117 tmp |= (InitStruct->DebSel << ANA_CTRL_CMP1DEB_Pos);
118 ANA->CTRL = tmp;
119
120 tmp = ANA->REG5;
121 tmp &= ~ANA_REG5_CMP1IT;
122 tmp |= (InitStruct->BiasSel << ANA_REG5_CMP1IT_Pos);
123 ANA->REG5 = tmp;
124
125 ANA->REG2 &= ~(ANA_REG2_CMP1SEL|ANA_REG2_CMP1REFSEL);
126 ANA->REGF &= ~ANA_REGF_BAT1DETEN;
127 switch(InitStruct->SignalSourceSel)
128 {
129 case CMP_SIGNALSRC_PPIN_TO_VREF:
130 break;
131 case CMP_SIGNALSRC_PPIN_TO_BGPREF: ANA->REG2 |= ANA_REG2_CMP1REFSEL;
132 break;
133 case CMP_SIGNALSRC_PBAT_TO_VREF: ANA->REGF |= ANA_REGF_BAT1DETEN;
134 break;
135 case CMP_SIGNALSRC_PBAT_TO_BGPREF: ANA->REG2 |= ANA_REG2_CMP1REFSEL;
136 ANA->REGF |= ANA_REGF_BAT1DETEN;
137 break;
138 case CMP_SIGNALSRC_NPIN_TO_VREF: ANA->REG2 |= ANA_REG2_CMP1SEL_1;
139 break;
140 case CMP_SIGNALSRC_NPIN_TO_BGPREF: ANA->REG2 |= (ANA_REG2_CMP1SEL_1|ANA_REG2_CMP1REFSEL);
141 break;
142 case CMP_SIGNALSRC_PPIN_TO_NPIN: ANA->REG2 |= ANA_REG2_CMP1SEL_3;
143 break;
144 case CMP_SIGNALSRC_PBAT_TO_NPIN: ANA->REG2 |= ANA_REG2_CMP1SEL_3;
145 ANA->REGF |= ANA_REGF_BAT1DETEN;
146 break;
147 default:
148 break;
149 }
150 }
151 /* CMP2 Configure */
152 else
153 {
154 tmp = ANA->CTRL;
155 tmp &= ~ANA_CTRL_CMP2DEB;
156 tmp |= (InitStruct->DebSel << ANA_CTRL_CMP2DEB_Pos);
157 ANA->CTRL = tmp;
158
159 tmp = ANA->REG5;
160 tmp &= ~ANA_REG5_CMP2IT;
161 tmp |= (InitStruct->BiasSel << ANA_REG5_CMP2IT_Pos);
162 ANA->REG5 = tmp;
163
164 ANA->REG2 &= ~(ANA_REG2_CMP2SEL|ANA_REG2_CMP2REFSEL);
165 ANA->REGF &= ~ANA_REGF_BATRTCDETEN;
166 switch(InitStruct->SignalSourceSel)
167 {
168 case CMP_SIGNALSRC_PPIN_TO_VREF:
169 break;
170 case CMP_SIGNALSRC_PPIN_TO_BGPREF: ANA->REG2 |= ANA_REG2_CMP2REFSEL;
171 break;
172 case CMP_SIGNALSRC_PBAT_TO_VREF: ANA->REGF |= ANA_REGF_BATRTCDETEN;
173 break;
174 case CMP_SIGNALSRC_PBAT_TO_BGPREF: ANA->REG2 |= ANA_REG2_CMP2REFSEL;
175 ANA->REGF |= ANA_REGF_BATRTCDETEN;
176 break;
177 case CMP_SIGNALSRC_NPIN_TO_VREF: ANA->REG2 |= ANA_REG2_CMP2SEL_1;
178 break;
179 case CMP_SIGNALSRC_NPIN_TO_BGPREF: ANA->REG2 |= (ANA_REG2_CMP2SEL_1|ANA_REG2_CMP2REFSEL);
180 break;
181 case CMP_SIGNALSRC_PPIN_TO_NPIN: ANA->REG2 |= ANA_REG2_CMP2SEL_3;
182 break;
183 case CMP_SIGNALSRC_PBAT_TO_NPIN: ANA->REG2 |= ANA_REG2_CMP2SEL_3;
184 ANA->REGF |= ANA_REGF_BATRTCDETEN;
185 break;
186 default:
187 break;
188 }
189 }
190 }
191
192 /**
193 * @brief Fills each CMP_TypeDef member with its default value.
194 * @param InitStruct: pointer to an CMP_TypeDef structure which will be initialized.
195 * @retval None
196 */
CMP_StructInit(CMP_TypeDef * InitStruct)197 void CMP_StructInit(CMP_TypeDef *InitStruct)
198 {
199 InitStruct->DebSel = CMP_DEB_NONE;
200 InitStruct->SignalSourceSel = CMP_SIGNALSRC_PPIN_TO_VREF;
201 InitStruct->BiasSel = CMP_BIAS_20nA;
202 }
203
204 /**
205 * @brief Initializes comparator Count.
206 * @param CMPx:
207 CMP_1
208 CMP_2
209 InitStruct: Comparator configuration
210 ModeSel:
211 CMP_MODE_OFF
212 CMP_MODE_RISING
213 CMP_MODE_FALLING
214 CMP_MODE_BOTH
215 CheckPeriod:
216 CMP_PERIOD_30US
217 CMP_PERIOD_7_8125MS
218 CMP_PERIOD_125MS
219 CMP_PERIOD_250MS
220 CMP_PERIOD_500MS
221 CheckNum:
222 CMP_CHKNUM_1~CMP_CHKNUM_16
223 * @retval None
224 */
CMP_CountInit(uint32_t CMPx,CMP_CountTypeDef * InitStruct)225 void CMP_CountInit(uint32_t CMPx, CMP_CountTypeDef *InitStruct)
226 {
227 uint32_t tmp;
228
229 /* Check parameters */
230 assert_parameters(IS_CMP(CMPx));
231 assert_parameters(IS_CMP_MODE(InitStruct->ModeSel));
232 assert_parameters(IS_CMP_CHECKPERIOD(InitStruct->CheckPeriod));
233 assert_parameters(IS_CMP_CHKNUM(InitStruct->CheckNum));
234
235 /* CMP1 Configure */
236 if (CMPx == CMP_1)
237 {
238 /* Configure ModeSel */
239 tmp = ANA->CTRL;
240 tmp &= ~ANA_CTRL_CMP1SEL;
241 tmp |= (InitStruct->ModeSel << ANA_CTRL_CMP1SEL_Pos);
242 ANA->CTRL = tmp;
243
244 /* Configure CheckPeriod/CheckNum */
245 tmp = ANA->CMPCTL;
246 tmp &= ~(ANA_CMPCTL_CMP1_CHK_FRQ|ANA_CMPCTL_CMP1_CHK_NUM);
247 tmp |= ((InitStruct->CheckPeriod << ANA_CMPCTL_CMP1_CHK_FRQ_Pos) | \
248 (InitStruct->CheckNum << ANA_CMPCTL_CMP1_CHK_NUM_Pos));
249 ANA->CMPCTL = tmp;
250 }
251 /* CMP2 Configure */
252 else
253 {
254 /* Configure ModeSel */
255 tmp = ANA->CTRL;
256 tmp &= ~ANA_CTRL_CMP2SEL;
257 tmp |= (InitStruct->ModeSel << ANA_CTRL_CMP2SEL_Pos);
258 ANA->CTRL = tmp;
259
260 /* Configure CheckPeriod/CheckNum */
261 tmp = ANA->CMPCTL;
262 tmp &= ~(ANA_CMPCTL_CMP2_CHK_FRQ|ANA_CMPCTL_CMP2_CHK_NUM);
263 tmp |= ((InitStruct->CheckPeriod << ANA_CMPCTL_CMP2_CHK_FRQ_Pos) | \
264 (InitStruct->CheckNum << ANA_CMPCTL_CMP2_CHK_NUM_Pos));
265 ANA->CMPCTL = tmp;
266 }
267 }
268
269 /**
270 * @brief Fill each CMP_CountTypeDef member with its default value.
271 * @param InitStruct: pointer to an CMP_CountTypeDef structure which will be initialized.
272 * @retval None
273 */
CMP_CountStructInit(CMP_CountTypeDef * InitStruct)274 void CMP_CountStructInit(CMP_CountTypeDef *InitStruct)
275 {
276 InitStruct->ModeSel = CMP_MODE_OFF;
277 InitStruct->CheckPeriod = CMP_PERIOD_30US;
278 InitStruct->CheckNum = CMP_CHKNUM_1;
279 }
280
281 /**
282 * @brief Initializes Comparator interrupt.
283 * @param CMPx:
284 CMP_1
285 CMP_2
286 InitStruct: Comparator configuration
287 INTNumSel:
288 CMP_INTNUM_EVERY
289 CMP_INTNUM_1
290 SubSel:
291 CMP_COUNT_NOSUB
292 CMP_COUNT_SUB
293 THRNum:0~65535
294 * @retval None
295 */
CMP_INTInit(uint32_t CMPx,CMP_INTTypeDef * InitStruct)296 void CMP_INTInit(uint32_t CMPx, CMP_INTTypeDef *InitStruct)
297 {
298 uint32_t tmp;
299
300 /* Check parameters */
301 assert_parameters(IS_CMP(CMPx));
302 assert_parameters(IS_CMP_INTNUM(InitStruct->INTNumSel));
303 assert_parameters(IS_CMP_COUNT(InitStruct->SubSel));
304 assert_parameters(IS_CMP_THRNUM(InitStruct->THRNum));
305
306 /* CMP1 Configure */
307 if (CMPx == CMP_1)
308 {
309 /* Configure INTNumSel/SubSel */
310 tmp = ANA->CMPCTL;
311 tmp &= ~(ANA_CMPCTL_CMP1_THR_EN|ANA_CMPCTL_CMP1_INT_MASK_EN);
312 tmp |= ((InitStruct->SubSel << ANA_CMPCTL_CMP1_THR_EN_Pos) | \
313 (InitStruct->INTNumSel << ANA_CMPCTL_CMP1_INT_MASK_EN_Pos));
314 ANA->CMPCTL = tmp;
315
316 /* Configure THRNum */
317 tmp = ANA->CMPTHR;
318 tmp &= ~ANA_CMPTHR_CMP1_THR;
319 tmp |= (InitStruct->THRNum << ANA_CMPTHR_CMP1_THR_Pos);
320 ANA->CMPTHR = tmp;
321 }
322 /* CMP2 Configure */
323 else
324 {
325 /* Configure INTNumSel/SubSel */
326 tmp = ANA->CMPCTL;
327 tmp &= ~(ANA_CMPCTL_CMP2_THR_EN|ANA_CMPCTL_CMP2_INT_MASK_EN);
328 tmp |= ((InitStruct->SubSel << ANA_CMPCTL_CMP2_THR_EN_Pos) | \
329 (InitStruct->INTNumSel << ANA_CMPCTL_CMP2_INT_MASK_EN_Pos));
330 ANA->CMPCTL = tmp;
331
332 /* Configure THRNum */
333 tmp = ANA->CMPTHR;
334 tmp &= ~ANA_CMPTHR_CMP2_THR;
335 tmp |= (InitStruct->THRNum << ANA_CMPTHR_CMP2_THR_Pos);
336 ANA->CMPTHR = tmp;
337 }
338 }
339
340 /**
341 * @brief Fills each CMP_INTTypeDef member with its default value.
342 * @param InitStruct: pointer to an CMP_INTTypeDef structure which will be initialized.
343 * @retval None
344 */
CMP_INTStructInit(CMP_INTTypeDef * InitStruct)345 void CMP_INTStructInit(CMP_INTTypeDef *InitStruct)
346 {
347 InitStruct->INTNumSel = CMP_INTNUM_EVERY;
348 InitStruct->SubSel = CMP_COUNT_NOSUB;
349 InitStruct->THRNum = 0;
350 }
351
352 /**
353 * @brief Initializes Comparator Output IO.
354 * @param CMPx:
355 CMP_1
356 CMP_2
357 InitStruct: Comparator configuration
358 DebSel:
359 CMP_OUTPUT_DEB
360 CMP_OUTPUT_NODEB
361 OutputSel:
362 ENABLE
363 DISABLE
364 * @retval None
365 */
CMP_OutputInit(uint32_t CMPx,CMP_OutputTypeDef * InitStruct)366 void CMP_OutputInit(uint32_t CMPx, CMP_OutputTypeDef *InitStruct)
367 {
368 /* Check parameters */
369 assert_parameters(IS_CMP(CMPx));
370 assert_parameters(IS_CMP_OUTPUTDEB(InitStruct->DebSel));
371 assert_parameters(IS_FUNCTIONAL_STATE(InitStruct->OutputSel));
372
373 /* CMP1 Configure */
374 if (CMPx == CMP_1)
375 {
376 ANA->CMPCTL &= ~ANA_CMPCTL_CMP1_IO_NODEB;
377 ANA->CMPCTL |= (InitStruct->DebSel << ANA_CMPCTL_CMP1_IO_NODEB_Pos);
378
379 GPIOAF->IOE_SEL &= ~GPIOAF_IOE_SEL_SEL7;
380 GPIOAF->IOE_SEL |= (InitStruct->OutputSel << GPIOAF_IOE_SEL_SEL7_Pos);
381 }
382 /* CMP2 Configure */
383 else
384 {
385 ANA->CMPCTL &= ~ANA_CMPCTL_CMP2_IO_NODEB;
386 ANA->CMPCTL |= (InitStruct->DebSel << ANA_CMPCTL_CMP2_IO_NODEB_Pos);
387
388 GPIOA->SEL &= ~GPIOA_SEL_SEL6;
389 GPIOA->SEL |= (InitStruct->OutputSel << GPIOA_SEL_SEL6_Pos);
390 }
391 }
392
393 /**
394 * @brief Fills each CMP_OutputTypeDef member with its default value.
395 * @param InitStruct: pointer to an CMP_OutputTypeDef structure which will be initialized.
396 * @retval None
397 */
CMP_OutputStructInit(CMP_OutputTypeDef * InitStruct)398 void CMP_OutputStructInit(CMP_OutputTypeDef *InitStruct)
399 {
400 InitStruct->DebSel = CMP_OUTPUT_DEB;
401 InitStruct->OutputSel = DISABLE;
402 }
403
404 /**
405 * @brief Gets comparator count value.
406 * @param CMPx:
407 CMP_1
408 CMP_2
409 * @retval Comparator count value.
410 */
CMP_GetCNTValue(uint32_t CMPx)411 uint32_t CMP_GetCNTValue(uint32_t CMPx)
412 {
413 /* Check parameters */
414 assert_parameters(IS_CMP(CMPx));
415
416 if (CMPx == CMP_1)
417 {
418 return ANA->CMPCNT1;
419 }
420 else
421 {
422 return ANA->CMPCNT2;
423 }
424 }
425
426 /**
427 * @brief Clears comparator counter value.
428 * @param CMPx:
429 CMP_1
430 CMP_2
431 * @retval None
432 */
CMP_ClearCNTValue(uint32_t CMPx)433 void CMP_ClearCNTValue(uint32_t CMPx)
434 {
435 /* Check parameters */
436 assert_parameters(IS_CMP(CMPx));
437
438 if (CMPx == CMP_1)
439 {
440 ANA->CMPCNT1 = 0;
441 }
442 else
443 {
444 ANA->CMPCNT2 = 0;
445 }
446 }
447
448 /**
449 * @brief Enables or disables Comparator.
450 * @param CMPx:
451 CMP_1
452 CMP_2
453 NewState:
454 ENABLE
455 DISABLE
456 * @retval None
457 */
CMP_Cmd(uint32_t CMPx,uint32_t NewState)458 void CMP_Cmd(uint32_t CMPx, uint32_t NewState)
459 {
460 /* Check parameters */
461 assert_parameters(IS_CMP(CMPx));
462 assert_parameters(IS_FUNCTIONAL_STATE(NewState));
463
464 if (CMPx == CMP_1)
465 {
466 ANA->REG3 &= ~ANA_REG3_CMP1PDN;
467 ANA->REG3 |= (NewState << ANA_REG3_CMP1PDN_Pos);
468 }
469 else
470 {
471 ANA->REG3 &= ~ANA_REG3_CMP2PDN;
472 ANA->REG3 |= (NewState << ANA_REG3_CMP2PDN_Pos);
473 }
474 }
475
476 /**
477 * @brief Gets comparator output level
478 * @param None
479 * @retval Output of comparator
480 */
CMP_GetOutputValue(uint32_t CMPx)481 uint8_t CMP_GetOutputValue(uint32_t CMPx)
482 {
483 /* Check parameters */
484 assert_parameters(IS_CMP(CMPx));
485
486 if (CMPx == CMP_1)
487 {
488 return ((ANA->CMPOUT & ANA_CMPOUT_CMP1) >> ANA_CMPOUT_CMP1_Pos);
489 }
490 else
491 {
492 return ((ANA->CMPOUT & ANA_CMPOUT_CMP2) >> ANA_CMPOUT_CMP2_Pos);
493 }
494 }
495
496 /**
497 * @brief Enables or disables Comparator interrupt.
498 * @param CMPx:
499 * CMP_1
500 * CMP_2
501 * NewState:
502 * ENABLE
503 * DISABLE
504 * @retval None
505 */
CMP_INTConfig(uint32_t CMPx,uint32_t NewState)506 void CMP_INTConfig(uint32_t CMPx, uint32_t NewState)
507 {
508 /* Check parameters */
509 assert_parameters(IS_CMP(CMPx));
510
511 if (CMPx == CMP_1)
512 {
513 ANA->INTEN &= ~ANA_INTEN_INTEN2;
514 ANA->INTEN |= (NewState<<ANA_INTEN_INTEN2_Pos);
515 }
516 else
517 {
518 ANA->INTEN &= ~ANA_INTEN_INTEN3;
519 ANA->INTEN |= (NewState<<ANA_INTEN_INTEN3_Pos);
520 }
521 }
522
523 /**
524 * @brief Gets comparator interrupt flag status.
525 * @param CMPx:
526 * CMP_1
527 * CMP_2
528 * @retval flag status
529 * 0: status not set
530 * 1: status set
531 */
CMP_GetINTStatus(uint32_t CMPx)532 uint8_t CMP_GetINTStatus(uint32_t CMPx)
533 {
534 /* Check parameters */
535 assert_parameters(IS_CMP(CMPx));
536
537 if (CMPx == CMP_1)
538 {
539 return ((ANA->INTSTS & ANA_INTSTS_INTSTS2) >> ANA_INTSTS_INTSTS2_Pos);
540 }
541 else
542 {
543 return ((ANA->INTSTS & ANA_INTSTS_INTSTS3) >> ANA_INTSTS_INTSTS3_Pos);
544 }
545 }
546
547 /**
548 * @brief Clears comparator interrupt flag.
549 * @param CMPx:
550 * CMP_1
551 * CMP_2
552 * @retval None
553 */
CMP_ClearINTStatus(uint32_t CMPx)554 void CMP_ClearINTStatus(uint32_t CMPx)
555 {
556 /* Check parameters */
557 assert_parameters(IS_CMP(CMPx));
558
559 if (CMPx == CMP_1)
560 {
561 ANA->INTSTS = ANA_INTSTS_INTSTS2;
562 }
563 else
564 {
565 ANA->INTSTS = ANA_INTSTS_INTSTS3;
566 }
567 }
568
569 /*********************************** END OF FILE ******************************/
570