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); }