Xmega Application Note


adc_driver.c

Go to the documentation of this file.
00001 /* This file has been prepared for Doxygen automatic documentation generation.*/
00067 #include "adc_driver.h"
00068 
00069 
00077 void ADC_CalibrationValues_Load(ADC_t * adc)
00078 {
00079         if(&ADCA == adc){
00080                  /* Get ADCACAL0 from production signature . */
00081                 adc->CALL = SP_ReadCalibrationByte( PROD_SIGNATURES_START + ADCACAL0_offset );
00082                 adc->CALH = SP_ReadCalibrationByte( PROD_SIGNATURES_START + ADCACAL1_offset );
00083         }else {
00084                 /* Get ADCBCAL0 from production signature  */
00085                 adc->CALL = SP_ReadCalibrationByte( PROD_SIGNATURES_START + ADCBCAL0_offset );
00086                 adc->CALH = SP_ReadCalibrationByte( PROD_SIGNATURES_START + ADCACAL1_offset );
00087         }
00088 }
00089 
00090 
00100 uint16_t ADC_ResultCh_GetWord_Unsigned(ADC_CH_t * adc_ch, uint8_t offset)
00101 {
00102         uint16_t answer;
00103 
00104         /* Clear interrupt flag.*/
00105         adc_ch->INTFLAGS = ADC_CH_CHIF_bm;
00106 
00107         /* Return result register contents*/
00108         answer = adc_ch->RES - offset;
00109 
00110         return answer;
00111 }
00112 
00113 
00123 int16_t ADC_ResultCh_GetWord_Signed(ADC_CH_t * adc_ch, int8_t signedOffset)
00124 {
00125         int16_t answer;
00126 
00127         /* Clear interrupt flag.*/
00128         adc_ch->INTFLAGS = ADC_CH_CHIF_bm;
00129 
00130         /* Return result register contents*/
00131         answer = adc_ch->RES - signedOffset;
00132 
00133         return answer;
00134 }
00135 
00144 uint16_t ADC_ResultCh_GetWord(ADC_CH_t * adc_ch)
00145 {
00146         /* Clear interrupt flag.*/
00147         adc_ch->INTFLAGS = ADC_CH_CHIF_bm;
00148 
00149         /* Return result register contents*/
00150         return adc_ch->RES;;
00151 }
00152 
00153 
00166 uint8_t ADC_ResultCh_GetLowByte(ADC_CH_t * adc_ch)
00167 {
00168         /* Clear interrupt flag.*/
00169         adc_ch->INTFLAGS = ADC_CH_CHIF_bm;
00170         /* Return result register contents*/
00171         return adc_ch->RESL;
00172 }
00173 
00186 uint8_t ADC_ResultCh_GetHighByte(ADC_CH_t * adc_ch)
00187 {
00188         /* Clear interrupt flag.*/
00189         adc_ch->INTFLAGS = ADC_CH_CHIF_bm;
00190 
00191         /* Return low byte result register contents.*/
00192         return adc_ch->RESH;
00193 }
00194 
00208 void ADC_Wait_8MHz(ADC_t * adc)
00209 {
00210         /* Store old prescaler value. */
00211         uint8_t prescaler_val = adc->PRESCALER;
00212 
00213         /* Set prescaler value to minimum value. */
00214         adc->PRESCALER = ADC_PRESCALER_DIV4_gc;
00215 
00216         /* Wait 4*COMMON_MODE_CYCLES for common mode to settle. */
00217         delay_us(4*COMMON_MODE_CYCLES);
00218 
00219         /* Set prescaler to old value*/
00220         adc->PRESCALER = prescaler_val;
00221 }
00222 
00223 
00240 void ADC_Wait_32MHz(ADC_t * adc)
00241 {
00242         /* Store old prescaler value. */
00243         uint8_t prescaler_val = adc->PRESCALER;
00244 
00245         /* Set prescaler value to minimum value. */
00246         adc->PRESCALER = ADC_PRESCALER_DIV8_gc;
00247 
00248         /* wait 8*COMMON_MODE_CYCLES for common mode to settle*/
00249         delay_us(8*COMMON_MODE_CYCLES);
00250 
00251         /* Set prescaler to old value*/
00252         adc->PRESCALER = prescaler_val;
00253 }
00254 
00271 uint8_t ADC_Offset_Get_Unsigned(ADC_t * adc, ADC_CH_t *ch, bool oversampling)
00272 {
00273     if (oversampling)
00274     {
00275       uint16_t offset=0;
00276       for (int i=0; i<4; i++)
00277       {
00278         /* Do one conversion to find offset. */
00279         ADC_Ch_Conversion_Start(ch);
00280     
00281         do{
00282         }while(!ADC_Ch_Conversion_Complete(ch));
00283         offset += ADC_ResultCh_GetWord_Unsigned(ch, 0x00);
00284       }
00285       return ((uint8_t)(offset>>2));
00286     }
00287     else
00288     {        
00289       uint8_t offset=0;
00290       
00291       /* Do one conversion to find offset. */
00292       ADC_Ch_Conversion_Start(ch);
00293   
00294       do{
00295       }while(!ADC_Ch_Conversion_Complete(ch));
00296       offset = (uint8_t)ADC_ResultCh_GetWord(ch);
00297       
00298       return offset;
00299     }
00300 }
00301 
00318 int8_t ADC_Offset_Get_Signed(ADC_t * adc, ADC_CH_t *ch, bool oversampling)
00319 {
00320     if (oversampling)
00321     {
00322       int16_t offset=0;
00323       for (int i=0; i<4; i++)
00324       {
00325         /* Do one conversion to find offset. */
00326         ADC_Ch_Conversion_Start(ch);
00327     
00328         do{
00329         }while(!ADC_Ch_Conversion_Complete(ch));
00330         offset += ADC_ResultCh_GetWord_Signed(ch, 0x00);
00331       }
00332       return ((int8_t)(offset/4));
00333     }
00334     else
00335     {        
00336       int8_t offset=0;
00337       
00338       /* Do one conversion to find offset. */
00339       ADC_Ch_Conversion_Start(ch);
00340   
00341       do{
00342       }while(!ADC_Ch_Conversion_Complete(ch));
00343       offset = (uint8_t)ADC_ResultCh_GetWord_Signed(ch, 0x00);
00344       
00345       return offset;
00346     }
00347 }
00348 
00349                
00350 #ifdef __GNUC__
00351 
00360 uint8_t SP_ReadCalibrationByte( uint8_t index )
00361 {
00362         uint8_t result;
00363 
00364         /* Load the NVM Command register to read the calibration row. */
00365         NVM_CMD = NVM_CMD_READ_CALIB_ROW_gc;
00366         result = pgm_read_byte(index);
00367 
00368         /* Clean up NVM Command register. */
00369         NVM_CMD = NVM_CMD_NO_OPERATION_gc;
00370 
00371         return result;
00372 }
00373 
00374 #endif
@DOC_TITLE@
Generated on Tue Aug 4 13:31:15 2009 for AVR1300 Using the XMEGA ADC by doxygen 1.5.3