adc_driver.c

Go to the documentation of this file.

/* This file has been prepared for Doxygen automatic documentation generation.*/
#include "adc_driver.h"


void ADC_CalibrationValues_Load(ADC_t * adc)
{
        if(&ADCA == adc){
                 /* Get ADCACAL0 from production signature . */
                adc->CALL = SP_ReadCalibrationByte( PROD_SIGNATURES_START + ADCACAL0_offset );
                adc->CALH = SP_ReadCalibrationByte( PROD_SIGNATURES_START + ADCACAL1_offset );
//      adc->CALL = 0x77;
//      adc->CALH = 0x07;
        }else {
                /* Get ADCBCAL0 from production signature  */
                adc->CALL = SP_ReadCalibrationByte( PROD_SIGNATURES_START + ADCBCAL0_offset );
                adc->CALH = SP_ReadCalibrationByte( PROD_SIGNATURES_START + ADCBCAL1_offset );
        }
}


uint16_t ADC_ResultCh_GetWord_Unsigned(ADC_CH_t * adc_ch, uint16_t offset)
{
        uint16_t answer;

        /* Clear interrupt flag.*/
        adc_ch->INTFLAGS = ADC_CH_CHIF_bm;

        /* Return result register contents*/
        answer = adc_ch->RES - offset;

        return answer;
}


int16_t ADC_ResultCh_GetWord_Signed(ADC_CH_t * adc_ch, int16_t signedOffset)
{
        int16_t answer;

        /* Clear interrupt flag.*/
        adc_ch->INTFLAGS = ADC_CH_CHIF_bm;

        /* Return result register contents*/
        answer = adc_ch->RES - signedOffset;

        return answer;
}

uint16_t ADC_ResultCh_GetWord(ADC_CH_t * adc_ch)
{
        /* Clear interrupt flag.*/
        adc_ch->INTFLAGS = ADC_CH_CHIF_bm;

        /* Return result register contents*/
        return adc_ch->RES;;
}


uint8_t ADC_ResultCh_GetLowByte(ADC_CH_t * adc_ch)
{
        /* Clear interrupt flag.*/
        adc_ch->INTFLAGS = ADC_CH_CHIF_bm;
        /* Return result register contents*/
        return adc_ch->RESL;
}

uint8_t ADC_ResultCh_GetHighByte(ADC_CH_t * adc_ch)
{
        /* Clear interrupt flag.*/
        adc_ch->INTFLAGS = ADC_CH_CHIF_bm;

        /* Return low byte result register contents.*/
        return adc_ch->RESH;
}

void ADC_Wait_8MHz(ADC_t * adc)
{
        /* Store old prescaler value. */
        uint8_t prescaler_val = adc->PRESCALER;

        /* Set prescaler value to minimum value. */
        adc->PRESCALER = ADC_PRESCALER_DIV4_gc;

        /* Wait 4*COMMON_MODE_CYCLES for common mode to settle. */
        delay_us(4*COMMON_MODE_CYCLES);

        /* Set prescaler to old value*/
        adc->PRESCALER = prescaler_val;
}


void ADC_Wait_32MHz(ADC_t * adc)
{
        /* Store old prescaler value. */
        uint8_t prescaler_val = adc->PRESCALER;

        /* Set prescaler value to minimum value. */
        adc->PRESCALER = ADC_PRESCALER_DIV8_gc;

        /* wait 8*COMMON_MODE_CYCLES for common mode to settle*/
        delay_us(8*COMMON_MODE_CYCLES);

        /* Set prescaler to old value*/
        adc->PRESCALER = prescaler_val;
}

uint16_t ADC_Offset_Get_Unsigned(ADC_t * adc, ADC_CH_t *ch, bool oversampling)
{
    if (oversampling)
    {
      uint16_t offset=0;
      for (int i=0; i<4; i++)
      {
        /* Do one conversion to find offset. */
        ADC_Ch_Conversion_Start(ch);
    
        do{
        }while(!ADC_Ch_Conversion_Complete(ch));
        offset += ADC_ResultCh_GetWord_Unsigned(ch, 0x00);
      }
            return ((uint16_t)(offset>>2));
    }
    else
    {        
      uint16_t offset=0;
      
      /* Do one conversion to find offset. */
      ADC_Ch_Conversion_Start(ch);
  
      do{
      }while(!ADC_Ch_Conversion_Complete(ch));
      offset = (uint16_t)ADC_ResultCh_GetWord(ch);
      
      return offset;
    }
}

int16_t ADC_Offset_Get_Signed(ADC_t * adc, ADC_CH_t *ch, bool oversampling)
{
    if (oversampling)
    {
      int16_t offset_calc=0;
      for (int i=0; i<4; i++)
      {
        /* Do one conversion to find offset. */
        ADC_Ch_Conversion_Start(ch);
    
        do{
        }while(!ADC_Ch_Conversion_Complete(ch));
        offset_calc += ADC_ResultCh_GetWord_Signed(ch, 0x0000);
      }
      return ((int16_t)(offset_calc/4));
    }
    else
    {        
      int16_t offset_calc=0;
      
      /* Do one conversion to find offset. */
      ADC_Ch_Conversion_Start(ch);
  
      do{
      }while(!ADC_Ch_Conversion_Complete(ch));
      offset_calc = (uint16_t)ADC_ResultCh_GetWord_Signed(ch, 0x0000);
      
      return offset_calc;
    }
}

               
#ifdef __GNUC__

uint8_t SP_ReadCalibrationByte( uint8_t index )
{
        uint8_t result;

        /* Load the NVM Command register to read the calibration row. */
        NVM_CMD = NVM_CMD_READ_CALIB_ROW_gc;
        result = pgm_read_byte(index);

        /* Clean up NVM Command register. */
        NVM_CMD = NVM_CMD_NO_OPERATION_gc;

        return result;
}

#endif