Rev 43 | Details | Compare with Previous | Last modification | View Log | RSS feed
Rev | Author | Line No. | Line |
---|---|---|---|
1 | ingob | 1 | /******************** (C) COPYRIGHT 2006 STMicroelectronics ******************** |
2 | * File Name : 91x_adc.c |
||
3 | * Author : MCD Application Team |
||
4 | * Date First Issued : 05/18/2006 : Version 1.0 |
||
5 | * Description : This file provides all the ADC software functions. |
||
6 | ******************************************************************************** |
||
7 | * History: |
||
8 | * 05/22/2007 : Version 1.2 |
||
9 | * 05/24/2006 : Version 1.1 |
||
10 | * 05/18/2006 : Version 1.0 |
||
11 | ******************************************************************************** |
||
12 | * THE PRESENT SOFTWARE WHICH IS FOR GUIDANCE ONLY AIMS AT PROVIDING CUSTOMERS WITH |
||
13 | * CODING INFORMATION REGARDING THEIR PRODUCTS IN ORDER FOR THEM TO SAVE TIME. AS |
||
14 | * A RESULT, STMICROELECTRONICS SHALL NOT BE HELD LIABLE FOR ANY DIRECT, INDIRECT |
||
15 | * OR CONSEQUENTIAL DAMAGES WITH RESPECT TO ANY CLAIMS ARISING FROM THE CONTENT |
||
16 | * OF SUCH SOFTWARE AND/OR THE USE MADE BY CUSTOMERS OF THE CODING INFORMATION |
||
17 | * CONTAINED HEREIN IN CONNECTION WITH THEIR PRODUCTS. |
||
18 | *******************************************************************************/ |
||
19 | |||
20 | |||
21 | /* Standard include ----------------------------------------------------------*/ |
||
22 | #include "91x_adc.h" |
||
23 | #include "91x_scu.h" |
||
24 | /* Include of other module interface headers ---------------------------------*/ |
||
25 | /* Local includes ------------------------------------------------------------*/ |
||
26 | /* Private typedef -----------------------------------------------------------*/ |
||
27 | /* Private define ------------------------------------------------------------*/ |
||
28 | |||
29 | /* ADC mask */ |
||
30 | #define ADC_FLAG_MASK 0x001F /* ADC Flag Mask */ |
||
31 | #define ADC_RESULT_MASK 0x03FF /* ADC Result Mask */ |
||
32 | #define ADC_SCAN_MODE_MASK 0x0020 /* ADC Sacn Mode Mask */ |
||
33 | #define ADC_STANDBY_MODE_MASK 0x0008 /* ADC Standby Mode Mask */ |
||
34 | #define ADC_CMD_MASK 0x0002 /* ADC Command Mask */ |
||
35 | #define ADC_CHANNEL_MASK 0xFE3F /* ADC Channel Select Mask */ |
||
36 | /* Private macro -------------------------------------------------------------*/ |
||
37 | /* Private variables ---------------------------------------------------------*/ |
||
38 | /* Private function prototypes -----------------------------------------------*/ |
||
39 | /* Interface functions -------------------------------------------------------*/ |
||
40 | /* Private functions ---------------------------------------------------------*/ |
||
41 | |||
42 | /******************************************************************************* |
||
43 | * Function Name : ADC_DeInit |
||
44 | * Description : Deinitialize the ADC module registers to their default reset |
||
45 | * values |
||
46 | * Input : None |
||
47 | * Output : None |
||
48 | * Return : None |
||
49 | *******************************************************************************/ |
||
50 | void ADC_DeInit(void) |
||
51 | { |
||
52 | /* Reset the ADC registers values */ |
||
53 | SCU_APBPeriphReset(__ADC,ENABLE); |
||
54 | SCU_APBPeriphReset(__ADC,DISABLE); |
||
55 | } |
||
56 | |||
57 | /******************************************************************************* |
||
58 | * Function Name : ADC_Init |
||
59 | * Description : Initializes ADC peripheral according to the specified |
||
60 | * parameters in the ADC_InitTypeDef structure. |
||
61 | * Input : ADC_InitStruct: pointer to a ADC_InitTypeDef structure that |
||
62 | * contains the configuration information for the specified |
||
63 | * ADC peripheral. |
||
64 | * Output : None |
||
65 | * Return : None |
||
66 | *******************************************************************************/ |
||
67 | void ADC_Init(ADC_InitTypeDef* ADC_InitStruct) |
||
68 | { |
||
69 | /* Set the low threshold of the watchdog */ |
||
70 | ADC->LTR = ADC_InitStruct->ADC_WDG_Low_Threshold; |
||
71 | |||
72 | /* Set the high threshold of the watchdog */ |
||
73 | ADC->HTR = ADC_InitStruct->ADC_WDG_High_Threshold; |
||
74 | |||
75 | |||
76 | /* Channel 0 conversion mode */ |
||
77 | ADC->CCR &= 0xFFFC; |
||
78 | ADC->CCR |= ADC_InitStruct->ADC_Channel_0_Mode; |
||
79 | |||
80 | /* Channel 1 conversion mode */ |
||
81 | ADC->CCR &= 0xFFF3; |
||
82 | ADC->CCR |= ADC_InitStruct->ADC_Channel_1_Mode << 0x2; |
||
83 | |||
84 | /* Channel 2 conversion mode */ |
||
85 | ADC->CCR &= 0xFFCF; |
||
86 | ADC->CCR |= ADC_InitStruct->ADC_Channel_2_Mode << 0x4; |
||
87 | |||
88 | /* Channel 3 conversion mode */ |
||
89 | ADC->CCR &= 0xFF3F; |
||
90 | ADC->CCR |= ADC_InitStruct->ADC_Channel_3_Mode << 0x6; |
||
91 | |||
92 | /* Channel 4 conversion mode */ |
||
93 | ADC->CCR &= 0xFCFF; |
||
94 | ADC->CCR |= ADC_InitStruct->ADC_Channel_4_Mode << 0x8; |
||
95 | |||
96 | /* Channel 5 conversion mode */ |
||
97 | ADC->CCR &= 0xF3FF; |
||
98 | ADC->CCR |= ADC_InitStruct->ADC_Channel_5_Mode << 0xA; |
||
99 | |||
100 | /* Channel 6 conversion mode */ |
||
101 | ADC->CCR &= 0xCFFF; |
||
102 | ADC->CCR |= ADC_InitStruct->ADC_Channel_6_Mode << 0xC; |
||
103 | |||
104 | /* Channel 7 conversion mode */ |
||
105 | ADC->CCR &= 0x3FFF; |
||
106 | ADC->CCR |= ADC_InitStruct->ADC_Channel_7_Mode << 0xE; |
||
107 | |||
108 | /* Select the channel to be converted */ |
||
109 | ADC->CR &= ADC_CHANNEL_MASK; |
||
110 | ADC->CR |= ADC_InitStruct->ADC_Select_Channel << 0x6; |
||
111 | |||
112 | /* Enable/disable the scan mode */ |
||
113 | if (ADC_InitStruct->ADC_Scan_Mode == ENABLE) |
||
114 | { |
||
115 | /* Enable the scan mode */ |
||
116 | ADC->CR |= ADC_SCAN_MODE_MASK; |
||
117 | } |
||
118 | else |
||
119 | { |
||
120 | /* Disable the scan mode */ |
||
121 | ADC->CR &= ~ADC_SCAN_MODE_MASK; |
||
122 | } |
||
123 | |||
124 | /* Configure the conversion mode */ |
||
125 | if (ADC_InitStruct->ADC_Conversion_Mode == ADC_Continuous_Mode) |
||
126 | { |
||
127 | /* ADC continuous mode */ |
||
128 | ADC->CR |= ADC_Continuous_Mode; |
||
129 | } |
||
130 | else |
||
131 | { |
||
132 | /* ADC single mode */ |
||
133 | ADC->CR &= ADC_Single_Mode; |
||
134 | } |
||
135 | } |
||
136 | |||
137 | /******************************************************************************* |
||
138 | * Function Name : ADC_StructInit |
||
139 | * Description : Fills each ADC_InitStruct member with its reset value. |
||
140 | * Input : ADC_InitStruct : pointer to a ADC_InitTypeDef structure |
||
141 | * which will be initialized. |
||
142 | * Output : None |
||
143 | * Return : None. |
||
144 | *******************************************************************************/ |
||
145 | void ADC_StructInit(ADC_InitTypeDef* ADC_InitStruct) |
||
146 | { |
||
147 | ADC_InitStruct->ADC_WDG_High_Threshold = 0x0000; |
||
148 | ADC_InitStruct->ADC_WDG_Low_Threshold = 0x0000; |
||
149 | ADC_InitStruct->ADC_Channel_0_Mode = ADC_No_Conversion; |
||
150 | ADC_InitStruct->ADC_Channel_1_Mode = ADC_No_Conversion; |
||
151 | ADC_InitStruct->ADC_Channel_2_Mode = ADC_No_Conversion; |
||
152 | ADC_InitStruct->ADC_Channel_3_Mode = ADC_No_Conversion; |
||
153 | ADC_InitStruct->ADC_Channel_4_Mode = ADC_No_Conversion; |
||
154 | ADC_InitStruct->ADC_Channel_5_Mode = ADC_No_Conversion; |
||
155 | ADC_InitStruct->ADC_Channel_6_Mode = ADC_No_Conversion; |
||
156 | ADC_InitStruct->ADC_Channel_7_Mode = ADC_No_Conversion; |
||
157 | ADC_InitStruct->ADC_Select_Channel = ADC_Channel_0; |
||
158 | ADC_InitStruct->ADC_Scan_Mode = DISABLE; |
||
159 | ADC_InitStruct->ADC_Conversion_Mode = ADC_Single_Mode; |
||
160 | } |
||
161 | |||
162 | /******************************************************************************* |
||
163 | * Function Name : ADC_PrescalerConfig |
||
164 | * Description : This routine is used to configure the ADC prescaler value. |
||
165 | * Input : ADC_Prescaler: specifies the prescaler value. This parameter |
||
166 | * can be a value from 0x0 to 0xFF. |
||
167 | * Output : None |
||
168 | * Return : None |
||
169 | *******************************************************************************/ |
||
170 | void ADC_PrescalerConfig(u8 ADC_Prescaler) |
||
171 | { |
||
172 | ADC->PRS &= 0xFF00; |
||
173 | ADC->PRS |= ADC_Prescaler; |
||
174 | |||
175 | } |
||
176 | /******************************************************************************* |
||
177 | * Function Name : ADC_GetPrescalerValue |
||
178 | * Description : This routine is used to get the ADC prescaler value. |
||
179 | * Input : None |
||
180 | * Output : None |
||
181 | * Return : The prescaler value. |
||
182 | *******************************************************************************/ |
||
183 | u8 ADC_GetPrescalerValue(void) |
||
184 | { |
||
185 | return ADC->PRS & 0x00FF; |
||
186 | } |
||
187 | /******************************************************************************* |
||
188 | * Function Name : ADC_GetFlagStatus |
||
189 | * Description : Checks whether the specified ADC flag is set or not. |
||
190 | * Input : ADC_Flag: flag to check. |
||
191 | * This parameter can be one of the following values: |
||
192 | * - ADC_FLAG_OV_CH_0: Conversion overflow status for |
||
193 | * channel 0. |
||
194 | * - ADC_FLAG_OV_CH_1: Conversion overflow status for |
||
195 | * channel 1. |
||
196 | * - ADC_FLAG_OV_CH_2: Conversion overflow status for |
||
197 | * channel 2. |
||
198 | * - ADC_FLAG_OV_CH_3: Conversion overflow status for |
||
199 | * channel 3. |
||
200 | * - ADC_FLAG_OV_CH_4: Conversion overflow status for |
||
201 | * channel 4. |
||
202 | * - ADC_FLAG_OV_CH_5: Conversion overflow status for |
||
203 | * channel 5. |
||
204 | * - ADC_FLAG_OV_CH_6: Conversion overflow status for |
||
205 | * channel 6. |
||
206 | * - ADC_FLAG_OV_CH_7: Conversion overflow status for |
||
207 | * channel 7. |
||
208 | * - ADC_FLAG_ECV: End of conversion status. |
||
209 | * - ADC_FLAG_AWD: Analog watchdog status. |
||
210 | * Output : None |
||
211 | * Return : The NewState of the ADC_Flag (SET or RESET). |
||
212 | *******************************************************************************/ |
||
213 | FlagStatus ADC_GetFlagStatus(u16 ADC_Flag) |
||
214 | { |
||
215 | u8 AdcReg = 0, FlagPos = 0; |
||
216 | |||
217 | /* Get the ADC register index */ |
||
218 | AdcReg = ADC_Flag >> 5; |
||
219 | |||
220 | /* Get the flag position */ |
||
221 | FlagPos = ADC_Flag & ADC_FLAG_MASK; |
||
222 | |||
223 | if(AdcReg == 1) /* The flag to check is in CR register */ |
||
224 | { |
||
225 | if((ADC->CR & (1<<FlagPos))!= RESET) |
||
226 | { |
||
227 | return SET; |
||
228 | } |
||
229 | else |
||
230 | { |
||
231 | return RESET; |
||
232 | } |
||
233 | } |
||
234 | else if(AdcReg == 6) /* The flag to check is in DR0 register */ |
||
235 | { |
||
236 | if((ADC->DR0 & (1<<FlagPos))!= RESET) |
||
237 | { |
||
238 | return SET; |
||
239 | } |
||
240 | else |
||
241 | { |
||
242 | return RESET; |
||
243 | } |
||
244 | } |
||
245 | else if(AdcReg == 7) /* The flag to check is in DR1 register */ |
||
246 | { |
||
247 | if((ADC->DR1 & (1<<FlagPos))!= RESET) |
||
248 | { |
||
249 | return SET; |
||
250 | } |
||
251 | else |
||
252 | { |
||
253 | return RESET; |
||
254 | } |
||
255 | } |
||
256 | else if(AdcReg == 8) /* The flag to check is in DR2 register */ |
||
257 | { |
||
258 | if((ADC->DR2 & (1<<FlagPos))!= RESET) |
||
259 | { |
||
260 | return SET; |
||
261 | } |
||
262 | else |
||
263 | { |
||
264 | return RESET; |
||
265 | } |
||
266 | } |
||
267 | else if(AdcReg == 9) /* The flag to check is in DR3 register */ |
||
268 | { |
||
269 | if((ADC->DR3 & (1<<FlagPos))!= RESET) |
||
270 | { |
||
271 | return SET; |
||
272 | } |
||
273 | else |
||
274 | { |
||
275 | return RESET; |
||
276 | } |
||
277 | } |
||
278 | |||
279 | else if(AdcReg == 0xA) /* The flag to check is in DR4 register */ |
||
280 | { |
||
281 | if((ADC->DR4 & (1<<FlagPos))!= RESET) |
||
282 | { |
||
283 | return SET; |
||
284 | } |
||
285 | else |
||
286 | { |
||
287 | return RESET; |
||
288 | } |
||
289 | } |
||
290 | else if(AdcReg == 0xB) /* The flag to check is in DR5 register */ |
||
291 | { |
||
292 | if((ADC->DR5 & (1<<FlagPos))!= RESET) |
||
293 | { |
||
294 | return SET; |
||
295 | } |
||
296 | else |
||
297 | { |
||
298 | return RESET; |
||
299 | } |
||
300 | } |
||
301 | else if(AdcReg == 0xC) /* The flag to check is in DR6 register */ |
||
302 | { |
||
303 | if((ADC->DR6 & (1<<FlagPos))!= RESET) |
||
304 | { |
||
305 | return SET; |
||
306 | } |
||
307 | else |
||
308 | { |
||
309 | return RESET; |
||
310 | } |
||
311 | } |
||
312 | else /* (AdcReg == 0xD), The flag to check is in DR7 register */ |
||
313 | { |
||
314 | if((ADC->DR7 & (1<<FlagPos))!= RESET) |
||
315 | { |
||
316 | return SET; |
||
317 | } |
||
318 | else |
||
319 | { |
||
320 | return RESET; |
||
321 | } |
||
322 | } |
||
323 | } |
||
324 | |||
325 | /******************************************************************************* |
||
326 | * Function Name : ADC_ClearFlag |
||
327 | * Description : Clears the ADC Flag passed as a parameter. |
||
328 | * Input : ADC_Flag: flag to clear. |
||
329 | * This parameter can be one of the following values: |
||
330 | * - ADC_FLAG_ECV: End of conversion status. |
||
331 | * - ADC_FLAG_AWD: Analog watchdog status. |
||
332 | * Output : None |
||
333 | * Return : None |
||
334 | *******************************************************************************/ |
||
335 | void ADC_ClearFlag(u16 ADC_Flag) |
||
336 | { |
||
337 | /* Clear the correspondent flag */ |
||
338 | ADC->CR |= (1<<(ADC_Flag & ADC_FLAG_MASK)); |
||
339 | } |
||
340 | |||
341 | /******************************************************************************* |
||
342 | * Function Name : ADC_GetConversionValue |
||
343 | * Description : Read the result of conversion from the appropriate data |
||
344 | * register. |
||
345 | * Input : ADC_Channel: the correspondent channel of the ADC peripheral. |
||
346 | * This parameter can be one of the following values: |
||
347 | * - ADC_Channel_0: ADC channel 0. |
||
348 | * - ADC_Channel_1: ADC channel 1. |
||
349 | * - ADC_Channel_2: ADC channel 2. |
||
350 | * - ADC_Channel_3: ADC channel 3. |
||
351 | * - ADC_Channel_4: ADC channel 4. |
||
352 | * - ADC_Channel_5: ADC channel 5. |
||
353 | * - ADC_Channel_6: ADC channel 6. |
||
354 | * - ADC_Channel_7: ADC channel 7. |
||
355 | * Output : None |
||
356 | * Return : The result of the conversion for the specific channel. |
||
357 | *******************************************************************************/ |
||
358 | u16 ADC_GetConversionValue(u16 ADC_Channel) |
||
359 | { |
||
360 | u16 ADC_Conversion_Value = 0; |
||
361 | |||
362 | switch (ADC_Channel) |
||
363 | { |
||
364 | case (ADC_Channel_0): |
||
365 | /* Get the conversion value of the channel 0 */ |
||
366 | ADC_Conversion_Value = ADC->DR0 & ADC_RESULT_MASK; |
||
367 | break; |
||
368 | |||
369 | case (ADC_Channel_1): |
||
370 | /* Get the conversion value of the channel 1 */ |
||
371 | ADC_Conversion_Value = ADC->DR1 & ADC_RESULT_MASK; |
||
372 | break; |
||
373 | |||
374 | case (ADC_Channel_2): |
||
375 | /* Get the conversion value of the channel 2 */ |
||
376 | ADC_Conversion_Value = ADC->DR2 & ADC_RESULT_MASK; |
||
377 | break; |
||
378 | |||
379 | case (ADC_Channel_3): |
||
380 | /* Get the conversion value of the channel 3 */ |
||
381 | ADC_Conversion_Value = ADC->DR3 & ADC_RESULT_MASK; |
||
382 | break; |
||
383 | |||
384 | case (ADC_Channel_4): |
||
385 | /* Get the conversion value of the channel 4 */ |
||
386 | ADC_Conversion_Value = ADC->DR4 & ADC_RESULT_MASK; |
||
387 | break; |
||
388 | |||
389 | case (ADC_Channel_5): |
||
390 | /* Get the conversion value of the channel 5 */ |
||
391 | ADC_Conversion_Value = ADC->DR5 & ADC_RESULT_MASK; |
||
392 | break; |
||
393 | |||
394 | case (ADC_Channel_6): |
||
395 | /* Get the conversion value of the channel 6 */ |
||
396 | ADC_Conversion_Value = ADC->DR6 & ADC_RESULT_MASK; |
||
397 | break; |
||
398 | |||
399 | case (ADC_Channel_7): |
||
400 | /* Get the conversion value of the channel 7 */ |
||
401 | ADC_Conversion_Value = ADC->DR7 & ADC_RESULT_MASK; |
||
402 | break; |
||
403 | |||
404 | default: |
||
405 | break; |
||
406 | } |
||
407 | |||
408 | return(ADC_Conversion_Value); |
||
409 | } |
||
410 | |||
411 | /******************************************************************************* |
||
412 | * Function Name : ADC_GetAnalogWatchdogResult |
||
413 | * Description : Return the result of the comparaison on the selected Analog |
||
414 | * Watchdog. |
||
415 | * Input : ADC_Channel: the correspondent channel of the ADC peripheral. |
||
416 | * This parameter can be one of the following values: |
||
417 | * - ADC_Channel_0: ADC channel 0. |
||
418 | * - ADC_Channel_1: ADC channel 1. |
||
419 | * - ADC_Channel_2: ADC channel 2. |
||
420 | * - ADC_Channel_3: ADC channel 3. |
||
421 | * - ADC_Channel_4: ADC channel 4. |
||
422 | * - ADC_Channel_5: ADC channel 5. |
||
423 | * - ADC_Channel_6: ADC channel 6. |
||
424 | * - ADC_Channel_7: ADC channel 7. |
||
425 | * Output : None |
||
426 | * Return : The state of the comparision (SET or RESET). |
||
427 | *******************************************************************************/ |
||
428 | FlagStatus ADC_GetAnalogWatchdogResult(u16 ADC_Channel) |
||
429 | { |
||
430 | if (ADC->CRR & (1<<ADC_Channel) != RESET) |
||
431 | { |
||
432 | return SET; |
||
433 | } |
||
434 | else |
||
435 | { |
||
436 | return RESET; |
||
437 | } |
||
438 | } |
||
439 | |||
440 | /******************************************************************************* |
||
441 | * Function Name : ADC_ClearAnalogWatchdogResult |
||
442 | * Description : Clear the result of the comparaison on the selected Analog |
||
443 | * Watchdog. |
||
444 | * Input : ADC_Channel: the correspondent channel of the ADC peripheral. |
||
445 | * This parameter can be one of the following values: |
||
446 | * - ADC_Channel_0: ADC channel 0. |
||
447 | * - ADC_Channel_1: ADC channel 1. |
||
448 | * - ADC_Channel_2: ADC channel 2. |
||
449 | * - ADC_Channel_3: ADC channel 3. |
||
450 | * - ADC_Channel_4: ADC channel 4. |
||
451 | * - ADC_Channel_5: ADC channel 5. |
||
452 | * - ADC_Channel_6: ADC channel 6. |
||
453 | * - ADC_Channel_7: ADC channel 7. |
||
454 | * Output : None |
||
455 | * Return : None |
||
456 | *******************************************************************************/ |
||
457 | void ADC_ClearAnalogWatchdogResult(u16 ADC_Channel) |
||
458 | { |
||
459 | /* Clear the correspondent watchdog result */ |
||
460 | ADC->CRR = 1<<ADC_Channel; |
||
461 | } |
||
462 | |||
463 | /******************************************************************************* |
||
464 | * Function Name : ADC_GetWatchdogThreshold |
||
465 | * Description : Get the higher/lower thresholds values of the watchdog. |
||
466 | * Input : ADC_Threshold: the lower or the higher threshold. |
||
467 | * This parameter can be one of the following values: |
||
468 | * - ADC_HigherThreshold: The higher threshold. |
||
469 | * - ADC_LowerThreshold: The lower threshold. |
||
470 | * Output : None |
||
471 | * Return : The selected threshold value. |
||
472 | *******************************************************************************/ |
||
473 | u16 ADC_GetWatchdogThreshold(ADC_ThresholdType ADC_Threshold) |
||
474 | { |
||
475 | u16 ADC_Threshold_Value = 0; |
||
476 | |||
477 | switch (ADC_Threshold) |
||
478 | { |
||
479 | case ADC_LowThreshold: |
||
480 | /* Get the low threshold of the watchdog */ |
||
481 | ADC_Threshold_Value = ADC->LTR; |
||
482 | break; |
||
483 | |||
484 | case ADC_HighThreshold: |
||
485 | /* Get the high threshol of the watchdog */ |
||
486 | ADC_Threshold_Value = ADC->HTR; |
||
487 | break; |
||
488 | |||
489 | default: |
||
490 | break; |
||
491 | } |
||
492 | |||
493 | return(ADC_Threshold_Value); |
||
494 | } |
||
495 | |||
496 | /******************************************************************************* |
||
497 | * Function Name : ADC_ITConfig |
||
498 | * Description : Enables or disables the specified ADC interrupts. |
||
499 | * Input : - ADC_IT: specifies the ADC interrupts sources to be enabled |
||
500 | * or disabled. |
||
501 | * This parameter can be one of the following values: |
||
502 | * - ADC_IT_EndOfConversion: End of conversion interrupt. |
||
503 | * - ADC_IT_AnalogWDG: Analog watchdog interrupt. |
||
504 | * - ADC_NewState: new state of the specified ADC interrupts. |
||
505 | * (ADC_Newstate can be ENABLE or DISABLE). |
||
506 | * Output : None |
||
507 | * Return : None |
||
508 | *******************************************************************************/ |
||
509 | void ADC_ITConfig(u16 ADC_IT, FunctionalState ADC_NewState) |
||
510 | { |
||
511 | if (ADC_NewState == ENABLE) |
||
512 | { |
||
513 | /* Enable the interrupt */ |
||
514 | ADC->CR |= ADC_IT; |
||
515 | } |
||
516 | else |
||
517 | { |
||
518 | /* Disable the interrupt */ |
||
519 | ADC->CR &= ~ADC_IT; |
||
520 | } |
||
521 | } |
||
522 | |||
523 | /******************************************************************************* |
||
524 | * Function Name : ADC_StandbyModeCmd |
||
525 | * Description : Enable or disable the standby mode. |
||
526 | * Input : ADC_NewState: new state of the ADC standby mode. |
||
527 | * (ADC_Newstate can be ENABLE or DISABLE). |
||
528 | * Output : None |
||
529 | * Return : None |
||
530 | *******************************************************************************/ |
||
531 | void ADC_StandbyModeCmd(FunctionalState ADC_NewState) |
||
532 | { |
||
533 | if (ADC_NewState == ENABLE) |
||
534 | { |
||
535 | /* Enable the standby mode */ |
||
536 | ADC->CR |= ADC_STANDBY_MODE_MASK; |
||
537 | } |
||
538 | else |
||
539 | { |
||
540 | /* Disable the standby mode */ |
||
541 | ADC->CR &= ~ADC_STANDBY_MODE_MASK; |
||
542 | } |
||
543 | } |
||
544 | |||
545 | /******************************************************************************* |
||
546 | * Function Name : ADC_Cmd |
||
547 | * Description : Power on or put in reset mode the ADC peripheral. |
||
548 | * Input : ADC_NewState: new state of the ADC peripheral. |
||
549 | * (ADC_Newstate can be ENABLE or DISABLE). |
||
550 | * Output : None |
||
551 | * Return : None |
||
552 | *******************************************************************************/ |
||
553 | void ADC_Cmd(FunctionalState ADC_NewState) |
||
554 | { |
||
555 | if (ADC_NewState == ENABLE) |
||
556 | { |
||
557 | /* Enable the ADC */ |
||
558 | ADC->CR |= ADC_CMD_MASK; |
||
559 | } |
||
560 | else |
||
561 | { |
||
562 | /* Disable the ADC */ |
||
563 | ADC->CR &= ~ADC_CMD_MASK; |
||
564 | } |
||
565 | } |
||
566 | |||
567 | /******************************************************************************* |
||
568 | * Function Name : ADC_ConversionCmd |
||
569 | * Description : Start or stop the ADC conversion in the selected mode. |
||
570 | * Input : ADC_Conversion: the conversion command. |
||
571 | * This parameter can be one of the following values: |
||
572 | * - ADC_Conversion_Start: Start the conversion. |
||
573 | * - ADC_Conversion_Stop: Stop the Conversion. |
||
574 | * Output : None |
||
575 | * Return : None |
||
576 | *******************************************************************************/ |
||
577 | void ADC_ConversionCmd(u16 ADC_Conversion) |
||
578 | { |
||
579 | if (ADC_Conversion == ADC_Conversion_Start) |
||
580 | { |
||
581 | /* Start the ADC conversion */ |
||
582 | ADC->CR |= ADC_Conversion_Start; |
||
583 | } |
||
584 | else |
||
585 | { |
||
586 | /* Stop the ADC conversion */ |
||
587 | ADC->CR &= ADC_Conversion_Stop; |
||
588 | } |
||
589 | } |
||
590 | |||
591 | /******************* (C) COPYRIGHT 2006 STMicroelectronics *****END OF FILE****/ |