ADC Functions

Functions
enum sd_adc_err	sd_adc_dev_init (struct sd_adc_dev *dev, ADC_HandleTypeDef *adc)
	ADC Device Initialization. More...
void	sd_adc_init (void)
void	HAL_ADC_MspInit (ADC_HandleTypeDef *hadc)
void	HAL_ADC_MspDeInit (ADC_HandleTypeDef *hadc)
void	sd_adc_watchdog_enable (void)
	ADC Watchdog Enable. More...
void	sd_adc_irqhandler (struct sd_adc_dev *dev)
	ADC Interrupt Handler Handle interrupt events on the ADC peripheral. More...
void	sd_adc_print (void)
	Print the ADC Values.
void	sd_adc_monitor (struct sd_adc_dev *dev)
	Check ADC Limits.
void	sd_adc_monitor_enable (void)

Detailed Description

Function Documentation

HAL_ADC_MspInit()

void HAL_ADC_MspInit

(

ADC_HandleTypeDef *

hadc

)

#include <Src/sd_adc.c>

ADC GPIO Configuration

Pin/Port	Channel ----—
PA0	Channel 0
PA1	Channel 1
PA2	Channel 2
PA3	Channel 3
PA6	Channel 6
PB0	Channel 8
PB1	Channel 9
PC2	Channel 12
PC3	Channel 13

{
    GPIO_InitTypeDef GPIO_InitStruct;
    if (hadc->Instance==ADC1) {
        /* Peripheral clock enable */
        __ADC1_CLK_ENABLE();
  
        GPIO_InitStruct.Pin = ZYNQ_1V2_SENSE_Pin |
                      ZYNQ_3V3_SENSE_Pin;
                      
        GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

        GPIO_InitStruct.Pin = MAIN_3V3_SENSE_Pin |
                      VIN_SENSE_Pin |
                      MAIN_1V8_SENSE_Pin |
                      VDDIO2_3V3_SENSE_Pin |
                      VUSB_SENSE_Pin;
    
        GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

        GPIO_InitStruct.Pin = ZYNQ_1V0_SENSE_Pin|ZYNQ_1V8_SENSE_Pin;
        GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
        GPIO_InitStruct.Pull = GPIO_NOPULL;
        HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

        HAL_NVIC_SetPriority(ADC1_COMP_IRQn, 0, 0);
        HAL_NVIC_EnableIRQ(ADC1_COMP_IRQn);
        
        HAL_ADCEx_Calibration_Start(hadc);
    }
}

sd_adc_dev_init()

enum sd_adc_err sd_adc_dev_init	(	struct sd_adc_dev *	dev,
		ADC_HandleTypeDef *	adc
	)

#include <Src/sd_adc.c>

ADC Device Initialization.

Parameters

dev	ADC device to initialize
adc	ADC handle to attach to device

Return values

SD_ADC_SUCCESS

on success, error status otherwise

{
    dev->adc = adc;
    
    /* Set the sampling time and channel selection registers */
    adc->Instance->SMPR = ADC_SAMPLETIME_71CYCLES_5;
    adc_dev.adc->Instance->CHSELR = (1U << ADC_CHANNEL_0) |
                (1U << ADC_CHANNEL_1) |
                (1U << ADC_CHANNEL_2) |
                (1U << ADC_CHANNEL_3) |
                (1U << ADC_CHANNEL_6) |
                (1U << ADC_CHANNEL_8) |
                (1U << ADC_CHANNEL_9) |
                (1U << ADC_CHANNEL_12) |
                (1U << ADC_CHANNEL_13);
    
    /* Start the ADC in interrupt mode */
    HAL_ADC_Start_IT(adc);
    
    return SD_ADC_SUCCESS;
}

sd_adc_init()

void sd_adc_init

(

void

)

#include <Src/sd_adc.c>

Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)

{
    hadc.Instance = ADC1;
    hadc.Init.ClockPrescaler = ADC_CLOCK_ASYNC;
    hadc.Init.Resolution = ADC_RESOLUTION12b;
    hadc.Init.DataAlign = ADC_DATAALIGN_RIGHT;
    hadc.Init.ScanConvMode = ADC_SCAN_DIRECTION_FORWARD;
    hadc.Init.EOCSelection = EOC_SINGLE_CONV;
    hadc.Init.LowPowerAutoWait = DISABLE;
    hadc.Init.LowPowerAutoPowerOff = DISABLE;
    hadc.Init.ContinuousConvMode = ENABLE;
    hadc.Init.DiscontinuousConvMode = DISABLE;
    hadc.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
    hadc.Init.DMAContinuousRequests = DISABLE;
    hadc.Init.Overrun = OVR_DATA_PRESERVED;
    HAL_ADC_Init(&hadc);
    
    sd_adc_dev_init(&adc_dev, &hadc);
}

sd_adc_irqhandler()

void sd_adc_irqhandler

(

struct sd_adc_dev *

dev

)

#include <Src/sd_adc.c>

ADC Interrupt Handler Handle interrupt events on the ADC peripheral.

Parameters

dev	ADC device

Return values

None

{
    ADC_HandleTypeDef *hadc = dev->adc;
  
    /* Check the parameters */
    assert_param(IS_ADC_ALL_INSTANCE(hadc->Instance));
    assert_param(IS_FUNCTIONAL_STATE(hadc->Init.ContinuousConvMode));
    assert_param(IS_ADC_EOC_SELECTION(hadc->Init.EOCSelection));
  
    /* Check if the analog watchdog triggered interrupt */
    if (__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_AWD) &&
        __HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_AWD)) {
        
        /* Disable the Zynq clock */
//      sd_zynq_clk_enable(FALSE);
        
        /* Disable the Zynq power rails */
//      sd_zynq_disable();
    }
  
    /* Check if an end of conversion triggered interrupt */
    if (__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_EOC) && 
         __HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_EOC)) {
    
        /* Update state machine on conversion status if not in error state */
        if (HAL_IS_BIT_CLR(hadc->State, HAL_ADC_STATE_ERROR_INTERNAL)) {
      
            /* Set ADC state */
            SET_BIT(hadc->State, HAL_ADC_STATE_REG_EOC); 
        }
    
        /* Record channel measurement */
        (adc_chan++)->meas = hadc->Instance->DR;
    
        /* Clear regular group conversion flag */
        __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_EOC);
    }
    
    /* Check if end of sequence triggered interrupt */
    if (__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_EOS) && 
        __HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_EOS)) {
        
        /* Reset to beginning of table */
        adc_chan = &adc_tab[0];

        /* Clear interrupt flag */
        __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_EOS);
    }
  
    /*------------------- Check overrun interrupt flag -------------------*/
    if (__HAL_ADC_GET_FLAG(hadc, ADC_FLAG_OVR) &&
        __HAL_ADC_GET_IT_SOURCE(hadc, ADC_IT_OVR)) {
        /* If overrun is set to overwrite previous data (default setting),        */
        /* overrun event is not considered as an error.                           */
        /* (cf ref manual "Managing conversions without using the DMA and without */
        /* overrun ")                                                             */
        /* Exception for usage with DMA overrun event always considered as an     */
        /* error.                                                                 */
        if ((hadc->Init.Overrun == ADC_OVR_DATA_PRESERVED) ||
            HAL_IS_BIT_SET(hadc->Instance->CFGR1, ADC_CFGR1_DMAEN)) {
            /* Set ADC error code overrun bit */
            hadc->ErrorCode |= HAL_ADC_ERROR_OVR;
      
            /* Clear ADC overrun flag */
            __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_OVR);
      
            /* Error callback */ 
            HAL_ADC_ErrorCallback(hadc);
        }
    
        /* Clear the Overrun flag */
        __HAL_ADC_CLEAR_FLAG(hadc, ADC_FLAG_OVR);
    }
}

sd_adc_watchdog_enable()

void sd_adc_watchdog_enable

(

void

)

#include <Src/sd_adc.c>

ADC Watchdog Enable.

Return values

None

{
    ADC_AnalogWDGConfTypeDef adc_wd_config;

    adc_wd_config.WatchdogMode = ADC_ANALOGWATCHDOG_SINGLE_REG;
    adc_wd_config.Channel = ADC_CHANNEL_2;
    adc_wd_config.ITMode = ENABLE;
    adc_wd_config.HighThreshold = 3583;
    adc_wd_config.LowThreshold = 3242;

    HAL_ADC_AnalogWDGConfig(&hadc, &adc_wd_config);
}