1 /**
2 ******************************************************************************
3 * @file lib_adc.c
4 * @author Application Team
5 * @version V4.6.0
6 * @date 2019-06-18
7 * @brief ADC library.
8 ******************************************************************************
9 * @attention
10 *
11 ******************************************************************************
12 */
13 #include "lib_adc.h"
14
15 extern __IO uint32_t ana_reg3_tmp;
16 #define ANA_REG1_RSTValue (0U)
17 #define ANA_ADCCTRL_RSTValue (0U)
18
19 /**
20 * @brief Initializes ADC peripheral registers to their default reset values.
21 * @note 1. Disable ADC
22 2. Disable ADC overall bias current trim
23 3. Disable resistor/cap division.
24 4. Disable ADC auto/manual done interrupt
25 5. ANA_ADCCTRL(register) write default value.
26 * @param None
27 * @retval None
28 */
ADC_DeInit(void)29 void ADC_DeInit(void)
30 {
31 /* Power down ADC */
32 ana_reg3_tmp &= ~ANA_REG3_ADCPDN;
33 ANA->REG3 = ana_reg3_tmp;
34 /* Disable resistor/cap division. */
35 ANA->REG1 = ANA_REG1_RSTValue;
36 /* Disable interrupt, Clear interrupt flag */
37 ANA->INTEN &= ~(ANA_INTEN_INTEN0 | ANA_INTEN_INTEN1);
38 ANA->INTSTS = (ANA_INTSTS_INTSTS0 | ANA_INTSTS_INTSTS1);
39 while (ANA->ADCCTRL & ANA_ADCCTRL_MTRIG);
40 ANA->ADCCTRL = ANA_ADCCTRL_RSTValue;
41 }
42
43 /**
44 * @brief Fills each ADC_InitStruct member with its default value.
45 * @param ADC_InitStruct: pointer to an ADCInitType structure which will be initialized.
46 * @retval None
47 */
ADC_StructInit(ADCInitType * ADC_InitStruct)48 void ADC_StructInit(ADCInitType* ADC_InitStruct)
49 {
50 /*--------------- Reset ADC init structure parameters values ---------------*/
51 /* Initialize the ClockSource member */
52 ADC_InitStruct->ClockSource = ADC_CLKSRC_RCH;
53 /* Initialize the Channel member */
54 ADC_InitStruct->Channel = ADC_CHANNEL0;
55 /* Initialize the ClockDivider member */
56 ADC_InitStruct->ClockDivider = ADC_CLKDIV_1;
57 /* Initialize the ConvMode member */
58 ADC_InitStruct->ConvMode = ADC_CONVMODE_SINGLECHANNEL;
59 /* Initialize the TrigMode member */
60 ADC_InitStruct->TrigMode = ADC_TRIGMODE_MANUAL;
61 }
62
63 /**
64 * @brief ADC initialization.
65 * @param ADC_InitStruct:
66 TrigMode:
67 ADC_TRIGMODE_AUTO
68 ADC_TRIGMODE_MANUAL
69 ConvMode:
70 ADC_CONVMODE_SINGLECHANNEL
71 ADC_CONVMODE_MULTICHANNEL
72 ClockSource:
73 ADC_CLKSRC_RCH
74 ADC_CLKSRC_PLLL
75 ClockDivider:
76 ADC_CLKDIV_1
77 ADC_CLKDIV_2
78 ADC_CLKDIV_3
79 ADC_CLKDIV_4
80 ADC_CLKDIV_5
81 ADC_CLKDIV_6
82 ADC_CLKDIV_7
83 ADC_CLKDIV_8
84 ADC_CLKDIV_9
85 ADC_CLKDIV_10
86 ADC_CLKDIV_11
87 ADC_CLKDIV_12
88 ADC_CLKDIV_13
89 ADC_CLKDIV_14
90 ADC_CLKDIV_15
91 ADC_CLKDIV_16
92 Channel:(be valid when ConvMode is ADC_CONVMODE_SINGLECHANNEL)
93 ADC_CHANNEL0
94 ADC_CHANNEL1
95 ADC_CHANNEL2
96 ADC_CHANNEL3
97 ADC_CHANNEL4
98 ADC_CHANNEL5
99 ADC_CHANNEL6
100 ADC_CHANNEL7
101 ADC_CHANNEL8
102 ADC_CHANNEL9
103 ADC_CHANNEL10
104 ADC_CHANNEL11
105
106 * @retval None
107 */
ADC_Init(ADCInitType * ADC_InitStruct)108 void ADC_Init(ADCInitType* ADC_InitStruct)
109 {
110 uint32_t tmp = 0;
111
112 /* Check parameters */
113 assert_parameters(IS_ADC_TRIGMODE(ADC_InitStruct->TrigMode));
114 assert_parameters(IS_ADC_CONVMODE(ADC_InitStruct->ConvMode));
115 assert_parameters(IS_ADC_CLKDIV(ADC_InitStruct->ClockDivider));
116 assert_parameters(IS_ADC_CLKSRC(ADC_InitStruct->ClockSource));
117
118 tmp = ANA->ADCCTRL;
119 tmp &= ~(ANA_ADCCTRL_AMODE \
120 |ANA_ADCCTRL_MMODE \
121 |ANA_ADCCTRL_CLKSEL \
122 |ANA_ADCCTRL_CLKDIV \
123 |ANA_ADCCTRL_AEN \
124 |ANA_ADCCTRL_MCH \
125 |ANA_ADCCTRL_ACH);
126 tmp |= (ADC_InitStruct->ClockDivider | ADC_InitStruct->ClockSource);
127
128 if(ADC_InitStruct->TrigMode == ADC_TRIGMODE_AUTO) //Auto mode
129 {
130 if(ADC_InitStruct->ConvMode == ADC_CONVMODE_SINGLECHANNEL) //signal channel
131 {
132 assert_parameters(IS_ADC_CHANNEL(ADC_InitStruct->Channel));
133 tmp &= (~ANA_ADCCTRL_ACH);
134 tmp |= (ADC_InitStruct->Channel << ANA_ADCCTRL_ACH_Pos);
135 }
136 else //multi channels
137 {
138 tmp |= ANA_ADCCTRL_AMODE;
139 }
140 }
141 else // Manual mode
142 {
143 if(ADC_InitStruct->ConvMode == ADC_CONVMODE_SINGLECHANNEL) //signal channel
144 {
145 assert_parameters(IS_ADC_CHANNEL(ADC_InitStruct->Channel));
146 tmp &= (~ANA_ADCCTRL_MCH);
147 tmp |= (ADC_InitStruct->Channel << ANA_ADCCTRL_MCH_Pos);
148 }
149 else //multi channels
150 {
151 tmp |= ANA_ADCCTRL_MMODE;
152 }
153 }
154
155 while (ANA->ADCCTRL & ANA_ADCCTRL_MTRIG);
156 ANA->ADCCTRL = tmp;
157 }
158
159 /**
160 * @brief Calculate ADC voltage value(uint:V) via ADC original data.
161 * @param [in]Mode:
162 * ADC_3V_EXTERNAL_NODIV
163 * ADC_3V_EXTERNAL_RESDIV
164 * ADC_3V_EXTERNAL_CAPDIV
165 * ADC_3V_VDD_RESDIV
166 * ADC_3V_VDD_CAPDIV
167 * ADC_3V_BATRTC_RESDIV
168 * ADC_3V_BATRTC_CAPDIV
169 * ADC_5V_EXTERNAL_NODIV
170 * ADC_5V_EXTERNAL_RESDIV
171 * ADC_5V_EXTERNAL_CAPDIV
172 * ADC_5V_VDD_RESDIV
173 * ADC_5V_VDD_CAPDIV
174 * ADC_5V_BATRTC_RESDIV
175 * ADC_5V_BATRTC_CAPDIV
176 * @param [in]adc_data: The ADC original data
177 * @param [out]Voltage: The pointer of voltage value calculated by this function
178 * @retval 1 NVR checksum error.
179 0 Function successed.
180 */
ADC_CalculateVoltage(uint32_t Mode,int16_t adc_data,float * Voltage)181 uint32_t ADC_CalculateVoltage(uint32_t Mode, int16_t adc_data, float *Voltage)
182 {
183 NVR_ADCVOLPARA parameter;
184 NVR_BATMEARES BAT_OffsetInfo;
185
186 /* Check parameters */
187 assert_parameters(IS_ADCVOL_MODE(Mode));
188
189 if (NVR_GetADCVoltageParameter(Mode, ¶meter))
190 {
191 if ((Mode&0xFUL) > 2UL) /* VDD or BATRTC channel */
192 {
193 if (NVR_GetBATOffset(&BAT_OffsetInfo))
194 {
195 return 1;
196 }
197 else
198 {
199 if (((Mode&0xFUL) == 3UL) || ((Mode&0xFUL) == 5UL)) /* VDD/BATRTC, Resistive */
200 {
201 *Voltage = (float)(0.00015392*(float)adc_data + 0.06667986) + BAT_OffsetInfo.BATRESResult;
202 }
203 else /* VDD/BATRTC, Capacitive */
204 {
205 *Voltage = (float)(0.00014107*(float)adc_data - 0.00699515) + BAT_OffsetInfo.BATCAPResult;
206 }
207 }
208 }
209 else /* External channel */
210 {
211 if (Mode & 0x100UL) /* Power supply: 5V */
212 {
213 if ((Mode&0xFUL) == 0UL) /* No divider */
214 {
215 *Voltage = (float)(0.00003678*(float)adc_data + 0.00235783);
216 }
217 else if ((Mode&0xFUL) == 1UL) /* Resistive */
218 {
219 *Voltage = (float)(0.00016129*(float)adc_data + 0.00673599);
220 }
221 else /* Capacitive */
222 {
223 *Voltage = (float)(0.00014076*(float)adc_data - 0.00753319);
224 }
225 }
226 else /* Power supply: 3.3V */
227 {
228 if ((Mode&0xFUL) == 0UL) /* No divider */
229 {
230 *Voltage = (float)(0.00003680*(float)adc_data + 0.00205011);
231 }
232 else if ((Mode&0xFUL) == 1UL) /* Resistive */
233 {
234 *Voltage = (float)(0.00016425*(float)adc_data + 0.03739179);
235 }
236 else /* Capacitive */
237 {
238 *Voltage = (float)(0.00014051*(float)adc_data - 0.00023322);
239 }
240 }
241 }
242 }
243 else
244 {
245 *Voltage = (float)(parameter.aParameter*(float)adc_data + parameter.bParameter);
246 }
247
248 return 0;
249 }
250
251 /**
252 * @brief Get VDD Voltage(takes 244us).
253 * @note This function costs about 170us when SystemClock is 26M.
254 * ADC data refresh time is 117us.
255 * @note This function will release ADC resource(write ADC registers with their
256 * default reset values).
257 * @note ADC configurarion:
258 * - Trigger mode: manual mode
259 * - Conversion mode: single channel mode(VDD channel 1)
260 * - ADC clock: 3.2M
261 * - Skip samples: Skip 2 samples
262 * - Down sampling rate: 1/64
263 * @param [in]Division
264 ADC_BAT_CAPDIV (Cap division 1/4)
265 ADC_BAT_RESDIV (Resistance division 1/4)
266 [out]CalResults.VDDVoltage The value of VDD Voltage
267 [out]CalResults.BATRTCVoltage is ignored
268 [out]CalResults.Temperature is ignored
269 * @retval 1 NVR BAT-offset information checksum error.
270 0 Function successed.
271 */
ADC_GetVDDVoltage_Fast(uint32_t Division,ADC_CalResType * CalResults)272 uint32_t ADC_GetVDDVoltage_Fast(uint32_t Division, ADC_CalResType *CalResults)
273 {
274 float Vbatcap;
275 float Vbatres;
276 NVR_BATMEARES BAT_OffsetInfo;
277 int16_t data;
278
279 assert_parameters(IS_ADC_BATDIV(Division));
280
281 /* Get NVR BAT offset information */
282 if (NVR_GetBATOffset(&BAT_OffsetInfo))
283 {
284 return (1);
285 }
286 else
287 {
288 Vbatcap = BAT_OffsetInfo.BATCAPResult;
289 Vbatres = BAT_OffsetInfo.BATRESResult;
290 }
291
292 /* ADC initialization */
293 ADC_DeInit();
294 while (ANA->ADCCTRL & ANA_ADCCTRL_MTRIG);
295 ANA->ADCCTRL = 0x06C00101;
296
297 /* Enable division */
298 ANA->REG1 |= Division;
299 /* Enable ADC */
300 ana_reg3_tmp |= ANA_REG3_ADCPDN;
301 ANA->REG3 = ana_reg3_tmp;
302
303 /* Start a manual ADC conversion */
304 ADC_StartManual();
305 /* Waiting last operation done */
306 ADC_WaitForManual();
307
308 data = ANA->ADCDATA1;
309
310 /* Calculate the voltage of VDD */
311 if (Division & ADC_BAT_CAPDIV)
312 {
313 CalResults->VDDVoltage = (0.00014107*(float)data - 0.00699515) + Vbatcap;
314 }
315 else
316 {
317 CalResults->VDDVoltage = (0.00015392*(float)data + 0.06667986) + Vbatres;
318 }
319
320 /* ADC resource release */
321 ADC_DeInit();
322
323 return (0);
324 }
325
326 /**
327 * @brief Get VDD Voltage(takes 3.3ms).
328 * @note This function costs about 3.3ms when SystemClock is 26M.
329 * ADC data refresh time is about 3.2ms.
330 * @note This function will release ADC resource(write ADC registers with their
331 * default reset values).
332 * @note ADC configurarion:
333 * - Trigger mode: manual mode
334 * - Conversion mode: single channel mode(VDD channel 1)
335 * - ADC clock: 1.6M
336 * - Skip samples: Skip first 4 samples
337 * - Down sampling rate: 1/512
338 * @param [in]Division
339 ADC_BAT_CAPDIV (Cap division 1/4)
340 ADC_BAT_RESDIV (Resistance division 1/4)
341 [out]CalResults.VDDVoltage The value of VDD Voltage
342 [out]CalResults.BATRTCVoltage is ignored
343 [out]CalResults.Temperature is ignored
344 * @retval 1 NVR BAT-offset information checksum error.
345 0 Function successed.
346 */
ADC_GetVDDVoltage_Normal(uint32_t Division,ADC_CalResType * CalResults)347 uint32_t ADC_GetVDDVoltage_Normal(uint32_t Division, ADC_CalResType *CalResults)
348 {
349 float Vbatcap;
350 float Vbatres;
351 NVR_BATMEARES BAT_OffsetInfo;
352 ADCInitType ADC_InitStruct;
353 int16_t data;
354
355 assert_parameters(IS_ADC_BATDIV(Division));
356
357 /* Get NVR BAT offset information */
358 if (NVR_GetBATOffset(&BAT_OffsetInfo))
359 {
360 return (1);
361 }
362 else
363 {
364 Vbatcap = BAT_OffsetInfo.BATCAPResult;
365 Vbatres = BAT_OffsetInfo.BATRESResult;
366 }
367
368 /* ADC initialization */
369 ADC_DeInit();
370 ADC_InitStruct.TrigMode = ADC_TRIGMODE_MANUAL;
371 ADC_InitStruct.ConvMode = ADC_CONVMODE_SINGLECHANNEL;
372 ADC_InitStruct.Channel = ADC_CHANNEL1;
373 ADC_InitStruct.ClockDivider = ADC_CLKDIV_4;
374 ADC_InitStruct.ClockSource = ADC_CLKSRC_RCH;
375 ADC_Init(&ADC_InitStruct);
376
377 /* Enable division */
378 ANA->REG1 |= Division;
379 /* Enable ADC */
380 ana_reg3_tmp |= ANA_REG3_ADCPDN;
381 ANA->REG3 = ana_reg3_tmp;
382
383 /* Start a manual ADC conversion */
384 ADC_StartManual();
385 /* Waiting last operation done */
386 ADC_WaitForManual();
387
388
389 data = ANA->ADCDATA1;
390
391 /* Calculate the voltage of VDD */
392 if (Division & ADC_BAT_CAPDIV)
393 {
394 CalResults->VDDVoltage = (0.00014107*(float)data - 0.00699515) + Vbatcap;
395 }
396 else
397 {
398 CalResults->VDDVoltage = (0.00015392*(float)data + 0.06667986) + Vbatres;
399 }
400
401 /* ADC resource release */
402 ADC_DeInit();
403
404 return (0);
405 }
406
407 /**
408 * @brief Get BATRTC Voltage(takes 244us).
409 * @note This function takes about 244us when SystemClock is 26M.
410 * ADC data refresh time is 117us.
411 * @note This function will release ADC resource(write ADC registers with their
412 * default reset values).
413 * @note ADC configurarion:
414 * - Trigger mode: manual mode
415 * - Conversion mode: single channel mode(BATRTC channel 2)
416 * - ADC clock: 3.2M
417 * - Skip samples: Skip 2 samples
418 * - Down sampling rate: 1/64
419 * @param [in]Division
420 ADC_BAT_CAPDIV (Cap division 1/4)
421 ADC_BAT_RESDIV (Resistance division 1/4)
422 [out]CalResults.VDDVoltage is ignored
423 [out]CalResults.BATRTCVoltage The value of BATRTC Voltage
424 [out]CalResults.Temperature is ignored
425 * @retval 1 NVR BAT-offset or BGP-gain information checksum error.
426 0 Function successed.
427 */
ADC_GetBATRTCVoltage_Fast(uint32_t Division,ADC_CalResType * CalResults)428 uint32_t ADC_GetBATRTCVoltage_Fast(uint32_t Division, ADC_CalResType *CalResults)
429 {
430 float Vbatcap;
431 float Vbatres;
432
433 NVR_BATMEARES BAT_OffsetInfo;
434 int16_t data;
435
436 assert_parameters(IS_ADC_BATDIV(Division));
437
438 /* Get NVR BAT offset information */
439 if (NVR_GetBATOffset(&BAT_OffsetInfo))
440 {
441 return (1);
442 }
443 else
444 {
445 Vbatcap = BAT_OffsetInfo.BATCAPResult;
446 Vbatres = BAT_OffsetInfo.BATRESResult;
447 }
448
449 /* ADC initialization */
450 ADC_DeInit();
451 while (ANA->ADCCTRL & ANA_ADCCTRL_MTRIG);
452 ANA->ADCCTRL = 0x06C00102;
453 /* Enable division */
454 ANA->REG1 |= Division;
455 /* Enable ADC */
456 ana_reg3_tmp |= ANA_REG3_ADCPDN;
457 ANA->REG3 = ana_reg3_tmp;
458
459 /* Start a manual ADC conversion */
460 ADC_StartManual();
461 /* Waiting last operation done */
462 ADC_WaitForManual();
463
464 data = ANA->ADCDATA2;
465
466 /* Calculate the voltage of BAT1 */
467 if (Division & ADC_BAT_CAPDIV)
468 {
469 CalResults->BATRTCVoltage = (0.00014107*(float)data - 0.00699515) + Vbatcap;
470 }
471 else
472 {
473 CalResults->BATRTCVoltage = (0.00015392*(float)data + 0.06667986) + Vbatres;
474 }
475 /* ADC resource release */
476 ADC_DeInit();
477
478 return (0);
479 }
480
481 /**
482 * @brief Get BATRTC Voltage(takes 3.3ms).
483 * @note This function takes about 3.3ms when SystemClock is 26M.
484 * ADC data refresh time is about 3.2ms.
485 * @note This function will release ADC resource(write ADC registers with their
486 * default reset values).
487 * @note ADC configurarion:
488 * - Trigger mode: manual mode
489 * - Conversion mode: single channel mode(BATRTC channel 2)
490 * - ADC clock: 1.6M
491 * - Skip samples: Skip first 4 samples
492 * - Down sampling rate: 1/512
493 * @param [in]Division
494 ADC_BAT_CAPDIV (Capacitance division 1/4)
495 ADC_BAT_RESDIV (Resistance division 1/4)
496 [out]CalResults.VDDVoltage is ignored
497 [out]CalResults.BATRTCVoltage The value of BATRTC Voltage
498 [out]CalResults.Temperature is ignored
499 * @retval 1 NVR BAT-offset information checksum error.
500 0 Function successed.
501 */
ADC_GetBATRTCVoltage_Normal(uint32_t Division,ADC_CalResType * CalResults)502 uint32_t ADC_GetBATRTCVoltage_Normal(uint32_t Division, ADC_CalResType *CalResults)
503 {
504 float Vbatcap;
505 float Vbatres;
506 NVR_BATMEARES BAT_OffsetInfo;
507 ADCInitType ADC_InitStruct;
508 int16_t data;
509
510 assert_parameters(IS_ADC_BATDIV(Division));
511
512 /* Get NVR BAT offset information */
513 if (NVR_GetBATOffset(&BAT_OffsetInfo))
514 {
515 return (1);
516 }
517 else
518 {
519 Vbatcap = BAT_OffsetInfo.BATCAPResult;
520 Vbatres = BAT_OffsetInfo.BATRESResult;
521 }
522
523 /* ADC initialization */
524 ADC_DeInit();
525 ADC_InitStruct.TrigMode = ADC_TRIGMODE_MANUAL;
526 ADC_InitStruct.ConvMode = ADC_CONVMODE_SINGLECHANNEL;
527 ADC_InitStruct.Channel = ADC_CHANNEL2;
528 ADC_InitStruct.ClockDivider = ADC_CLKDIV_4;
529 ADC_InitStruct.ClockSource = ADC_CLKSRC_RCH;
530 ADC_Init(&ADC_InitStruct);
531
532 /* Enable division */
533 ANA->REG1 |= Division;
534 /* Enable ADC */
535 ana_reg3_tmp |= ANA_REG3_ADCPDN;
536 ANA->REG3 = ana_reg3_tmp;
537
538 /* Start a manual ADC conversion */
539 ADC_StartManual();
540 /* Waiting last operation done */
541 ADC_WaitForManual();
542
543 data = ANA->ADCDATA2;
544
545 /* Calculate the voltage of BAT1 */
546 if (Division & ADC_BAT_CAPDIV)
547 {
548 CalResults->BATRTCVoltage = (0.00014107*(float)data - 0.00699515) + Vbatcap;
549 }
550 else
551 {
552 CalResults->BATRTCVoltage = (0.00015392*(float)data + 0.06667986) + Vbatres;
553 }
554
555 /* ADC resource release */
556 ADC_DeInit();
557
558 return (0);
559 }
560
561 /**
562 * @brief Get Temperature(takes 6.5ms).
563 * @note This function costs about 6.5ms when SystemClock is 26M.
564 * ADC data refresh time is about 3.2ms.
565 * @note This function will release ADC resource(write ADC registers with their
566 * default reset values).
567 * @note ADC configurarion:
568 * - Trigger mode: manual mode
569 * - Conversion mode: single channel mode(Temperature channel 10)
570 * - ADC clock: 1.6M
571 * - Skip samples: Skip first 4 samples
572 * - Down sampling rate: 1/512
573 * @param [out]CalResults.VDDVoltage is ignored
574 [out]CalResults.BATRTCVoltage is ignored
575 [out]CalResults.Temperature The value of Temperature
576 * @retval 1 Temperature delta information checksum error.
577 0 Function successed.
578 */
ADC_GetTemperature(ADC_CalResType * CalResults)579 uint32_t ADC_GetTemperature(ADC_CalResType *CalResults)
580 {
581 int32_t P2;
582 int16_t P1, P0;
583 int16_t adc_data;
584 uint32_t retval;
585 NVR_RTCINFO RTC_DataStruct;
586 ADCInitType ADC_InitStruct;
587
588 /* Get RTC Px parameters */
589 retval = NVR_GetInfo_LoadRTCData(&RTC_DataStruct);
590 if (retval & 0x1U)
591 {
592 return (1);
593 }
594 else
595 {
596 P0 = RTC_DataStruct.RTCTempP0;
597 P1 = RTC_DataStruct.RTCTempP1;
598 P2 = RTC_DataStruct.RTCTempP2;
599 }
600
601 /* ADC initialization */
602 ADC_DeInit();
603 ADC_InitStruct.TrigMode = ADC_TRIGMODE_MANUAL;
604 ADC_InitStruct.ConvMode = ADC_CONVMODE_SINGLECHANNEL;
605 ADC_InitStruct.Channel = ADC_CHANNEL10;
606 ADC_InitStruct.ClockDivider = ADC_CLKDIV_4;
607 ADC_InitStruct.ClockSource = ADC_CLKSRC_RCH;
608 ADC_Init(&ADC_InitStruct);
609
610 /* Configure 1/512 down-sampling rate */
611 ADC_CICDownSamRateConfig(ADC_SDRSEL_DIV512);
612 /* Enable ADC */
613 ADC_Cmd(ENABLE);
614
615 /*---------- Get ADC data1 ----------*/
616 /* Starts a manual ADC conversion */
617 ADC_StartManual();
618 /* Waiting Manual ADC conversion done */
619 ADC_WaitForManual();
620 adc_data = (int16_t)ADC_GetADCConversionValue(ADC_CHANNEL10);
621
622 /* ADC resource release */
623 ADC_DeInit();
624
625 /* Calculate temperature */
626 CalResults->Temperature = (float)((((P0 * ((adc_data*adc_data)>>16)) + P1*adc_data + P2) >> 8) / 256.0);
627
628 return (0);
629 }
630
631 /**
632 * @brief ADC power control.
633 * @note When DISABLE is selected, the automatic triggering of the ADC must be turned off by calling
634 * ADC_TrigSourceConfig(ADC_TRIGSOURCE_OFF) before using this function.
635 * @param NewState
636 ENABLE
637 DISABLE
638 * @retval 0: Function succeeded
639 * 1: Function failded, the automatic triggering be enabled when DISABLE selected
640 */
ADC_Cmd(uint32_t NewState)641 uint32_t ADC_Cmd(uint32_t NewState)
642 {
643 /* Check parameters */
644 assert_parameters(IS_FUNCTIONAL_STATE(NewState));
645
646 if (NewState == DISABLE)
647 {
648 if (ANA->ADCCTRL & ANA_ADCCTRL_AEN)
649 {
650 return 1;
651 }
652 else
653 {
654 ana_reg3_tmp &= ~ANA_REG3_ADCPDN;
655 }
656 }
657 else
658 {
659 ana_reg3_tmp |= ANA_REG3_ADCPDN;
660 }
661
662 ANA->REG3 = ana_reg3_tmp;
663
664 return 0;
665 }
666
667 /**
668 * @brief Manual ADC trigger
669 * @param None
670 * @retval None
671 */
ADC_StartManual(void)672 void ADC_StartManual(void)
673 {
674 while (ANA->ADCCTRL & ANA_ADCCTRL_MTRIG);
675 ANA->ADCCTRL |= ANA_ADCCTRL_MTRIG;
676 }
677
678 /**
679 * @brief Wait for the last Manual ADC conversion done.
680 * @param None
681 * @retval None
682 */
ADC_WaitForManual(void)683 void ADC_WaitForManual(void)
684 {
685 while (ANA->ADCCTRL & ANA_ADCCTRL_MTRIG)
686 {
687 }
688 }
689
690 /**
691 * @brief ADC auto mode trigger source configure.
692 * @param TrigSource:
693 ADC_TRIGSOURCE_OFF
694 ADC_TRIGSOURCE_TIM0
695 ADC_TRIGSOURCE_TIM1
696 ADC_TRIGSOURCE_TIM2
697 ADC_TRIGSOURCE_TIM3
698 * @retval None
699 */
ADC_TrigSourceConfig(uint32_t TrigSource)700 void ADC_TrigSourceConfig(uint32_t TrigSource)
701 {
702 uint32_t tmp;
703
704 /* Check parameters */
705 assert_parameters(IS_ADC_TRIGSOURCE(TrigSource));
706
707 tmp = ANA->ADCCTRL;
708 tmp &= ~ANA_ADCCTRL_AEN;
709 tmp |= TrigSource;
710 while (ANA->ADCCTRL & ANA_ADCCTRL_MTRIG);
711 ANA->ADCCTRL = tmp;
712 }
713
714 /**
715 * @brief Resistance division enable control.
716 * @param NewState
717 ENABLE (x1/4)
718 DISABLE (x1)
719 * @retval None
720 */
ADC_RESDivisionCmd(uint32_t NewState)721 void ADC_RESDivisionCmd(uint32_t NewState)
722 {
723 uint32_t tmp;
724
725 /* Check parameters */
726 assert_parameters(IS_FUNCTIONAL_STATE(NewState));
727
728 tmp = ANA->REG1;
729 if (NewState == ENABLE)
730 {
731 tmp &= ~ANA_REG1_GDE4;
732 tmp |=ANA_REG1_RESDIV;
733 }
734 else
735 {
736 tmp &= ~ANA_REG1_RESDIV;
737 }
738 ANA->REG1 = tmp;
739 }
740
741 /**
742 * @brief Capacitance division enable control.
743 * @param NewState
744 ENABLE (x1/4)
745 DISABLE (x1)
746 * @retval None
747 */
ADC_CAPDivisionCmd(uint32_t NewState)748 void ADC_CAPDivisionCmd(uint32_t NewState)
749 {
750 uint32_t tmp;
751
752 /* Check parameters */
753 assert_parameters(IS_FUNCTIONAL_STATE(NewState));
754
755 tmp = ANA->REG1;
756 if (NewState == ENABLE)
757 {
758 tmp &= ~ANA_REG1_RESDIV;
759 tmp |=ANA_REG1_GDE4;
760 }
761 else
762 {
763 tmp &= ~ANA_REG1_GDE4;
764 }
765 ANA->REG1 = tmp;
766 }
767
768 /**
769 * @brief CIC filter always on control.
770 * @param NewState
771 ENABLE (CIC filter always on)
772 DISABLE (CIC filter will be disabled when no ADC sample process is ongoing.)
773 * @retval None
774 */
ADC_CICAlwaysOnCmd(uint32_t NewState)775 void ADC_CICAlwaysOnCmd(uint32_t NewState)
776 {
777 /* Check parameters */
778 assert_parameters(IS_FUNCTIONAL_STATE(NewState));
779
780 while (ANA->ADCCTRL & ANA_ADCCTRL_MTRIG);
781
782 if (NewState == ENABLE)
783 ANA->ADCCTRL |= ANA_ADCCTRL_CICAON;
784 else
785 ANA->ADCCTRL &= ~ANA_ADCCTRL_CICAON;
786 }
787
788 /**
789 * @brief CIC filter input inversion control.
790 * @param NewState
791 ENABLE
792 DISABLE
793 * @retval None
794 */
ADC_CICINVCmd(uint32_t NewState)795 void ADC_CICINVCmd(uint32_t NewState)
796 {
797 /* Check parameters */
798 assert_parameters(IS_FUNCTIONAL_STATE(NewState));
799
800 while (ANA->ADCCTRL & ANA_ADCCTRL_MTRIG);
801
802 if (NewState == ENABLE)
803 ANA->ADCCTRL |= ANA_ADCCTRL_CICINV;
804 else
805 ANA->ADCCTRL &= ~ANA_ADCCTRL_CICINV;
806 }
807
808 /**
809 * @brief CIC output scale-down configure.
810 * @param ScaleDown:
811 ADC_SCA_NONE
812 ADC_SCA_DIV2
813 * @retval None
814 */
ADC_CICScaleDownConfig(uint32_t ScaleDown)815 void ADC_CICScaleDownConfig(uint32_t ScaleDown)
816 {
817 uint32_t tmp;
818
819 /* Check parameters */
820 assert_parameters(IS_ADC_SCA(ScaleDown));
821
822 tmp = ANA->ADCCTRL;
823 tmp &= ~ANA_ADCCTRL_CICSCA;
824 tmp |= ScaleDown;
825 while (ANA->ADCCTRL & ANA_ADCCTRL_MTRIG);
826 ANA->ADCCTRL = tmp;
827 }
828
829 /**
830 * @brief CIC output skip control.
831 * @param Skip:
832 ADC_SKIP_4
833 ADC_SKIP_5
834 ADC_SKIP_6
835 ADC_SKIP_7
836 ADC_SKIP_0
837 ADC_SKIP_1
838 ADC_SKIP_2
839 ADC_SKIP_3
840 * @retval None
841 */
ADC_CICSkipConfig(uint32_t Skip)842 void ADC_CICSkipConfig(uint32_t Skip)
843 {
844 uint32_t tmp;
845
846 /* Check parameters */
847 assert_parameters(IS_ADC_SKIP(Skip));
848
849 tmp = ANA->ADCCTRL;
850 tmp &= ~ANA_ADCCTRL_CICSKIP;
851 tmp |= Skip;
852 while (ANA->ADCCTRL & ANA_ADCCTRL_MTRIG);
853 ANA->ADCCTRL = tmp;
854 }
855
856 /**
857 * @brief CIC down sampling rate control.
858 * @param DSRSelection:
859 ADC_SDRSEL_DIV512
860 ADC_SDRSEL_DIV256
861 ADC_SDRSEL_DIV128
862 ADC_SDRSEL_DIV64
863 * @retval None
864 */
ADC_CICDownSamRateConfig(uint32_t DSRSelection)865 void ADC_CICDownSamRateConfig(uint32_t DSRSelection)
866 {
867 uint32_t tmp;
868
869 /* Check parameters */
870 assert_parameters(IS_ADC_SDR(DSRSelection));
871 tmp = ANA->ADCCTRL;
872 tmp &= ~ANA_ADCCTRL_DSRSEL;
873 tmp |= DSRSelection;
874 while (ANA->ADCCTRL & ANA_ADCCTRL_MTRIG);
875 ANA->ADCCTRL = tmp;
876 }
877
878 /**
879 * @brief Get ADC vonversion value.
880 * @param Channel:
881 ADC_CHANNEL0
882 ADC_CHANNEL1
883 ADC_CHANNEL2
884 ADC_CHANNEL3
885 ADC_CHANNEL4
886 ADC_CHANNEL5
887 ADC_CHANNEL6
888 ADC_CHANNEL7
889 ADC_CHANNEL8
890 ADC_CHANNEL9
891 ADC_CHANNEL10
892 ADC_CHANNEL11
893 * @retval ADC conversion value.
894 */
ADC_GetADCConversionValue(uint32_t Channel)895 int16_t ADC_GetADCConversionValue(uint32_t Channel)
896 {
897 __IO uint32_t *addr;
898
899 /* Check parameters */
900 assert_parameters(IS_ADC_CHANNEL(Channel));
901
902 addr = &ANA->ADCDATA0 + Channel;
903
904 return *addr;
905 }
906
907 /**
908 * @brief ADC interrupt control.
909 * @param INTMask:
910 ADC_INT_AUTODONE
911 ADC_INT_MANUALDONE
912 NewState
913 ENABLE
914 DISABLE
915 * @retval None
916 */
ADC_INTConfig(uint32_t INTMask,uint32_t NewState)917 void ADC_INTConfig(uint32_t INTMask, uint32_t NewState)
918 {
919 /* Check parameters */
920 assert_parameters(IS_FUNCTIONAL_STATE(NewState));
921 assert_parameters(IS_ADC_INT(INTMask));
922
923 if (NewState == ENABLE)
924 ANA->INTEN |= INTMask;
925 else
926 ANA->INTEN &= ~INTMask;
927 }
928
929 /**
930 * @brief Get auto done flag
931 * @param None
932 * @retval 1 flag set
933 * 0 flag reset.
934 */
ADC_GetAutoDoneFlag(void)935 uint8_t ADC_GetAutoDoneFlag(void)
936 {
937 if(ANA->INTSTS & ANA_INTSTS_INTSTS1)
938 return 1;
939 else
940 return 0;
941 }
942
943 /**
944 * @brief Get manual done flag
945 * @param None
946 * @retval 1 flag set
947 * 0 flag reset.
948 */
ADC_GetManualDoneFlag(void)949 uint8_t ADC_GetManualDoneFlag(void)
950 {
951 if(ANA->INTSTS & ANA_INTSTS_INTSTS0)
952 return 1;
953 else
954 return 0;
955 }
956
957 /**
958 * @brief Clear auto done flag
959 * @param None
960 * @retval None
961 */
ADC_ClearAutoDoneFlag(void)962 void ADC_ClearAutoDoneFlag(void)
963 {
964 ANA->INTSTS = ANA_INTSTS_INTSTS1;
965 }
966
967 /**
968 * @brief Clear manual done flag
969 * @param None
970 * @retval None
971 */
ADC_ClearManualDoneFlag(void)972 void ADC_ClearManualDoneFlag(void)
973 {
974 ANA->INTSTS = ANA_INTSTS_INTSTS0;
975 }
976
977 /*********************************** END OF FILE ******************************/
978