297 lines
9.2 KiB
C
297 lines
9.2 KiB
C
/*
|
|
* Copyright (c) 2016, Freescale Semiconductor, Inc.
|
|
* Copyright 2016-2017 NXP
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
* are permitted provided that the following conditions are met:
|
|
*
|
|
* o Redistributions of source code must retain the above copyright notice, this list
|
|
* of conditions and the following disclaimer.
|
|
*
|
|
* o Redistributions in binary form must reproduce the above copyright notice, this
|
|
* list of conditions and the following disclaimer in the documentation and/or
|
|
* other materials provided with the distribution.
|
|
*
|
|
* o Neither the name of the copyright holder nor the names of its
|
|
* contributors may be used to endorse or promote products derived from this
|
|
* software without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
|
|
* ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
|
|
* ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "fsl_adc.h"
|
|
|
|
/*******************************************************************************
|
|
* Prototypes
|
|
******************************************************************************/
|
|
/*!
|
|
* @brief Get instance number for ADC module.
|
|
*
|
|
* @param base ADC peripheral base address
|
|
*/
|
|
static uint32_t ADC_GetInstance(ADC_Type *base);
|
|
|
|
/*******************************************************************************
|
|
* Variables
|
|
******************************************************************************/
|
|
/*! @brief Pointers to ADC bases for each instance. */
|
|
static ADC_Type *const s_adcBases[] = ADC_BASE_PTRS;
|
|
|
|
/*! @brief Pointers to ADC clocks for each instance. */
|
|
static const clock_ip_name_t s_adcClocks[] = ADC_CLOCKS;
|
|
|
|
/*******************************************************************************
|
|
* Code
|
|
******************************************************************************/
|
|
static uint32_t ADC_GetInstance(ADC_Type *base)
|
|
{
|
|
uint32_t instance;
|
|
|
|
/* Find the instance index from base address mappings. */
|
|
for (instance = 0; instance < ARRAY_SIZE(s_adcBases); instance++)
|
|
{
|
|
if (s_adcBases[instance] == base)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
assert(instance < ARRAY_SIZE(s_adcBases));
|
|
|
|
return instance;
|
|
}
|
|
|
|
void ADC_Init(ADC_Type *base, const adc_config_t *config)
|
|
{
|
|
assert(NULL != config);
|
|
|
|
uint32_t tmp32;
|
|
|
|
/* Enable the clock. */
|
|
CLOCK_EnableClock(s_adcClocks[ADC_GetInstance(base)]);
|
|
/* ADCx_CFG */
|
|
tmp32 = base->CFG & (ADC_CFG_AVGS_MASK | ADC_CFG_ADTRG_MASK); /* Reserve AVGS and ADTRG bits. */
|
|
tmp32 |= ADC_CFG_REFSEL(config->referenceVoltageSource) | ADC_CFG_ADSTS(config->samplePeriodMode) |
|
|
ADC_CFG_ADICLK(config->clockSource) | ADC_CFG_ADIV(config->clockDriver) | ADC_CFG_MODE(config->resolution);
|
|
if (config->enableOverWrite)
|
|
{
|
|
tmp32 |= ADC_CFG_OVWREN_MASK;
|
|
}
|
|
if (config->enableLongSample)
|
|
{
|
|
tmp32 |= ADC_CFG_ADLSMP_MASK;
|
|
}
|
|
if (config->enableLowPower)
|
|
{
|
|
tmp32 |= ADC_CFG_ADLPC_MASK;
|
|
}
|
|
if (config->enableHighSpeed)
|
|
{
|
|
tmp32 |= ADC_CFG_ADHSC_MASK;
|
|
}
|
|
base->CFG = tmp32;
|
|
|
|
/* ADCx_GC */
|
|
tmp32 = base->GC & ~(ADC_GC_ADCO_MASK | ADC_GC_ADACKEN_MASK);
|
|
if (config->enableContinuousConversion)
|
|
{
|
|
tmp32 |= ADC_GC_ADCO_MASK;
|
|
}
|
|
if (config->enableAsynchronousClockOutput)
|
|
{
|
|
tmp32 |= ADC_GC_ADACKEN_MASK;
|
|
}
|
|
base->GC = tmp32;
|
|
}
|
|
|
|
void ADC_Deinit(ADC_Type *base)
|
|
{
|
|
/* Disable the clock. */
|
|
CLOCK_DisableClock(s_adcClocks[ADC_GetInstance(base)]);
|
|
}
|
|
|
|
void ADC_GetDefaultConfig(adc_config_t *config)
|
|
{
|
|
assert(NULL != config);
|
|
|
|
config->enableAsynchronousClockOutput = true;
|
|
config->enableOverWrite = false;
|
|
config->enableContinuousConversion = false;
|
|
config->enableHighSpeed = false;
|
|
config->enableLowPower = false;
|
|
config->enableLongSample = false;
|
|
config->referenceVoltageSource = kADC_ReferenceVoltageSourceAlt0;
|
|
config->samplePeriodMode = kADC_SamplePeriod2or12Clocks;
|
|
config->clockSource = kADC_ClockSourceAD;
|
|
config->clockDriver = kADC_ClockDriver1;
|
|
config->resolution = kADC_Resolution12Bit;
|
|
}
|
|
|
|
void ADC_SetChannelConfig(ADC_Type *base, uint32_t channelGroup, const adc_channel_config_t *config)
|
|
{
|
|
assert(NULL != config);
|
|
assert(channelGroup < ADC_HC_COUNT);
|
|
|
|
uint32_t tmp32;
|
|
|
|
tmp32 = ADC_HC_ADCH(config->channelNumber);
|
|
if (config->enableInterruptOnConversionCompleted)
|
|
{
|
|
tmp32 |= ADC_HC_AIEN_MASK;
|
|
}
|
|
base->HC[channelGroup] = tmp32;
|
|
}
|
|
|
|
/*
|
|
*To complete calibration, the user must follow the below procedure:
|
|
* 1. Configure ADC_CFG with actual operating values for maximum accuracy.
|
|
* 2. Configure the ADC_GC values along with CAL bit.
|
|
* 3. Check the status of CALF bit in ADC_GS and the CAL bit in ADC_GC.
|
|
* 4. When CAL bit becomes '0' then check the CALF status and COCO[0] bit status.
|
|
*/
|
|
status_t ADC_DoAutoCalibration(ADC_Type *base)
|
|
{
|
|
status_t status = kStatus_Success;
|
|
#if !(defined(FSL_FEATURE_ADC_SUPPORT_HARDWARE_TRIGGER_REMOVE) && FSL_FEATURE_ADC_SUPPORT_HARDWARE_TRIGGER_REMOVE)
|
|
bool bHWTrigger = false;
|
|
|
|
/* The calibration would be failed when in hardwar mode.
|
|
* Remember the hardware trigger state here and restore it later if the hardware trigger is enabled.*/
|
|
if (0U != (ADC_CFG_ADTRG_MASK & base->CFG))
|
|
{
|
|
bHWTrigger = true;
|
|
ADC_EnableHardwareTrigger(base, false);
|
|
}
|
|
#endif
|
|
|
|
/* Clear the CALF and launch the calibration. */
|
|
base->GS = ADC_GS_CALF_MASK; /* Clear the CALF. */
|
|
base->GC |= ADC_GC_CAL_MASK; /* Launch the calibration. */
|
|
|
|
/* Check the status of CALF bit in ADC_GS and the CAL bit in ADC_GC. */
|
|
while (0U != (base->GC & ADC_GC_CAL_MASK))
|
|
{
|
|
/* Check the CALF when the calibration is active. */
|
|
if (0U != (ADC_GetStatusFlags(base) & kADC_CalibrationFailedFlag))
|
|
{
|
|
status = kStatus_Fail;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* When CAL bit becomes '0' then check the CALF status and COCO[0] bit status. */
|
|
if (0U == ADC_GetChannelStatusFlags(base, 0U)) /* Check the COCO[0] bit status. */
|
|
{
|
|
status = kStatus_Fail;
|
|
}
|
|
if (0U != (ADC_GetStatusFlags(base) & kADC_CalibrationFailedFlag)) /* Check the CALF status. */
|
|
{
|
|
status = kStatus_Fail;
|
|
}
|
|
|
|
/* Clear conversion done flag. */
|
|
ADC_GetChannelConversionValue(base, 0U);
|
|
|
|
#if !(defined(FSL_FEATURE_ADC_SUPPORT_HARDWARE_TRIGGER_REMOVE) && FSL_FEATURE_ADC_SUPPORT_HARDWARE_TRIGGER_REMOVE)
|
|
/* Restore original trigger mode. */
|
|
if (true == bHWTrigger)
|
|
{
|
|
ADC_EnableHardwareTrigger(base, true);
|
|
}
|
|
#endif
|
|
|
|
return status;
|
|
}
|
|
|
|
void ADC_SetOffsetConfig(ADC_Type *base, const adc_offest_config_t *config)
|
|
{
|
|
assert(NULL != config);
|
|
|
|
uint32_t tmp32;
|
|
|
|
tmp32 = ADC_OFS_OFS(config->offsetValue);
|
|
if (config->enableSigned)
|
|
{
|
|
tmp32 |= ADC_OFS_SIGN_MASK;
|
|
}
|
|
base->OFS = tmp32;
|
|
}
|
|
|
|
void ADC_SetHardwareCompareConfig(ADC_Type *base, const adc_hardware_compare_config_t *config)
|
|
{
|
|
uint32_t tmp32;
|
|
|
|
tmp32 = base->GC & ~(ADC_GC_ACFE_MASK | ADC_GC_ACFGT_MASK | ADC_GC_ACREN_MASK);
|
|
if (NULL == config) /* Pass "NULL" to disable the feature. */
|
|
{
|
|
base->GC = tmp32;
|
|
return;
|
|
}
|
|
/* Enable the feature. */
|
|
tmp32 |= ADC_GC_ACFE_MASK;
|
|
|
|
/* Select the hardware compare working mode. */
|
|
switch (config->hardwareCompareMode)
|
|
{
|
|
case kADC_HardwareCompareMode0:
|
|
break;
|
|
case kADC_HardwareCompareMode1:
|
|
tmp32 |= ADC_GC_ACFGT_MASK;
|
|
break;
|
|
case kADC_HardwareCompareMode2:
|
|
tmp32 |= ADC_GC_ACREN_MASK;
|
|
break;
|
|
case kADC_HardwareCompareMode3:
|
|
tmp32 |= ADC_GC_ACFGT_MASK | ADC_GC_ACREN_MASK;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
base->GC = tmp32;
|
|
|
|
/* Load the compare values. */
|
|
tmp32 = ADC_CV_CV1(config->value1) | ADC_CV_CV2(config->value2);
|
|
base->CV = tmp32;
|
|
}
|
|
|
|
void ADC_SetHardwareAverageConfig(ADC_Type *base, adc_hardware_average_mode_t mode)
|
|
{
|
|
uint32_t tmp32;
|
|
|
|
if (mode == kADC_HardwareAverageDiasable)
|
|
{
|
|
base->GC &= ~ADC_GC_AVGE_MASK;
|
|
}
|
|
else
|
|
{
|
|
tmp32 = base->CFG & ~ADC_CFG_AVGS_MASK;
|
|
tmp32 |= ADC_CFG_AVGS(mode);
|
|
base->CFG = tmp32;
|
|
base->GC |= ADC_GC_AVGE_MASK; /* Enable the hardware compare. */
|
|
}
|
|
}
|
|
|
|
void ADC_ClearStatusFlags(ADC_Type *base, uint32_t mask)
|
|
{
|
|
uint32_t tmp32 = 0;
|
|
|
|
if (0U != (mask & kADC_CalibrationFailedFlag))
|
|
{
|
|
tmp32 |= ADC_GS_CALF_MASK;
|
|
}
|
|
if (0U != (mask & kADC_ConversionActiveFlag))
|
|
{
|
|
tmp32 |= ADC_GS_ADACT_MASK;
|
|
}
|
|
base->GS = tmp32;
|
|
}
|