void AdcDacStartSynchro(uint32_t period, uint16_t amplitude)
{
if(g_adcStatus==1)
AdcStop();//Потенциально здесь может все зависнуть, если цикл внутри AdcQuant не завершился
//for(int i=0;i<RESULT_BUFFER_SIZE;i++)
// g_resultBuffer[i]=0x00080008;
g_cur_cycle = 0;
LcdRepaint();
DacSetPeriod(period, amplitude);
AdcRoundSize(DacSamplesPerPeriod());
AdcStartPre();
USBAdd32(DacPeriod());
USBAdd32(SystemCoreClock);
USBAdd32(DacSamplesPerPeriod());
ADC_StartConversion(ADC3);
ADC_StartConversion(ADC4);
g_adc_elapsed_time = 0;
StartTimer();
TIM_Cmd(TIM2, ENABLE); //Start DAC
}
void TIM2_IRQHandler (void)
{
static uint8_t oversamp = 0;
static int32_t average = 0;
static int32_t oversampout = 0;
if (TIM_GetITStatus (TIM2, TIM_IT_Update) != RESET) {
TIM_ClearITPendingBit (TIM2, TIM_IT_Update);
int16_t value = ADC_GetConversionValue(ADC4);
ADC_StartConversion( ADC4 );
oversampout += value;
oversamp++;
if( oversamp >= ADCOVERSAMP )
{
value = oversampout / ADCOVERSAMP;
average = ((average*1023) + (value*1024))/1024;
value = value-(average/1024);
oversamp = 0;
ADCCallback( value );
oversampout = 0;
}
}
}
void pot_init(void) {
//sets up interrupts to trigger on every sucessful conversion
IRQ_ConfigureIT(AT91C_ID_ADC, 0, ISR_ADC);
//initilize ADC
ADC_Initialize(AT91C_BASE_ADC,
AT91C_ID_ADC,
AT91C_ADC_TRGEN_DIS,
0,
AT91C_ADC_SLEEP_NORMAL_MODE,
AT91C_ADC_LOWRES_10_BIT,
BOARD_MCK,
BOARD_ADC_FREQ,
10,
1200);
ADC_EnableDataReadyIt(AT91C_BASE_ADC);
ADC_EnableChannel(AT91C_BASE_ADC, POT_CHANNEL);
IRQ_EnableIT(AT91C_ID_ADC);
ADC_EnableIt(AT91C_BASE_ADC, POT_CHANNEL);
//Starts the adc
ADC_StartConversion(AT91C_BASE_ADC);
}
void UpdateAnalogs(void)
{
ADC_StartConversion(AT91C_BASE_ADC1);
while((ADC_GetStatus(AT91C_BASE_ADC1) & 0x80) != 0x80) nop();
//g_AnalogReading[0] = ADC_GetConvertedData(AT91C_BASE_ADC1,0);
g_AnalogReading[1] = ADC_GetConvertedData(AT91C_BASE_ADC1,1);
g_AnalogReading[2] = ADC_GetConvertedData(AT91C_BASE_ADC1,2);
g_AnalogReading[3] = ADC_GetConvertedData(AT91C_BASE_ADC1,3);
g_AnalogReading[4] = ADC_GetConvertedData(AT91C_BASE_ADC1,4);
g_AnalogReading[5] = ADC_GetConvertedData(AT91C_BASE_ADC1,5);
g_AnalogReading[6] = ADC_GetConvertedData(AT91C_BASE_ADC1,6);
g_AnalogReading[7] = ADC_GetConvertedData(AT91C_BASE_ADC1,7);
switch(g_BatteryCounter) {
case 0:
g_AnalogReading[0] = ADC_GetConvertedData(AT91C_BASE_ADC1, 0);
SelectBattV();
break;
case 1:
CalculateBatteryPower(ADC_GetConvertedData(AT91C_BASE_ADC1, 0));
SelectAng0();
break;
case BATTV_PERIOD:
g_BatteryCounter = -1;
default:
g_AnalogReading[0] = ADC_GetConvertedData(AT91C_BASE_ADC1, 0);
}
g_BatteryCounter++;
}
void Temp_Read()
{
//Set the ADC interupt to start to fill in the Battery ADC Buffer
ADC_Buffer_Point = 0;
Temp_Aquire = 1;
ADCON1 = 0x80; //Set up to run ADC from VDD to VSS
ADC_StartConversion(Temp1);
}
inline void TSL_DualAnalogRead(int32_t *ADC1_Value, int32_t *ADC2_Value)
{
ADC_StartConversion(ADC1);
while(ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET); /* Wait for ADC to be ready */
*ADC1_Value = ADC_GetDualModeConversionValue(ADC1); /* Both ADC values stored in single uint32_t */
*ADC2_Value = (uint32_t)(((uint32_t)*ADC1_Value) & 0x0000FFFF); /* ADC2 value stored in lower 16 bits */
*ADC1_Value = (uint32_t)(((uint32_t)*ADC1_Value) & 0xFFFF0000); /* ADC1 value stored in upper 16 bits */
}
void AGE_InitAnalogSensor()
{
ADC_InitTypeDef ADC_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
ADC_CommonInitTypeDef ADC_CommonInitStructure;
//init of the ADC2 Ch1 GPIO A4
//used as position sensor
/* Configure the ADC clock */
RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div2);
/* Enable ADC12 clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC12, ENABLE);
/* ADC Channel configuration */
/* GPIOC Periph clock enable */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
#warning AEG.4
//** mettere il pin corretto affinché l'adc acquisisca dal canale ADC2_CH2 (pin A5)
//** decommentare le riche di codice di inizializzazione avendo cura di mettere l'ADC corretta
/* Configure ADC Channel2 as analog input */
GPIO_InitStructure.GPIO_Pin = 0xFF ;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;
GPIO_Init(GPIOA, &GPIO_InitStructure);
ADC_StructInit(&ADC_InitStructure);
ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_CommonInitStructure.ADC_Clock = ADC_Clock_AsynClkMode;
ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled;
ADC_CommonInitStructure.ADC_DMAMode = ADC_DMAMode_OneShot;
ADC_CommonInitStructure.ADC_TwoSamplingDelay = 0;
//** ADC_CommonInit(/* ADC */, &ADC_CommonInitStructure);
ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Enable;
ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_0;
ADC_InitStructure.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_OverrunMode = ADC_OverrunMode_Disable;
ADC_InitStructure.ADC_AutoInjMode = ADC_AutoInjec_Disable;
ADC_InitStructure.ADC_NbrOfRegChannel = 1;
//** ADC_Init(/* ADC */, &ADC_InitStructure);
/* ADC2 regular channel configuration */
//** ADC_RegularChannelConfig(/* ADC */, ADC_Channel_2, 1, ADC_SampleTime_7Cycles5);
/* Enable ADC2 */
//** ADC_Cmd(/* ADC */, ENABLE);
/* wait for ADRDY */
while(!ADC_GetFlagStatus(ADC2, ADC_FLAG_RDY));
ADC_StartConversion(ADC2);
}
void start_ADC(void) {
if(driver_stat.statusAdc != HALT_ADC)
orders_to_stop();
ADC_Cmd(ADC1, ENABLE);
ADC_Cmd(ADC2, ENABLE);
ADC_Cmd(ADC3, ENABLE);
ADC_Cmd(ADC4, ENABLE);
while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_RDY) && !ADC_GetFlagStatus(ADC2, ADC_FLAG_RDY)
&& !ADC_GetFlagStatus(ADC3, ADC_FLAG_RDY) && !ADC_GetFlagStatus(ADC4, ADC_FLAG_RDY));
ADC_StartConversion(ADC1);
ADC_StartConversion(ADC2);
ADC_StartConversion(ADC3);
ADC_StartConversion(ADC4);
initial_tim8();
driver_stat.statusAdc = RUN_ADC;
TIM_Cmd(TIM8, ENABLE);
return;
}
uint16_t ADConverter::read(ADCDevice_e device) {
// todo check SetInputChannel method
// ADC_SetInputChannel(ADC_Input_ADC1);
// ADMUX &= 0xF0; //Clear the older channel that was read
reg::admux::reg_and(0xF0);
// ADMUX |= device; //Defines the new ADC channel to be read
reg::admux::reg_or(device);
ADC_StartConversion();
while (ADC_ConversionInProgress()) {
}
return ADC_GetDataRegister();
}
void ds_therm_init(void) {
//Initialization
RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div2);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC12, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOF, ENABLE);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOF, &GPIO_InitStructure);
//Enable the ADC’s voltage regulator and wait for it to stabilize
ADC_VoltageRegulatorCmd(ADC1, ENABLE);
ADC_TempSensorCmd(ADC1, ENABLE);
ds_delay_uS(10);
//Initialize the parameters that are common to all of the A2D Channels
ADC_CommonInitTypeDef ADC_CommonInitStructure;
ADC_CommonStructInit(&ADC_CommonInitStructure);
ADC_CommonInitStructure.ADC_Mode=ADC_Mode_Independent;
ADC_CommonInitStructure.ADC_Clock = ADC_Clock_AsynClkMode;
ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled;
ADC_CommonInitStructure.ADC_DMAMode = ADC_DMAMode_OneShot;
ADC_CommonInitStructure.ADC_TwoSamplingDelay = 0;
ADC_CommonInit(ADC1, &ADC_CommonInitStructure);
//Initialize the parameters specific to channel 10
ADC_InitTypeDef ADC_InitStructure;
ADC_StructInit(&ADC_InitStructure);
ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Enable;
ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_0;
ADC_InitStructure.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_OverrunMode = ADC_OverrunMode_Disable;
ADC_InitStructure.ADC_AutoInjMode = ADC_AutoInjec_Disable;
ADC_InitStructure.ADC_NbrOfRegChannel = 1;
ADC_Init(ADC1, &ADC_InitStructure);
//Configure the specific ADC, channel, and timing
ADC_RegularChannelConfig(ADC1, ADC_Channel_16, 1, ADC_SampleTime_7Cycles5);
//Enable the ADC and wait for it to become ready.
ADC_Cmd(ADC1, ENABLE);
while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_RDY));
//Start the first conversion
ADC_StartConversion(ADC1);
}
/* Start new single conversion and get the ADC value. Blocking routine. */
unsigned short ADC_GetValue(unsigned char n_channel)
{
unsigned short buf;
/* Start new ADC conversion in single mode */
ADC_StartConversion(ADC_SINGLE_MODE, n_channel);
/* Waiting last conversion is finished */
while (IS_CONVERTION_RUNNING) {
;
}
buf = ADCL;
buf = (ADCH << 8)|(buf);
return buf;
}
static void ISR_ADC(void) {
int status = ADC_GetStatus(AT91C_BASE_ADC);
char_display_number(33);
if (ADC_IsChannelInterruptStatusSet(status, POT_CHANNEL)) {
//gets the new value from ADC
pot_current_value = ADC_GetConvertedData(AT91C_BASE_ADC, POT_CHANNEL);
char_display_number((pot_current_value - 25) / 10);
//char_display_number(44);
//starts the converter running again
ADC_StartConversion(AT91C_BASE_ADC);
}
}
void VBatQuant()
{
/* Start ADC2 Software Conversion */
/* Test EOC flag */
while(ADC_GetFlagStatus(ADC2, ADC_FLAG_EOC) == RESET);
/* Get ADC2 converted data */
int adcValue = ADC_GetConversionValue(ADC2);
//Не задерживаем вывод на экран. Батарейка все равно медленно разряжается, поэтому показываем старое значение
ADC_StartConversion(ADC2);
const int Vup = 3080;//6.2 V
const int Vdown = 2730;//5.5 V
int value = 0;
//Vup->6.5 Vdown->0
value = adcValue-Vdown;
if(value<0)
value = 0;
value = (value*65)/(10*(Vup-Vdown));
//Draw battery
byte x0 = 63, y0 = 0;
LcdLine(x0, x0, y0+1, y0+7, PIXEL_ON );
LcdLine(x0+1, x0+3, y0+1, y0+1, PIXEL_ON );
LcdLine(x0+1, x0+3, y0+7, y0+7, PIXEL_ON );
LcdLine(x0+3, x0+3, y0+1, y0+0, PIXEL_ON );
LcdLine(x0+3, x0+3, y0+7, y0+8, PIXEL_ON );
LcdLine(x0+3, x0+19, y0+0, y0+0, PIXEL_ON );
LcdLine(x0+3, x0+19, y0+8, y0+8, PIXEL_ON );
LcdLine(x0+20, x0+20, y0+0, y0+8, PIXEL_ON );
if(value>5)
LcdSingleBar( x0+2, y0+3+3, 3, 2, PIXEL_ON );
for(byte i=0; i<5; i++)
{
if(value>4-i)
LcdSingleBar( x0+5+i*3, y0+3+4, 5, 2, PIXEL_ON );
}
}
void battery_init(void) {
GPIO_InitTypeDef gpio_init;
ADC_InitTypeDef adc_init;
ADC_CommonInitTypeDef adc_common_init;
RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div2);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC12, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE);
gpio_init.GPIO_Pin = GPIO_Pin_1;
gpio_init.GPIO_Mode = GPIO_Mode_AN;
gpio_init.GPIO_PuPd = GPIO_PuPd_NOPULL;
GPIO_Init(GPIOC, &gpio_init);
ADC_StructInit(&adc_init);
ADC_VoltageRegulatorCmd(ADC1, ENABLE);
/* Calibrate ADC */
ADC_SelectCalibrationMode(ADC1, ADC_CalibrationMode_Single);
ADC_StartCalibration(ADC1);
while (ADC_GetCalibrationStatus(ADC1) != RESET);
/* calibration_value = ADC_GetCalibrationValue(ADC1); */
adc_common_init.ADC_Mode = ADC_Mode_Independent;
adc_common_init.ADC_Clock = ADC_Clock_AsynClkMode;
adc_common_init.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled;
adc_common_init.ADC_DMAMode = ADC_DMAMode_OneShot;
adc_common_init.ADC_TwoSamplingDelay = 0;
ADC_CommonInit(ADC1, &adc_common_init);
adc_init.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Enable;
adc_init.ADC_Resolution = ADC_Resolution_12b;
adc_init.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_0;
adc_init.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_None;
adc_init.ADC_DataAlign = ADC_DataAlign_Right;
adc_init.ADC_OverrunMode = ADC_OverrunMode_Disable;
adc_init.ADC_AutoInjMode = ADC_AutoInjec_Disable;
adc_init.ADC_NbrOfRegChannel = 1;
ADC_Init(ADC1, &adc_init);
ADC_RegularChannelConfig(ADC1, ADC_Channel_7, 1, ADC_SampleTime_7Cycles5);
ADC_Cmd(ADC1, ENABLE);
while (!ADC_GetFlagStatus(ADC1, ADC_FLAG_RDY));
ADC_StartConversion(ADC1);
}
int analogRead(uint8_t pin)
{
#if defined( CORE_ANALOG_FIRST )
if ( pin >= CORE_ANALOG_FIRST ) pin -= CORE_ANALOG_FIRST; // allow for channel or pin numbers
#endif
// fix? Validate pin?
ADC_SetVoltageReference( analog_reference );
ADC_SetInputChannel( pin );
ADC_StartConversion();
while( ADC_ConversionInProgress() );
return( ADC_GetDataRegister() );
}
//
// HTRIM ISR:
//
void HRTIM1_TIMB_IRQHandler(void)
{
#if BOOST_CTL_TYPE == 1
if(true != inSoftStart)
{
//Roda a malha de controle:
DigitalPowerLoopFunc();
//Satura:
DigitalPowerSaturate();
if(output < 0.0f) output = 0.0f;
//Prepara o dutycicle para correcao no proximo ciclo:
dutyCicle = MAP_TO_PWM(output);
}
else
{
//
// Se o flag de subida suave estiver ativo, ignora a malha de
// controle:
//
dutyCicle += BOOST_SOFT_START_PWM_INC;
if(dutyCicle > BOOST_SOFT_START_PWM_VAL)
{
inSoftStart = false;
}
}
#endif
//Dispara a leitura do conversor A/D:
ADC_StartConversion(ADC1);
//Atualiza novo DutyCicle calculado previamente:
Boost_HW_SetDutyCicle(dutyCicle);
//Limpa o flag de interrupcao:
HRTIM_ClearITPendingBit(HRTIM1, 0x01, 0xFFFFFFFF);
}
/*
实验名称：PIT触发ADC
实验平台：渡鸦开发板
板载芯片：MK60DN512ZVQ10
实验效果：使用PIT模块周期性的触发ADC模块进行数据采集
通过调节开发板上的电位器，可以更改ad采集结果
*/
int main(void)
{
DelayInit();
GPIO_QuickInit(HW_GPIOE, 6, kGPIO_Mode_OPP);
UART_QuickInit(UART0_RX_PD06_TX_PD07, 115200);
printf("PIT tirgger ADC test\r\n");
/* 配置ADC0 硬件触发源 */
SIM->SOPT7 |= SIM_SOPT7_ADC0TRGSEL(4); /* 使用PIT0 触发 */
SIM->SOPT7 &= ~SIM_SOPT7_ADC0PRETRGSEL_MASK; /* 使用trigger A */
SIM->SOPT7 |= SIM_SOPT7_ADC0ALTTRGEN_MASK; /*使用除PDB之外的硬件触发源 此触发源可能因芯片而异*/
/* 初始化ADC模块 ADC0_SE19_DM0 */
ADC_InitTypeDef AD_InitStruct1;
AD_InitStruct1.instance = HW_ADC0;
AD_InitStruct1.clockDiv = kADC_ClockDiv2; /* ADC采样时钟2分频 */
AD_InitStruct1.resolutionMode = kADC_SingleDiff10or11; /*单端 10位精度 查分 11位精度 */
AD_InitStruct1.triggerMode = kADC_TriggerHardware; /* 硬件触发转换 */
AD_InitStruct1.singleOrDiffMode = kADC_Single; /*单端模式 */
AD_InitStruct1.continueMode = kADC_ContinueConversionDisable;
AD_InitStruct1.hardwareAveMode = kADC_HardwareAverageDisable; /*禁止 硬件平均 功能 */
ADC_Init(&AD_InitStruct1);
/* 初始化对应引脚 */
/* DM0引脚为专门的模拟引脚 ADC时 无需设置复用 DM0也无法当做普通的数字引脚 */
/* 启动一次ADC转换 填入通道值*/
ADC_StartConversion(HW_ADC0, 19, kADC_MuxA);
/* 初始化 PIT模块 */
PIT_QuickInit(HW_PIT_CH0, 1000*200); /* 200 ms 触发一次 */
while(1)
{
/* 如果ADC转换完成 读取转换结果*/
if(ADC_IsConversionCompleted(HW_ADC0, kADC_MuxA) == 0)
{
printf("ADC:%04d\r", ADC_ReadValue(HW_ADC0, kADC_MuxA));
}
}
}
int main(void)
{
DelayInit();
GPIO_QuickInit(HW_GPIOE, 6, kGPIO_Mode_OPP);
UART_QuickInit(UART0_RX_PD06_TX_PD07, 115200);
printf("ADC test\r\n");
/* 初始化ADC模块 ADC0_SE19_DM0 */
ADC_InitTypeDef ADC_InitStruct1; //申请一个结构体
ADC_InitStruct1.instance = HW_ADC0; //使用ADC0模块
ADC_InitStruct1.clockDiv = kADC_ClockDiv8; /* ADC采样时钟2分频 */
ADC_InitStruct1.resolutionMode = kADC_SingleDiff10or11; //设置10位或11位精度
ADC_InitStruct1.triggerMode = kADC_TriggerSoftware; /* 软件触发转换 */
ADC_InitStruct1.singleOrDiffMode = kADC_Single; /*单端模式 */
ADC_InitStruct1.continueMode = kADC_ContinueConversionEnable; /* 启动连续转换 转换一次后 自动开始下一次转换*/
ADC_InitStruct1.hardwareAveMode = kADC_HardwareAverage_32; /*禁止 硬件平均 功能 */
ADC_InitStruct1.vref = kADC_VoltageVREF; /* 使用外部VERFH VREFL 作为模拟电压参考 */
ADC_Init(&ADC_InitStruct1);
/* 开启转换完成中断配置 */
ADC_CallbackInstall(HW_ADC0, ADC_ISR);
ADC_ITDMAConfig(HW_ADC0, kADC_MuxA, kADC_IT_EOF);
/* 初始化对应引脚 */
/* DM0引脚为专门的模拟引脚 ADC时 无需设置复用 DM0也无法当做普通的数字引脚 */
/* 启动ADC转换 */
ADC_StartConversion(HW_ADC0, 19, kADC_MuxA);
while(1)
{
printf("ADC:%4d\r", ADC_Value);
GPIO_ToggleBit(HW_GPIOE, 6);
DelayMs(50);
}
}
void InitADC()
{
ADC_InitTypeDef ADC_InitStructure;
ADC_CommonInitTypeDef ADC_CommonInitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
TIM_TimeBaseInitTypeDef TIM_TimeBaseStructure;
/* Configure the ADC clock */
RCC_ADCCLKConfig( RCC_ADC34PLLCLK_Div2 );
/* Enable ADC1 clock */
RCC_AHBPeriphClockCmd( RCC_AHBPeriph_ADC34, ENABLE );
/* ADC Channel configuration */
/* GPIOC Periph clock enable */
RCC_AHBPeriphClockCmd( RCC_AHBPeriph_GPIOB, ENABLE );
/* Configure ADC Channel7 as analog input */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;
GPIO_Init( GPIOB, &GPIO_InitStructure );
ADC_StructInit( &ADC_InitStructure );
/* Calibration procedure */
ADC_VoltageRegulatorCmd( ADC4, ENABLE );
/* Insert delay equal to 10 µs */
_delay_us( 10 );
ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_CommonInitStructure.ADC_Clock = ADC_Clock_AsynClkMode;
ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled;
ADC_CommonInitStructure.ADC_DMAMode = ADC_DMAMode_OneShot;
ADC_CommonInitStructure.ADC_TwoSamplingDelay = 0;
ADC_CommonInit( ADC4, &ADC_CommonInitStructure );
ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Enable;
ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_0;
ADC_InitStructure.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_OverrunMode = ADC_OverrunMode_Disable;
ADC_InitStructure.ADC_AutoInjMode = ADC_AutoInjec_Disable;
ADC_InitStructure.ADC_NbrOfRegChannel = 1;
ADC_Init( ADC4, &ADC_InitStructure );
/* ADC4 regular channel3 configuration */
ADC_RegularChannelConfig( ADC4, ADC_Channel_3, 1, ADC_SampleTime_181Cycles5 );
/* Enable ADC4 */
ADC_Cmd( ADC4, ENABLE );
/* wait for ADRDY */
while( !ADC_GetFlagStatus( ADC4, ADC_FLAG_RDY ) );
NVIC_InitTypeDef NVIC_InitStructure;
/* Enable the TIM2 gloabal Interrupt */
NVIC_InitStructure.NVIC_IRQChannel = TIM2_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 1;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init (&NVIC_InitStructure);
/* TIM2 clock enable */
RCC_APB1PeriphClockCmd (RCC_APB1Periph_TIM2, ENABLE);
/* Time base configuration */
RCC->CFGR |= 0X1400;
TIM_TimeBaseStructure.TIM_Period = (RCC_Clocks.HCLK_Frequency/(ADCFS*ADCOVERSAMP)) - 1;
TIM_TimeBaseStructure.TIM_Prescaler = 1 - 1; // Operate at clock frequency
TIM_TimeBaseStructure.TIM_ClockDivision = 0;
TIM_TimeBaseStructure.TIM_CounterMode = TIM_CounterMode_Up;
TIM_TimeBaseInit (TIM2, &TIM_TimeBaseStructure);
/* TIM IT enable */
TIM_ITConfig (TIM2, TIM_IT_Update, ENABLE);
/* TIM2 enable counter */
TIM_Cmd (TIM2, ENABLE);
/* Start ADC4 Software Conversion */
ADC_StartConversion( ADC4 );
}
void adcInit(void)
{
ADC_CommonInitTypeDef ADC_CommonInitStructure;
ADC_InitTypeDef ADC_InitStructure;
DMA_InitTypeDef DMA_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
ADC_CommonStructInit(&ADC_CommonInitStructure);
ADC_StructInit(&ADC_InitStructure);
DMA_StructInit(&DMA_InitStructure);
GPIO_StructInit(&GPIO_InitStructure);
///////////////////////////////////
RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div256); // 72 MHz divided by 256 = 281.25 kHz
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC12, ENABLE);
///////////////////////////////////
DMA_DeInit(DMA1_Channel1);
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&ADC1->DR;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)adc1ConvertedValues;
//DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = 2;
//DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
//DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel1, &DMA_InitStructure);
DMA_Cmd(DMA1_Channel1, ENABLE);
///////////////////////////////////
GPIO_InitStructure.GPIO_Pin = VBATT_PIN | DIFF_PRESSURE_PIN;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
//GPIO_InitStructure.GPIO_Speed = GPIO_Speed_2MHz;
//GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
//GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;
GPIO_Init(GPIOC, &GPIO_InitStructure);
///////////////////////////////////
ADC_VoltageRegulatorCmd(ADC1, ENABLE);
delay(10);
ADC_SelectCalibrationMode(ADC1, ADC_CalibrationMode_Single);
ADC_StartCalibration(ADC1);
while(ADC_GetCalibrationStatus(ADC1) != RESET );
///////////////////////////////////
//ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;
//ADC_CommonInitStructure.ADC_Clock = ADC_Clock_AsynClkMode;
//ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled;
ADC_CommonInitStructure.ADC_DMAMode = ADC_DMAMode_Circular;
//ADC_CommonInitStructure.ADC_TwoSamplingDelay = 0;
ADC_CommonInit(ADC1, &ADC_CommonInitStructure);
///////////////////////////////////
ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Enable;
//ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
//ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_0;
//ADC_InitStructure.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_None;
//ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
//ADC_InitStructure.ADC_OverrunMode = DISABLE;
//ADC_InitStructure.ADC_AutoInjMode = DISABLE;
ADC_InitStructure.ADC_NbrOfRegChannel = 2;
ADC_Init(ADC1, &ADC_InitStructure);
///////////////////////////////////
ADC_RegularChannelConfig(ADC1, VBATT_CHANNEL, 1, ADC_SampleTime_181Cycles5);
ADC_RegularChannelConfig(ADC1, DIFF_PRESSURE_CHANNEL, 2, ADC_SampleTime_181Cycles5);
ADC_Cmd(ADC1, ENABLE);
while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_RDY));
ADC_DMAConfig(ADC1, ADC_DMAMode_Circular);
ADC_DMACmd(ADC1, ENABLE);
ADC_StartConversion(ADC1);
}
void adcInit(const adcConfig_t *config)
{
ADC_InitTypeDef ADC_InitStructure;
DMA_InitTypeDef DMA_InitStructure;
uint8_t adcChannelCount = 0;
memset(&adcOperatingConfig, 0, sizeof(adcOperatingConfig));
if (config->vbat.enabled) {
adcOperatingConfig[ADC_BATTERY].tag = config->vbat.ioTag;
}
if (config->rssi.enabled) {
adcOperatingConfig[ADC_RSSI].tag = config->rssi.ioTag; //RSSI_ADC_CHANNEL;
}
if (config->external1.enabled) {
adcOperatingConfig[ADC_EXTERNAL1].tag = config->external1.ioTag; //EXTERNAL1_ADC_CHANNEL;
}
if (config->current.enabled) {
adcOperatingConfig[ADC_CURRENT].tag = config->current.ioTag; //CURRENT_METER_ADC_CHANNEL;
}
ADCDevice device = adcDeviceByInstance(ADC_INSTANCE);
if (device == ADCINVALID)
return;
#ifdef ADC24_DMA_REMAP
SYSCFG_DMAChannelRemapConfig(SYSCFG_DMARemap_ADC2ADC4, ENABLE);
#endif
adcDevice_t adc = adcHardware[device];
bool adcActive = false;
for (int i = 0; i < ADC_CHANNEL_COUNT; i++) {
if (!adcVerifyPin(adcOperatingConfig[i].tag, device)) {
continue;
}
adcActive = true;
IOInit(IOGetByTag(adcOperatingConfig[i].tag), OWNER_ADC_BATT + i, 0);
IOConfigGPIO(IOGetByTag(adcOperatingConfig[i].tag), IO_CONFIG(GPIO_Mode_AN, 0, GPIO_OType_OD, GPIO_PuPd_NOPULL));
adcOperatingConfig[i].adcChannel = adcChannelByTag(adcOperatingConfig[i].tag);
adcOperatingConfig[i].dmaIndex = adcChannelCount++;
adcOperatingConfig[i].sampleTime = ADC_SampleTime_601Cycles5;
adcOperatingConfig[i].enabled = true;
}
if (!adcActive) {
return;
}
if ((device == ADCDEV_1) || (device == ADCDEV_2)) {
// enable clock for ADC1+2
RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div256); // 72 MHz divided by 256 = 281.25 kHz
} else {
// enable clock for ADC3+4
RCC_ADCCLKConfig(RCC_ADC34PLLCLK_Div256); // 72 MHz divided by 256 = 281.25 kHz
}
RCC_ClockCmd(adc.rccADC, ENABLE);
dmaInit(dmaGetIdentifier(adc.DMAy_Channelx), OWNER_ADC, 0);
DMA_DeInit(adc.DMAy_Channelx);
DMA_StructInit(&DMA_InitStructure);
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&adc.ADCx->DR;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)adcValues;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = adcChannelCount;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = adcChannelCount > 1 ? DMA_MemoryInc_Enable : DMA_MemoryInc_Disable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(adc.DMAy_Channelx, &DMA_InitStructure);
DMA_Cmd(adc.DMAy_Channelx, ENABLE);
// calibrate
ADC_VoltageRegulatorCmd(adc.ADCx, ENABLE);
delay(10);
ADC_SelectCalibrationMode(adc.ADCx, ADC_CalibrationMode_Single);
ADC_StartCalibration(adc.ADCx);
while (ADC_GetCalibrationStatus(adc.ADCx) != RESET);
ADC_VoltageRegulatorCmd(adc.ADCx, DISABLE);
ADC_CommonInitTypeDef ADC_CommonInitStructure;
ADC_CommonStructInit(&ADC_CommonInitStructure);
ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_CommonInitStructure.ADC_Clock = ADC_Clock_SynClkModeDiv4;
ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_1;
ADC_CommonInitStructure.ADC_DMAMode = ADC_DMAMode_Circular;
ADC_CommonInitStructure.ADC_TwoSamplingDelay = 0;
ADC_CommonInit(adc.ADCx, &ADC_CommonInitStructure);
ADC_StructInit(&ADC_InitStructure);
ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Enable;
ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_0;
ADC_InitStructure.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_OverrunMode = ADC_OverrunMode_Disable;
ADC_InitStructure.ADC_AutoInjMode = ADC_AutoInjec_Disable;
ADC_InitStructure.ADC_NbrOfRegChannel = adcChannelCount;
ADC_Init(adc.ADCx, &ADC_InitStructure);
uint8_t rank = 1;
for (int i = 0; i < ADC_CHANNEL_COUNT; i++) {
if (!adcOperatingConfig[i].enabled) {
continue;
}
ADC_RegularChannelConfig(adc.ADCx, adcOperatingConfig[i].adcChannel, rank++, adcOperatingConfig[i].sampleTime);
}
ADC_Cmd(adc.ADCx, ENABLE);
while (!ADC_GetFlagStatus(adc.ADCx, ADC_FLAG_RDY));
ADC_DMAConfig(adc.ADCx, ADC_DMAMode_Circular);
ADC_DMACmd(adc.ADCx, ENABLE);
ADC_StartConversion(adc.ADCx);
}
static inline uint16_t adc_read(analogin_t *obj) {
// Get ADC registers structure address
ADC_TypeDef *adc = (ADC_TypeDef *)(obj->adc);
uint8_t channel = 0;
// Configure ADC channel
switch (obj->pin) {
case PA_0:
channel = ADC_Channel_1;
break;
case PA_1:
channel = ADC_Channel_2;
break;
case PA_2:
channel = ADC_Channel_3;
break;
case PA_3:
channel = ADC_Channel_4;
break;
case PA_4:
channel = ADC_Channel_5;
break;
case PC_0:
channel = ADC_Channel_6;
break;
case PC_1:
channel = ADC_Channel_7;
break;
case PC_2:
channel = ADC_Channel_8;
break;
case PC_3:
channel = ADC_Channel_9;
break;
case PA_6:
channel = ADC_Channel_10;
break;
case PB_0:
channel = ADC_Channel_11;
break;
case PB_1:
channel = ADC_Channel_12;
break;
case PB_13:
channel = ADC_Channel_13;
break;
case PB_11:
channel = ADC_Channel_14;
break;
case PA_7:
channel = ADC_Channel_15;
break;
default:
return 0;
}
ADC_RegularChannelConfig(adc, channel, 1, ADC_SampleTime_7Cycles5);
ADC_StartConversion(adc); // Start conversion
while (ADC_GetFlagStatus(adc, ADC_FLAG_EOC) == RESET); // Wait end of conversion
return (ADC_GetConversionValue(adc)); // Get conversion value
}
u16 adc_read(u32 ch)
{
u16 res = 0;
ADC_TypeDef* ADCx;
uint8_t ADC_Channel;
switch (ch)
{
case ADC0_CH:
ADCx = ADC1;
ADC_Channel = ADC_Channel_1;
break;
case ADC1_CH:
ADCx = ADC1;
ADC_Channel = ADC_Channel_2;
break;
case ADC2_CH:
ADCx = ADC1;
ADC_Channel = ADC_Channel_3;
break;
case ADC3_CH:
ADCx = ADC1;
ADC_Channel = ADC_Channel_4;
break;
case ADC4_CH:
ADCx = ADC2;
ADC_Channel = ADC_Channel_1;
break;
case ADC5_CH:
ADCx = ADC2;
ADC_Channel = ADC_Channel_2;
break;
case ADC6_CH:
ADCx = ADC2;
ADC_Channel = ADC_Channel_3;
break;
case ADC7_CH:
ADCx = ADC2;
ADC_Channel = ADC_Channel_4;
break;
case ADC8_CH:
ADCx = ADC3;
ADC_Channel = ADC_Channel_12;
break;
default:
ADCx = ADC1;
ADC_Channel = ADC_Channel_1;
break;
}
ADC_RegularChannelConfig( ADCx, ADC_Channel, 1, ADC_SampleTime_1Cycles5);
//ADC_SampleTime_7Cycles5 );
// ADC_RegularChannelConfig( ADCx, ADC_Channel_13, 1, ADC_SampleTime_3Cycles);
//Start ADCx Software Conversion
ADC_StartConversion(ADCx);
// Wait until conversion completion
while(ADC_GetFlagStatus(ADCx, ADC_FLAG_EOC) == RESET)
__asm("nop");
res = ADC_GetConversionValue(ADCx);
return res;
}
void adcInit(drv_adc_config_t *init)
{
ADC_InitTypeDef ADC_InitStructure;
DMA_InitTypeDef DMA_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
uint8_t i;
uint8_t adcChannelCount = 0;
memset(&adcConfig, 0, sizeof(adcConfig));
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_3;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;
adcConfig[ADC_BATTERY].adcChannel = ADC_Channel_6;
adcConfig[ADC_BATTERY].dmaIndex = adcChannelCount;
adcConfig[ADC_BATTERY].sampleTime = ADC_SampleTime_601Cycles5;
adcConfig[ADC_BATTERY].enabled = true;
adcChannelCount++;
if (init->enableCurrentMeter) {
GPIO_InitStructure.GPIO_Pin |= GPIO_Pin_1;
adcConfig[ADC_CURRENT].adcChannel = ADC_Channel_7;
adcConfig[ADC_CURRENT].dmaIndex = adcChannelCount;
adcConfig[ADC_CURRENT].sampleTime = ADC_SampleTime_601Cycles5;
adcConfig[ADC_CURRENT].enabled = true;
adcChannelCount++;
}
if (init->enableRSSI) {
GPIO_InitStructure.GPIO_Pin |= GPIO_Pin_2;
adcConfig[ADC_RSSI].adcChannel = ADC_Channel_8;
adcConfig[ADC_RSSI].dmaIndex = adcChannelCount;
adcConfig[ADC_RSSI].sampleTime = ADC_SampleTime_601Cycles5;
adcConfig[ADC_RSSI].enabled = true;
adcChannelCount++;
}
adcConfig[ADC_EXTERNAL1].adcChannel = ADC_Channel_9;
adcConfig[ADC_EXTERNAL1].dmaIndex = adcChannelCount;
adcConfig[ADC_EXTERNAL1].sampleTime = ADC_SampleTime_601Cycles5;
adcConfig[ADC_EXTERNAL1].enabled = true;
adcChannelCount++;
RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div256); // 72 MHz divided by 256 = 281.25 kHz
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1 | RCC_AHBPeriph_ADC12, ENABLE);
DMA_DeInit(DMA1_Channel1);
DMA_StructInit(&DMA_InitStructure);
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&ADC1->DR;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)adcValues;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = adcChannelCount;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = adcChannelCount > 1 ? DMA_MemoryInc_Enable : DMA_MemoryInc_Disable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(DMA1_Channel1, &DMA_InitStructure);
DMA_Cmd(DMA1_Channel1, ENABLE);
GPIO_Init(GPIOC, &GPIO_InitStructure);
// calibrate
ADC_VoltageRegulatorCmd(ADC1, ENABLE);
delay(10);
ADC_SelectCalibrationMode(ADC1, ADC_CalibrationMode_Single);
ADC_StartCalibration(ADC1);
while(ADC_GetCalibrationStatus(ADC1) != RESET);
ADC_VoltageRegulatorCmd(ADC1, DISABLE);
ADC_CommonInitTypeDef ADC_CommonInitStructure;
ADC_CommonStructInit(&ADC_CommonInitStructure);
ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_CommonInitStructure.ADC_Clock = ADC_Clock_SynClkModeDiv4;
ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_1;
ADC_CommonInitStructure.ADC_DMAMode = ADC_DMAMode_Circular;
ADC_CommonInitStructure.ADC_TwoSamplingDelay = 0;
ADC_CommonInit(ADC1, &ADC_CommonInitStructure);
ADC_StructInit(&ADC_InitStructure);
ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Enable;
ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_0;
ADC_InitStructure.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_OverrunMode = ADC_OverrunMode_Disable;
ADC_InitStructure.ADC_AutoInjMode = ADC_AutoInjec_Disable;
ADC_InitStructure.ADC_NbrOfRegChannel = adcChannelCount;
ADC_Init(ADC1, &ADC_InitStructure);
uint8_t rank = 1;
for (i = 0; i < ADC_CHANNEL_COUNT; i++) {
if (!adcConfig[i].enabled) {
continue;
}
ADC_RegularChannelConfig(ADC1, adcConfig[i].adcChannel, rank++, adcConfig[i].sampleTime);
}
ADC_Cmd(ADC1, ENABLE);
while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_RDY));
ADC_DMAConfig(ADC1, ADC_DMAMode_Circular);
ADC_DMACmd(ADC1, ENABLE);
ADC_StartConversion(ADC1);
}
void ADC_Configuration(void)
{
__IO uint16_t calibration_value = 0;
ADC_InitTypeDef ADC_InitStructure;
ADC_CommonInitTypeDef ADC_CommonInitStructure;
ADC_InjectedInitTypeDef ADC_InjInitStructure;
ADC_StructInit(&ADC_InitStructure);
/* Calibration procedure */
ADC_VoltageRegulatorCmd(ADC2, ENABLE);
/* Insert delay equal to 10 µs */
Delay(10);
ADC_SelectCalibrationMode(ADC2, ADC_CalibrationMode_Single);
ADC_StartCalibration(ADC2);
while(ADC_GetCalibrationStatus(ADC2) != RESET );
calibration_value = ADC_GetCalibrationValue(ADC2);
ADC_CommonInitStructure.ADC_Mode = ADC_Mode_InjSimul;
ADC_CommonInitStructure.ADC_Clock = ADC_Clock_AsynClkMode;
ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled;
ADC_CommonInitStructure.ADC_DMAMode = ADC_DMAMode_OneShot;
ADC_CommonInitStructure.ADC_TwoSamplingDelay = 0;
ADC_CommonInit(ADC2, &ADC_CommonInitStructure);
ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Enable;
ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_0;
ADC_InitStructure.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_OverrunMode = ADC_OverrunMode_Disable;
ADC_InitStructure.ADC_AutoInjMode = ADC_AutoInjec_Enable;
ADC_InitStructure.ADC_NbrOfRegChannel = 3;
ADC_Init(ADC2, &ADC_InitStructure);
ADC_InjInitStructure.ADC_ExternalTrigInjecConvEvent = ADC_ExternalTrigInjecConvEvent_0;
ADC_InjInitStructure.ADC_ExternalTrigInjecEventEdge = ADC_ExternalTrigInjecEventEdge_None;
ADC_InjInitStructure.ADC_NbrOfInjecChannel = 3;
ADC_InjInitStructure.ADC_InjecSequence1 = ADC_Channel_5;
ADC_InjInitStructure.ADC_InjecSequence2 = ADC_Channel_11;
ADC_InjInitStructure.ADC_InjecSequence3 = ADC_Channel_12;
ADC_InjectedInit(ADC2, &ADC_InjInitStructure);
/* ADC1 regular channel7 configuration */
//ADC_RegularChannelConfig(ADC2, ADC_Channel_5, 1, ADC_SampleTime_7Cycles5);
ADC_InjectedChannelSampleTimeConfig(ADC2, ADC_Channel_5, ADC_SampleTime_7Cycles5);
ADC_InjectedChannelSampleTimeConfig(ADC2, ADC_Channel_11,ADC_SampleTime_7Cycles5);
ADC_InjectedChannelSampleTimeConfig(ADC2, ADC_Channel_12,ADC_SampleTime_7Cycles5);
/* Enable ADC1 */
ADC_Cmd(ADC2, ENABLE);
/* wait for ADRDY */
while(!ADC_GetFlagStatus(ADC2, ADC_FLAG_RDY));
/* Start ADC1 Software Conversion */
ADC_StartConversion(ADC2);
}
void ADC_Config( void )
{
RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div2);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC12, ENABLE);
/* Setup SysTick Timer for 1 µsec interrupts */
//if (SysTick_Config(SystemCoreClock / 1000000))
// {
/* Capture error */
// while (1)
// {}
//}
/* GPIOC Periph clock enable */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE);
/* Configure ADC Channel7 as analog input */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 ;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;
GPIO_Init(GPIOA, &GPIO_InitStructure);
ADC_SelectCalibrationMode(ADC1, ADC_CalibrationMode_Single);
ADC_StartCalibration(ADC1);
while(ADC_GetCalibrationStatus(ADC1) != RESET );
calibration_value = ADC_GetCalibrationValue(ADC1);
ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_CommonInitStructure.ADC_Clock = ADC_Clock_AsynClkMode;
ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled;
ADC_CommonInitStructure.ADC_DMAMode = ADC_DMAMode_OneShot;
ADC_CommonInitStructure.ADC_TwoSamplingDelay = 0;
ADC_CommonInit(ADC1, &ADC_CommonInitStructure);
ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Enable;
ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_0;
ADC_InitStructure.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_OverrunMode = ADC_OverrunMode_Disable;
ADC_InitStructure.ADC_AutoInjMode = ADC_AutoInjec_Disable;
ADC_InitStructure.ADC_NbrOfRegChannel = 1;
ADC_Init(ADC1, &ADC_InitStructure);
/* ADC1 regular channel1 configuration */
ADC_RegularChannelConfig(ADC1, ADC_Channel_1, 1, ADC_SampleTime_7Cycles5);
/* Enable ADC1 */
ADC_Cmd(ADC1, ENABLE);
/* wait for ADRDY */
while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_RDY));
/* Start ADC1 Software Conversion */
ADC_StartConversion(ADC1);
} //end ADC_Config
/**
* @brief Main program.
* @param None
* @retval None
*/
int main(void)
{
/*!< At this stage the microcontroller clock setting is already configured,
this is done through SystemInit() function which is called from startup
file (startup_stm32f30x.s) before to branch to application main.
To reconfigure the default setting of SystemInit() function, refer to
system_stm32f30x.c file
*/
/* Configure the ADC clock */
RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div2);
/* Enable ADC1 clock */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC12, ENABLE);
/* LCD Display init */
Display_Init();
/* Setup SysTick Timer for 1 µsec interrupts */
if (SysTick_Config(SystemCoreClock / 1000000))
{
/* Capture error */
while (1)
{}
}
/* ADC Channel configuration */
/* GPIOC Periph clock enable */
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE);
/* Configure ADC Channel7 as analog input */
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_2;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;
GPIO_Init(GPIOC, &GPIO_InitStructure);
ADC_StructInit(&ADC_InitStructure);
/* Calibration procedure */
ADC_VoltageRegulatorCmd(ADC1, ENABLE);
/* Insert delay equal to 10 µs */
Delay(10);
ADC_SelectCalibrationMode(ADC1, ADC_CalibrationMode_Differential);
ADC_StartCalibration(ADC1);
while(ADC_GetCalibrationStatus(ADC1) != RESET );
calibration_value = ADC_GetCalibrationValue(ADC1);
ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_CommonInitStructure.ADC_Clock = ADC_Clock_AsynClkMode;
ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled;
ADC_CommonInitStructure.ADC_DMAMode = ADC_DMAMode_OneShot;
ADC_CommonInitStructure.ADC_TwoSamplingDelay = 0;
ADC_CommonInit(ADC1, &ADC_CommonInitStructure);
ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Enable;
ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_0;
ADC_InitStructure.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_OverrunMode = ADC_OverrunMode_Disable;
ADC_InitStructure.ADC_AutoInjMode = ADC_AutoInjec_Disable;
ADC_InitStructure.ADC_NbrOfRegChannel = 1;
ADC_Init(ADC1, &ADC_InitStructure);
/* ADC1 regular channel7 and channel8 configuration */
ADC_RegularChannelConfig(ADC1, ADC_Channel_7, 1, ADC_SampleTime_7Cycles5);
ADC_RegularChannelConfig(ADC1, ADC_Channel_8, 2, ADC_SampleTime_7Cycles5);
/* Select the differetiel mode for Channel 7 */
ADC_SelectDifferentialMode(ADC1, ADC_Channel_7, ENABLE);
/* Enable ADC1 */
ADC_Cmd(ADC1, ENABLE);
/* wait for ADRDY */
while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_RDY));
/* Start ADC1 Software Conversion */
ADC_StartConversion(ADC1);
/* Infinite loop */
while (1)
{
/* Test EOC flag */
while(ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) == RESET);
/* Get ADC1 converted data */
ADC1ConvertedValue =ADC_GetConversionValue(ADC1);
/* Compute the voltage */
ADC1ConvertedVoltage = (ADC1ConvertedValue *6600)/0xFFF;
/* Display converted data on the LCD */
Display();
}
}
/**
* @brief Initializes the following ADC-modules. They are triggered by a timer module
* and an interrupt is generated when the ADC's are finished sampling and
* converting.
* ADC channels:
* PIN: CHANNEL: DESCRIPTION TRIGGER:
* --------------------------------------------------------
* PB12 ADC4_IN3 AN_IN1 TIM2
* PF4 ADC1_IN5 INT. TEMPERATURE TIM2
* PC0 ADC1_IN6 LEAKAGE DETECTION TIM2
* PC1 ADC1_IN7 AN_IN2 TIM2
* PC2 ADC1_IN8 CUR_IN1 TIM2
* PC3 ADC1_IN9 CUR_IN2 TIM2
* --------------------------------------------------------
* @param None
* @retval None
*/
void ADC_init(void){
/* TypeDef declarations *************************************************************/
GPIO_InitTypeDef GPIO_InitStructure;
ADC_InitTypeDef ADC_InitStructure;
ADC_CommonInitTypeDef ADC_CommonInitStructure;
NVIC_InitTypeDef NVIC_InitStruct;
/* Clock setup **********************************************************************/
RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div4); // Set clock divider
RCC_ADCCLKConfig(RCC_ADC34PLLCLK_Div4); // Set clock divider
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC12, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC34, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOF, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA1, ENABLE);
RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA2, ENABLE);
/* GPIO setup ***********************************************************************/
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN; // Analog mode
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL; // No internal pull up/down resistor.
GPIO_Init(GPIOB, &GPIO_InitStructure); // Download settings to GPIOB registers.
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3;
GPIO_Init(GPIOC, &GPIO_InitStructure); // Download settings to GPIOC registers
GPIO_InitStructure.GPIO_Pin = GPIO_Pin_4;
GPIO_Init(GPIOF, &GPIO_InitStructure);
/* Calibration **********************************************************************/
/* Reset ADC registers to their default values. */
ADC_DeInit(ADC1);
ADC_DeInit(ADC4);
/* Activate voltage regulators */
ADC_VoltageRegulatorCmd(ADC1, ENABLE);
ADC_VoltageRegulatorCmd(ADC4, ENABLE);
/* Wait 10 microseconds for the voltage regulator to finish starting up */
volatile uint16_t i = 358; // 10us/(2*14ns) = 358 iterations
while(i-->0);
/* Using single-mode calibration on ADC1.*/
ADC_SelectCalibrationMode(ADC1, ADC_CalibrationMode_Single);
ADC_StartCalibration(ADC1); // Start calibration
while(ADC_GetCalibrationStatus(ADC1) != RESET); // wait
/* Using single-mode calibration on ADC4.*/
ADC_SelectCalibrationMode(ADC4, ADC_CalibrationMode_Single);
ADC_StartCalibration(ADC4); // Start calibration
while(ADC_GetCalibrationStatus(ADC4) != RESET); // wait
/* Common structure *****************************************************************/
ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_CommonInitStructure.ADC_Clock = ADC_Clock_AsynClkMode;
ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled;
ADC_CommonInitStructure.ADC_DMAMode = ADC_DMAMode_Circular;
ADC_CommonInitStructure.ADC_TwoSamplingDelay = 10;
ADC_CommonInit(ADC4, &ADC_CommonInitStructure);
ADC_CommonInit(ADC1, &ADC_CommonInitStructure);
/* ADC setup ************************************************************************/
/*
* Resolution: 12 bit -> 732 uV per LSb.
* Conversion mode: Triggered from TIM2_TRGO.
* DMA: DMA request enabled for circular DMA mode.
*
*/
ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Disable;
ADC_InitStructure.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_RisingEdge;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_OverrunMode = ADC_OverrunMode_Enable;
ADC_InitStructure.ADC_AutoInjMode = ADC_AutoInjec_Disable;
/* Only one channel will be used in ADC4, while 4 will be used in ADC1.
* TIM2_TRGO is mapped to external trigger event 11 for ADC1 and 7 for ADC4.*/
ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_11;
ADC_InitStructure.ADC_NbrOfRegChannel = 5;
ADC_Init(ADC1, &ADC_InitStructure); /* Download settings to ADC1 registers */
ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_7;
ADC_InitStructure.ADC_NbrOfRegChannel = 1;
ADC_Init(ADC4, &ADC_InitStructure); /* Download settings to ADC4 registers*/
ADC1->CFGR |= 0b11; // Making sure DMA access is enabled for ADC1
ADC4->CFGR |= 0b11; // Making sure DMA access is enabled for ADC4
/* Interrupt settings ***************************************************************/
/*
* No interrupts are used for the ADC modules, the only interrupt will come from
* the DMA module(when all DMA-transfers are complete).
*/
/* Interrupt handler settings */
// NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
// NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
// NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
// NVIC_InitStruct.NVIC_IRQChannel = ADC1_2_IRQn;
// NVIC_Init(&NVIC_InitStruct);
// NVIC_InitStruct.NVIC_IRQChannel = ADC4_IRQn;
// NVIC_Init(&NVIC_InitStruct);
//
// /* Interrupt request settings */
// ADC_ITConfig(ADC1, ADC_IT_EOC, ENABLE);
// ADC_ITConfig(ADC4, ADC_IT_EOC, ENABLE);
/* ADC Channal sequencing ***********************************************************/
/*
* ADC1 will sample channels 5-9, ADC4 will sample channel 3.
* See the table over ADC_init() for pin mapping and functions.
* The sampling time is set to 61.5*4(prescaler) = 246 processor cycles to allow
* the DMA to finish data transfers before the next channel is sampled.
*/
ADC_RegularChannelConfig(ADC1, ADC_Channel_5, 1, ADC_SampleTime_61Cycles5);
ADC_RegularChannelConfig(ADC1, ADC_Channel_6, 2, ADC_SampleTime_61Cycles5);
ADC_RegularChannelConfig(ADC1, ADC_Channel_7, 3, ADC_SampleTime_61Cycles5);
ADC_RegularChannelConfig(ADC1, ADC_Channel_8, 4, ADC_SampleTime_61Cycles5);
ADC_RegularChannelConfig(ADC1, ADC_Channel_9, 5, ADC_SampleTime_61Cycles5);
ADC_RegularChannelConfig(ADC4, ADC_Channel_3, 1, ADC_SampleTime_61Cycles5);
/* Activaton ************************************************************************/
ADC_Cmd(ADC1, ENABLE);
ADC_Cmd(ADC4, ENABLE);
/* Wait for ready flags */
while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_RDY));
while(!ADC_GetFlagStatus(ADC4, ADC_FLAG_RDY));
/* DMA Controller setup *************************************************************/
/* DMA1 Channel 1, connected to ADC1. */
DMA_DeInit(DMA1_Channel1);
DMA1_Channel1->CPAR = ((uint32_t)&(ADC1->DR)); // Source register (periph)
DMA1_Channel1->CMAR = (uint32_t)&ADC_buffer[0]; // Destination register (memory)
DMA1_Channel1->CNDTR = 5; // The number of data to be transfered
DMA1_Channel1->CCR = (DMA_CCR_PL_1) // Medium priority.
|(DMA_CCR_CIRC) // DMA Circular mode enabled
|(DMA_CCR_MINC) // Memory pointer automatic increment enabled.
|(DMA_CCR_PSIZE_0) // Periph. data size = 16 bit.
|(DMA_CCR_MSIZE_0) // Memory data size = 16 bit.
|(DMA_CCR_TCIE); // Enable interrupt on Transfer Complete
//DMA1_Channel1->CCR |= 0b010010110100010;
/* DMA2 Channel 2, connected to ADC1. */
DMA_DeInit(DMA2_Channel2);
DMA2_Channel2->CPAR = ((uint32_t)&(ADC4->DR)); // Source register (periph)
DMA2_Channel2->CMAR = (uint32_t)&ADC_buffer[5]; // Destination register (memory)
DMA2_Channel2->CNDTR = 1; // The number of data to be transfered
DMA2_Channel2->CCR = (DMA_CCR_PL_1) // Medium priority.
|(DMA_CCR_CIRC) // DMA Circular mode enabled
|(DMA_CCR_MINC) // Memory pointer automatic increment enabled.
|(DMA_CCR_PSIZE_0) // Periph. data size = 16 bit.
|(DMA_CCR_MSIZE_0) // Memory data size = 16 bit.
|(DMA_CCR_TCIE); // Enable interrupt on Transfer Complete
/* Activating the DMA channels */
DMA1_Channel1->CCR |= DMA_CCR_EN;
DMA2_Channel2->CCR |= DMA_CCR_EN;
/* Enable DMA interrup handler */
NVIC_InitStruct.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStruct.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStruct.NVIC_IRQChannelCmd = ENABLE;
NVIC_InitStruct.NVIC_IRQChannel = DMA1_Channel1_IRQn;
NVIC_Init(&NVIC_InitStruct);
NVIC_InitStruct.NVIC_IRQChannel = DMA2_Channel2_IRQn;
NVIC_Init(&NVIC_InitStruct);
/* Enable DMA request from ADC1 and ADC4 */
ADC_DMACmd(ADC1, ENABLE);
ADC_DMACmd(ADC4, ENABLE);
/* Start first conversion ***********************************************************/
ADC_StartConversion(ADC1);
ADC_StartConversion(ADC4);
} // end ADC_oppstart()
void adcInit(drv_adc_config_t *init)
{
ADC_InitTypeDef ADC_InitStructure;
DMA_InitTypeDef DMA_InitStructure;
GPIO_InitTypeDef GPIO_InitStructure;
uint8_t i;
uint8_t adcChannelCount = 0;
memset(&adcConfig, 0, sizeof(adcConfig));
GPIO_StructInit(&GPIO_InitStructure);
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN;
GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ;
#ifdef ADC0_GPIO
if (init->channelMask & ADC_CHANNEL0_ENABLE) {
GPIO_InitStructure.GPIO_Pin = ADC0_GPIO_PIN;
GPIO_Init(ADC0_GPIO, &GPIO_InitStructure);
adcConfig[ADC_CHANNEL0].adcChannel = ADC0_CHANNEL;
adcConfig[ADC_CHANNEL0].dmaIndex = adcChannelCount;
adcConfig[ADC_CHANNEL0].sampleTime = ADC_SampleTime_601Cycles5;
adcConfig[ADC_CHANNEL0].enabled = true;
adcChannelCount++;
}
#endif
#ifdef ADC1_GPIO
if (init->channelMask & ADC_CHANNEL1_ENABLE) {
GPIO_InitStructure.GPIO_Pin = ADC1_GPIO_PIN;
GPIO_Init(ADC1_GPIO, &GPIO_InitStructure);
adcConfig[ADC_CHANNEL1].adcChannel = ADC1_CHANNEL;
adcConfig[ADC_CHANNEL1].dmaIndex = adcChannelCount;
adcConfig[ADC_CHANNEL1].sampleTime = ADC_SampleTime_601Cycles5;
adcConfig[ADC_CHANNEL1].enabled = true;
adcChannelCount++;
}
#endif
#ifdef ADC2_GPIO
if (init->channelMask & ADC_CHANNEL2_ENABLE) {
GPIO_InitStructure.GPIO_Pin = ADC2_GPIO_PIN;
GPIO_Init(ADC2_GPIO, &GPIO_InitStructure);
adcConfig[ADC_CHANNEL2].adcChannel = ADC2_CHANNEL;
adcConfig[ADC_CHANNEL2].dmaIndex = adcChannelCount;
adcConfig[ADC_CHANNEL2].sampleTime = ADC_SampleTime_601Cycles5;
adcConfig[ADC_CHANNEL2].enabled = true;
adcChannelCount++;
}
#endif
#ifdef ADC3_GPIO
if (init->channelMask & ADC_CHANNEL3_ENABLE) {
GPIO_InitStructure.GPIO_Pin = ADC3_GPIO_PIN;
GPIO_Init(ADC3_GPIO, &GPIO_InitStructure);
adcConfig[ADC_CHANNEL3].adcChannel = ADC3_CHANNEL;
adcConfig[ADC_CHANNEL3].dmaIndex = adcChannelCount;
adcConfig[ADC_CHANNEL3].sampleTime = ADC_SampleTime_601Cycles5;
adcConfig[ADC_CHANNEL3].enabled = true;
adcChannelCount++;
}
#endif
#ifdef ADC4_GPIO
if (init->channelMask & ADC_CHANNEL4_ENABLE) {
GPIO_InitStructure.GPIO_Pin = ADC4_GPIO_PIN;
GPIO_Init(ADC4_GPIO, &GPIO_InitStructure);
adcConfig[ADC_CHANNEL4].adcChannel = ADC4_CHANNEL;
adcConfig[ADC_CHANNEL4].dmaIndex = adcChannelCount;
adcConfig[ADC_CHANNEL4].sampleTime = ADC_SampleTime_601Cycles5;
adcConfig[ADC_CHANNEL4].enabled = true;
adcChannelCount++;
}
#endif
#ifdef ADC5_GPIO
if (init->channelMask & ADC_CHANNEL5_ENABLE) {
GPIO_InitStructure.GPIO_Pin = ADC5_GPIO_PIN;
GPIO_Init(ADC5_GPIO, &GPIO_InitStructure);
adcConfig[ADC_CHANNEL5].adcChannel = ADC5_CHANNEL;
adcConfig[ADC_CHANNEL5].dmaIndex = adcChannelCount;
adcConfig[ADC_CHANNEL5].sampleTime = ADC_SampleTime_601Cycles5;
adcConfig[ADC_CHANNEL5].enabled = true;
adcChannelCount++;
}
#endif
RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div256); // 72 MHz divided by 256 = 281.25 kHz
RCC_AHBPeriphClockCmd(ADC_AHB_PERIPHERAL | RCC_AHBPeriph_ADC12, ENABLE);
DMA_DeInit(ADC_DMA_CHANNEL);
DMA_StructInit(&DMA_InitStructure);
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&ADC_INSTANCE->DR;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)adcValues;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = adcChannelCount;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = adcChannelCount > 1 ? DMA_MemoryInc_Enable : DMA_MemoryInc_Disable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(ADC_DMA_CHANNEL, &DMA_InitStructure);
DMA_Cmd(ADC_DMA_CHANNEL, ENABLE);
// calibrate
ADC_VoltageRegulatorCmd(ADC_INSTANCE, ENABLE);
delay(10);
ADC_SelectCalibrationMode(ADC_INSTANCE, ADC_CalibrationMode_Single);
ADC_StartCalibration(ADC_INSTANCE);
while(ADC_GetCalibrationStatus(ADC_INSTANCE) != RESET);
ADC_VoltageRegulatorCmd(ADC_INSTANCE, DISABLE);
ADC_CommonInitTypeDef ADC_CommonInitStructure;
ADC_CommonStructInit(&ADC_CommonInitStructure);
ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_CommonInitStructure.ADC_Clock = ADC_Clock_SynClkModeDiv4;
ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_1;
ADC_CommonInitStructure.ADC_DMAMode = ADC_DMAMode_Circular;
ADC_CommonInitStructure.ADC_TwoSamplingDelay = 0;
ADC_CommonInit(ADC_INSTANCE, &ADC_CommonInitStructure);
ADC_StructInit(&ADC_InitStructure);
ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Enable;
ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_0;
ADC_InitStructure.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_OverrunMode = ADC_OverrunMode_Disable;
ADC_InitStructure.ADC_AutoInjMode = ADC_AutoInjec_Disable;
ADC_InitStructure.ADC_NbrOfRegChannel = adcChannelCount;
ADC_Init(ADC_INSTANCE, &ADC_InitStructure);
uint8_t rank = 1;
for (i = 0; i < ADC_CHANNEL_COUNT; i++) {
if (!adcConfig[i].enabled) {
continue;
}
ADC_RegularChannelConfig(ADC_INSTANCE, adcConfig[i].adcChannel, rank++, adcConfig[i].sampleTime);
}
ADC_Cmd(ADC_INSTANCE, ENABLE);
while(!ADC_GetFlagStatus(ADC_INSTANCE, ADC_FLAG_RDY));
ADC_DMAConfig(ADC_INSTANCE, ADC_DMAMode_Circular);
ADC_DMACmd(ADC_INSTANCE, ENABLE);
ADC_StartConversion(ADC_INSTANCE);
}
void adcInit(drv_adc_config_t *init)
{
ADC_InitTypeDef ADC_InitStructure;
DMA_InitTypeDef DMA_InitStructure;
uint8_t i;
uint8_t adcChannelCount = 0;
memset(&adcConfig, 0, sizeof(adcConfig));
#ifdef VBAT_ADC_PIN
if (init->enableVBat) {
IOInit(IOGetByTag(IO_TAG(VBAT_ADC_PIN)), OWNER_SYSTEM, RESOURCE_ADC);
IOConfigGPIO(IOGetByTag(IO_TAG(VBAT_ADC_PIN)), IO_CONFIG(GPIO_Mode_AN, 0, GPIO_OType_OD, GPIO_PuPd_NOPULL));
adcConfig[ADC_BATTERY].adcChannel = VBAT_ADC_CHANNEL;
adcConfig[ADC_BATTERY].dmaIndex = adcChannelCount;
adcConfig[ADC_BATTERY].sampleTime = ADC_SampleTime_601Cycles5;
adcConfig[ADC_BATTERY].enabled = true;
adcChannelCount++;
}
#endif
#ifdef RSSI_ADC_PIN
if (init->enableRSSI) {
IOInit(IOGetByTag(IO_TAG(RSSI_ADC_PIN)), OWNER_SYSTEM, RESOURCE_ADC);
IOConfigGPIO(IOGetByTag(IO_TAG(RSSI_ADC_PIN)), IO_CONFIG(GPIO_Mode_AN, 0, GPIO_OType_OD, GPIO_PuPd_NOPULL));
adcConfig[ADC_RSSI].adcChannel = RSSI_ADC_CHANNEL;
adcConfig[ADC_RSSI].dmaIndex = adcChannelCount;
adcConfig[ADC_RSSI].sampleTime = ADC_SampleTime_601Cycles5;
adcConfig[ADC_RSSI].enabled = true;
adcChannelCount++;
}
#endif
#ifdef CURRENT_METER_ADC_PIN
if (init->enableCurrentMeter) {
IOInit(IOGetByTag(IO_TAG(CURRENT_METER_ADC_PIN)), OWNER_SYSTEM, RESOURCE_ADC);
IOConfigGPIO(IOGetByTag(IO_TAG(CURRENT_METER_ADC_PIN)), IO_CONFIG(GPIO_Mode_AN, 0, GPIO_OType_OD, GPIO_PuPd_NOPULL));
adcConfig[ADC_CURRENT].adcChannel = CURRENT_METER_ADC_CHANNEL;
adcConfig[ADC_CURRENT].dmaIndex = adcChannelCount;
adcConfig[ADC_CURRENT].sampleTime = ADC_SampleTime_601Cycles5;
adcConfig[ADC_CURRENT].enabled = true;
adcChannelCount++;
}
#endif
#ifdef EXTERNAL1_ADC_PIN
if (init->enableExternal1) {
IOInit(IOGetByTag(IO_TAG(EXTERNAL1_ADC_PIN)), OWNER_SYSTEM, RESOURCE_ADC);
IOConfigGPIO(IOGetByTag(IO_TAG(EXTERNAL1_ADC_PIN)), IO_CONFIG(GPIO_Mode_AN, 0, GPIO_OType_OD, GPIO_PuPd_NOPULL));
adcConfig[ADC_EXTERNAL1].adcChannel = EXTERNAL1_ADC_CHANNEL;
adcConfig[ADC_EXTERNAL1].dmaIndex = adcChannelCount;
adcConfig[ADC_EXTERNAL1].sampleTime = ADC_SampleTime_601Cycles5;
adcConfig[ADC_EXTERNAL1].enabled = true;
adcChannelCount++;
}
#endif
RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div256); // 72 MHz divided by 256 = 281.25 kHz
RCC_AHBPeriphClockCmd(ADC_AHB_PERIPHERAL | RCC_AHBPeriph_ADC12, ENABLE);
DMA_DeInit(ADC_DMA_CHANNEL);
DMA_StructInit(&DMA_InitStructure);
DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&ADC_INSTANCE->DR;
DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)adcValues;
DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC;
DMA_InitStructure.DMA_BufferSize = adcChannelCount;
DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable;
DMA_InitStructure.DMA_MemoryInc = adcChannelCount > 1 ? DMA_MemoryInc_Enable : DMA_MemoryInc_Disable;
DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord;
DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord;
DMA_InitStructure.DMA_Mode = DMA_Mode_Circular;
DMA_InitStructure.DMA_Priority = DMA_Priority_High;
DMA_InitStructure.DMA_M2M = DMA_M2M_Disable;
DMA_Init(ADC_DMA_CHANNEL, &DMA_InitStructure);
DMA_Cmd(ADC_DMA_CHANNEL, ENABLE);
// calibrate
ADC_VoltageRegulatorCmd(ADC_INSTANCE, ENABLE);
delay(10);
ADC_SelectCalibrationMode(ADC_INSTANCE, ADC_CalibrationMode_Single);
ADC_StartCalibration(ADC_INSTANCE);
while(ADC_GetCalibrationStatus(ADC_INSTANCE) != RESET);
ADC_VoltageRegulatorCmd(ADC_INSTANCE, DISABLE);
ADC_CommonInitTypeDef ADC_CommonInitStructure;
ADC_CommonStructInit(&ADC_CommonInitStructure);
ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent;
ADC_CommonInitStructure.ADC_Clock = ADC_Clock_SynClkModeDiv4;
ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_1;
ADC_CommonInitStructure.ADC_DMAMode = ADC_DMAMode_Circular;
ADC_CommonInitStructure.ADC_TwoSamplingDelay = 0;
ADC_CommonInit(ADC_INSTANCE, &ADC_CommonInitStructure);
ADC_StructInit(&ADC_InitStructure);
ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Enable;
ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b;
ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_0;
ADC_InitStructure.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_None;
ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right;
ADC_InitStructure.ADC_OverrunMode = ADC_OverrunMode_Disable;
ADC_InitStructure.ADC_AutoInjMode = ADC_AutoInjec_Disable;
ADC_InitStructure.ADC_NbrOfRegChannel = adcChannelCount;
ADC_Init(ADC_INSTANCE, &ADC_InitStructure);
uint8_t rank = 1;
for (i = 0; i < ADC_CHANNEL_COUNT; i++) {
if (!adcConfig[i].enabled) {
continue;
}
ADC_RegularChannelConfig(ADC_INSTANCE, adcConfig[i].adcChannel, rank++, adcConfig[i].sampleTime);
}
ADC_Cmd(ADC_INSTANCE, ENABLE);
while(!ADC_GetFlagStatus(ADC_INSTANCE, ADC_FLAG_RDY));
ADC_DMAConfig(ADC_INSTANCE, ADC_DMAMode_Circular);
ADC_DMACmd(ADC_INSTANCE, ENABLE);
ADC_StartConversion(ADC_INSTANCE);
}
