void analogin_init(analogin_t *obj, PinName pin) { ADC_TypeDef *adc; ADC_InitTypeDef ADC_InitStructure; ADC_CommonInitTypeDef ADC_CommonInitStructure; // Get the peripheral name from the pin and assign it to the object obj->adc = (ADCName)pinmap_peripheral(pin, PinMap_ADC); MBED_ASSERT(obj->adc == (ADCName)NC); // Configure GPIO pinmap_pinout(pin, PinMap_ADC); // Save pin number for the read function obj->pin = pin; // The ADC initialization is done once if (adc_inited == 0) { adc_inited = 1; // Get ADC registers structure address adc = (ADC_TypeDef *)(obj->adc); // Enable ADC clock RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div1); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC12, ENABLE); // Calibration ADC_VoltageRegulatorCmd(adc, ENABLE); wait_us(10); ADC_SelectCalibrationMode(adc, ADC_CalibrationMode_Single); ADC_StartCalibration(adc); while (ADC_GetCalibrationStatus(adc) != RESET) {} // Configure ADC 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_Disable; 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); // Enable ADC ADC_Cmd(adc, ENABLE); while (!ADC_GetFlagStatus(adc, ADC_FLAG_RDY)) {} } }
void adc12_mode_config(void) { ADC_InitTypeDef ADC_InitStructure; ADC_CommonInitTypeDef ADC_CommonInitStructure; /*DMA_DeInit(DMA1_Channel1); DMA_InitStructure.DMA_PeripheralBaseAddr = ADC1_ADDRESS; DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t) &ADC_ConvertedValue; DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC; DMA_InitStructure.DMA_BufferSize = 1; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_MemoryInc = 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);*/ //ADC_StructInit(&ADC_InitStructure); ADC_VoltageRegulatorCmd(ADC1, ENABLE); delay_us(100); 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_OneShot; ADC_CommonInitStructure.ADC_TwoSamplingDelay = 0; ADC_CommonInit(ADC1, &ADC_CommonInitStructure); ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b; ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_0; ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Enable; ADC_InitStructure.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_None; ADC_InitStructure.ADC_DataAlign = ADC_DataAlign_Right; ADC_InitStructure.ADC_AutoInjMode = ADC_AutoInjec_Disable; ADC_InitStructure.ADC_NbrOfRegChannel = 1; ADC_Init(ADC1, &ADC_InitStructure); ADC_RegularChannelConfig(ADC1, ADC_Channel_7, 1, ADC_SampleTime_7Cycles5); ADC_Cmd(ADC1, ENABLE); }
void adc_init_injected(int use_trigger, int trigger){ //Confiure pins PA0[AN1], PA1[AN2] for analog input operation RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA,ENABLE); GPIO_InitTypeDef myGPIO; GPIO_StructInit(&myGPIO); myGPIO.GPIO_Pin=(GPIO_Pin_1|GPIO_Pin_0); myGPIO.GPIO_Mode=GPIO_Mode_AN; GPIO_Init(GPIOA,&myGPIO); //Configure ADC RCC_ADCCLKConfig(RCC_ADC12PLLCLK_OFF); RCC_AHBPeriphClockCmd(RCC_AHBENR_ADC12EN,ENABLE); ADC_CommonInitTypeDef myADC_Comm; ADC_CommonStructInit(&myADC_Comm); myADC_Comm.ADC_Clock=ADC_Clock_SynClkModeDiv1; ADC_CommonInit(ADC1,&myADC_Comm); ADC_VoltageRegulatorCmd(ADC1,ENABLE); /*Initial calibration*/ ADC_SelectCalibrationMode(ADC1, ADC_CalibrationMode_Single); ADC_StartCalibration(ADC1); while(ADC_GetCalibrationStatus(ADC1) != RESET); ADC_GetCalibrationValue(ADC1); ADC_InjectedInitTypeDef myADC; ADC_InjectedStructInit(&myADC); myADC.ADC_ExternalTrigInjecEventEdge= (use_trigger) ? ADC_ExternalTrigInjecEventEdge_RisingEdge : ADC_ExternalTrigInjecEventEdge_None; //Connect timer with adc myADC.ADC_ExternalTrigInjecConvEvent=trigger;//Start convertion on TIM2_OTRIG myADC.ADC_NbrOfInjecChannel=2; myADC.ADC_InjecSequence1=ADC_InjectedChannel_1; myADC.ADC_InjecSequence2=ADC_InjectedChannel_1; myADC.ADC_InjecSequence3=ADC_InjectedChannel_1; myADC.ADC_InjecSequence4=ADC_InjectedChannel_2; ADC_InjectedInit(ADC1,&myADC); ADC_InjectedChannelSampleTimeConfig(ADC1,ADC_InjectedChannel_1,ADC_SampleTime_7Cycles5); ADC_InjectedChannelSampleTimeConfig(ADC1,ADC_InjectedChannel_2,ADC_SampleTime_7Cycles5); // ADC_ITConfig(ADC1, ADC_IT_JEOS, ENABLE); NVIC_EnableIRQ(ADC1_IRQn); /* wait for ADRDY */ ADC_Cmd(ADC1,ENABLE); while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_RDY)); }
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); }
/** * @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(); } }
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); }
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); }
/** * @brief ADC configuration. * @param None * @retval None */ static void ADC_Config(void) { __IO uint16_t calibration_value = 0x00; ADC_InitTypeDef ADC_InitStructure; ADC_CommonInitTypeDef ADC_CommonInitStructure; NVIC_InitTypeDef NVIC_InitStructure; /* Configure the ADC clock */ RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div1); /* Enable ADC1 clock */ RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC12, ENABLE); /* Setup SysTick Timer for 1 µsec interrupts */ if (SysTick_Config(SystemCoreClock / 1000000)) { /* Capture error */ while (1) {} } /* ADC Channel3 configuration */ /* GPIO PA0 configuration is done within OPAMP_Config function as the ADC channel3 is the OPAMP1 output*/ ADC_StructInit(&ADC_InitStructure); /* Calibration procedure */ ADC_VoltageRegulatorCmd(ADC1, ENABLE); /* Insert delay equal to 10 µs */ Delay(10); ADC_SelectCalibrationMode(ADC1, ADC_CalibrationMode_Single); ADC_StartCalibration(ADC1); while(ADC_GetCalibrationStatus(ADC1) != RESET ); calibration_value = ADC_GetCalibrationValue(ADC1); /* Configure the ADC1 in continuous mode */ 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 channel3 configuration */ ADC_RegularChannelConfig(ADC1, ADC_Channel_3, 1, ADC_SampleTime_1Cycles5); /* Enable EOC interrupt */ ADC_ITConfig(ADC1, ADC_IT_EOC, ENABLE); /* Enable ADC1 IRQ */ NVIC_InitStructure.NVIC_IRQChannel = ADC1_2_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); /* Enable ADC1 */ ADC_Cmd(ADC1, ENABLE); /* wait for ADRDY */ while(ADC_GetFlagStatus(ADC1, ADC_FLAG_RDY) == RESET); /* ADC1 start Conversion */ ADC_StartConversion(ADC1); }
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); }
static void AdcInit34() { RCC_ADCCLKConfig(RCC_ADC34PLLCLK_Div1); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_DMA2, ENABLE); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC34, ENABLE); NVIC_Configuration34(); GPIO_InitTypeDef GPIO_InitStructure; GPIO_StructInit(&GPIO_InitStructure); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1 ; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ; GPIO_Init(GPIOB, &GPIO_InitStructure); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOE, ENABLE); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_14 ; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ; GPIO_Init(GPIOE, &GPIO_InitStructure); ADC_VoltageRegulatorCmd(ADC3, ENABLE); ADC_VoltageRegulatorCmd(ADC4, ENABLE); delay_us(20); ADC_SelectCalibrationMode(ADC3, ADC_CalibrationMode_Single); ADC_StartCalibration(ADC3); while(ADC_GetCalibrationStatus(ADC3) != RESET ); ADC_SelectCalibrationMode(ADC4, ADC_CalibrationMode_Single); ADC_StartCalibration(ADC4); while(ADC_GetCalibrationStatus(ADC4) != RESET ); ADC_CommonInitTypeDef ADC_CommonInitStructure; ADC_CommonInitStructure.ADC_Mode = ADC_Mode_RegSimul; //ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent; ADC_CommonInitStructure.ADC_Clock = ADC_Clock_SynClkModeDiv1; //ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_1; ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_Disabled; //ADC_CommonInitStructure.ADC_DMAMode = ADC_DMAMode_OneShot; ADC_CommonInitStructure.ADC_DMAMode = ADC_DMAMode_Circular; ADC_CommonInitStructure.ADC_TwoSamplingDelay = 0; ADC_CommonInit(ADC3, &ADC_CommonInitStructure); ADC_InitTypeDef ADC_InitStructure; ADC_InitStructure.ADC_Resolution = ADC_Resolution_12b; if(1) { ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Disable; ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_1; ADC_InitStructure.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_RisingEdge; } else { ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Enable; 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_OverrunMode = ADC_OverrunMode_Enable; ADC_InitStructure.ADC_AutoInjMode = ADC_AutoInjec_Disable; ADC_InitStructure.ADC_NbrOfRegChannel = 1; ADC_Init(ADC3, &ADC_InitStructure); ADC_InitStructure.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_None; ADC_Init(ADC4, &ADC_InitStructure); ADC_DMAConfig(ADC3, ADC_DMAMode_Circular); ADC_DMAConfig(ADC4, ADC_DMAMode_Circular); }
void ADC_Config( void ) { DMA_InitTypeDef DMA_InitStruct; ADC_InitTypeDef ADC_InitStruct; ADC_CommonInitTypeDef ADC_CommonInitStruct; GPIO_InitTypeDef GPIO_InitStruct; /* ADC Clk *******************************************************************/ RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div2); ADCx_CLK_ENABLE(); ADCx_DMA_CLK_ENABLE(); /* ADC Pin *******************************************************************/ GPIO_InitStruct.GPIO_Mode = GPIO_Mode_AN; GPIO_InitStruct.GPIO_PuPd = GPIO_PuPd_NOPULL; GPIO_InitStruct.GPIO_Pin = ADCxP_PIN; GPIO_Init(ADCxP_GPIO_PORT, &GPIO_InitStruct); GPIO_InitStruct.GPIO_Pin = ADCxN_PIN; GPIO_Init(ADCxN_GPIO_PORT, &GPIO_InitStruct); /* ADC DMA *******************************************************************/ DMA_DeInit(ADCx_DMA_CHANNEL); DMA_InitStruct.DMA_PeripheralBaseAddr = ADCx_DR_ADDRESS; DMA_InitStruct.DMA_MemoryBaseAddr = (uint32_t)ADC_DMA_ConvBuf; DMA_InitStruct.DMA_DIR = DMA_DIR_PeripheralSRC; DMA_InitStruct.DMA_BufferSize = ADC_BUF_CHENNAL * ADC_BUF_SIZE; DMA_InitStruct.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStruct.DMA_MemoryInc = DMA_MemoryInc_Enable; DMA_InitStruct.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord; DMA_InitStruct.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord; DMA_InitStruct.DMA_Mode = DMA_Mode_Circular; DMA_InitStruct.DMA_Priority = DMA_Priority_Medium; DMA_InitStruct.DMA_M2M = DMA_M2M_Disable; DMA_Init(ADCx_DMA_CHANNEL, &DMA_InitStruct); DMA_Cmd(ADCx_DMA_CHANNEL, ENABLE); /* ADC Calibration ***********************************************************/ ADC_VoltageRegulatorCmd(ADCx, ENABLE); delay_ms(10); ADC_SelectCalibrationMode(ADCx, ADC_CalibrationMode_Single); ADC_StartCalibration(ADCx); while(ADC_GetCalibrationStatus(ADCx) != RESET); calibrationValue = ADC_GetCalibrationValue(ADCx); /* ADC Common Init ***********************************************************/ ADC_CommonInitStruct.ADC_Mode = ADC_Mode_Interleave; // ADC_Mode_Independent ADC_CommonInitStruct.ADC_Clock = ADC_Clock_AsynClkMode; ADC_CommonInitStruct.ADC_DMAAccessMode = ADC_DMAAccessMode_1; ADC_CommonInitStruct.ADC_DMAMode = ADC_DMAMode_Circular; ADC_CommonInitStruct.ADC_TwoSamplingDelay = 0; ADC_CommonInit(ADCx, &ADC_CommonInitStruct); /* ADC Init *****************************************************************/ ADC_InitStruct.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Enable; ADC_InitStruct.ADC_Resolution = ADC_Resolution_12b; ADC_InitStruct.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_0; ADC_InitStruct.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_None; ADC_InitStruct.ADC_DataAlign = ADC_DataAlign_Right; ADC_InitStruct.ADC_OverrunMode = ADC_OverrunMode_Disable; ADC_InitStruct.ADC_AutoInjMode = ADC_AutoInjec_Disable; ADC_InitStruct.ADC_NbrOfRegChannel = ADC_BUF_SIZE; ADC_Init(ADCx, &ADC_InitStruct); /* ADC Regular Config *******************************************************/ ADC_RegularChannelConfig(ADCx, ADCxP_CHANNEL, 1, ADC_SampleTime_601Cycles5); ADC_RegularChannelConfig(ADCx, ADCxN_CHANNEL, 2, ADC_SampleTime_601Cycles5); /* Enable & Start ***********************************************************/ ADC_DMACmd(ADCx, ENABLE); ADC_Cmd(ADCx, ENABLE); while(!ADC_GetFlagStatus(ADCx, ADC_FLAG_RDY)); DMA_Cmd(ADCx_DMA_CHANNEL, ENABLE); ADC_StartConversion(ADCx); }
void initial_adc(void) { GPIO_InitTypeDef structGPIO; ADC_InitTypeDef ADC_InitStructure; ADC_CommonInitTypeDef ADC_CommonInitStructure; NVIC_InitTypeDef NVIC_InitStructure; RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div10 /*RCC_ADC12PLLCLK_Div128*/); RCC_ADCCLKConfig(RCC_ADC34PLLCLK_Div10 /*RCC_ADC34PLLCLK_Div128*/); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC12 | RCC_AHBPeriph_ADC34 | RCC_AHBPeriph_GPIOA | RCC_AHBPeriph_GPIOB | RCC_AHBPeriph_GPIOC | RCC_AHBPeriph_GPIOD, ENABLE); //configure GPIO structGPIO.GPIO_Pin = GPIO_Pin_1 | GPIO_Pin_3 | GPIO_Pin_2 | GPIO_Pin_6; structGPIO.GPIO_Mode = GPIO_Mode_AN; structGPIO.GPIO_PuPd = GPIO_PuPd_NOPULL ; GPIO_Init(GPIOA, &structGPIO); structGPIO.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_10 | GPIO_Pin_1 | GPIO_Pin_12; GPIO_Init(GPIOB, &structGPIO); structGPIO.GPIO_Pin = GPIO_Pin_5; GPIO_Init(GPIOC, &structGPIO); structGPIO.GPIO_Pin = GPIO_Pin_8 | GPIO_Pin_11 /*| GPIO_Pin_14*/; GPIO_Init(GPIOD, &structGPIO); //configure ADC /*power-on voltage reference*/ ADC_VoltageRegulatorCmd(ADC1, ENABLE); Delay(100); ADC_VoltageRegulatorCmd(ADC2, ENABLE); Delay(100); ADC_VoltageRegulatorCmd(ADC3, ENABLE); Delay(100); ADC_VoltageRegulatorCmd(ADC4, ENABLE); Delay(100); /*calibration*/ ADC_SelectCalibrationMode(ADC1, ADC_CalibrationMode_Single); ADC_StartCalibration(ADC1); while(ADC_GetCalibrationStatus(ADC1) != RESET ); ADC_SelectCalibrationMode(ADC2, ADC_CalibrationMode_Single); ADC_StartCalibration(ADC2); while(ADC_GetCalibrationStatus(ADC2) != RESET ); ADC_SelectCalibrationMode(ADC3, ADC_CalibrationMode_Single); ADC_StartCalibration(ADC3); while(ADC_GetCalibrationStatus(ADC3) != RESET ); ADC_SelectCalibrationMode(ADC4, ADC_CalibrationMode_Single); ADC_StartCalibration(ADC4); while(ADC_GetCalibrationStatus(ADC4) != RESET ); /*init logic*/ ADC_StructInit(&ADC_InitStructure); ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_7; ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Enable /*ADC_ContinuousConvMode_Disable*/; ADC_InitStructure.ADC_ExternalTrigEventEdge = ADC_ExternalTrigEventEdge_RisingEdge; ADC_Init(ADC1, &ADC_InitStructure); ADC_Init(ADC2, &ADC_InitStructure); ADC_InitStructure.ADC_ExternalTrigConvEvent = ADC_ExternalTrigConvEvent_4; ADC_Init(ADC3, &ADC_InitStructure); ADC_Init(ADC4, &ADC_InitStructure); ADC_CommonInitStructure.ADC_Mode = ADC_Mode_RegSimul; 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_CommonInit(ADC3, &ADC_CommonInitStructure); ADC_CommonInit(ADC2, &ADC_CommonInitStructure); ADC_CommonInit(ADC4, &ADC_CommonInitStructure); ADC_RegularChannelConfig(ADC1, ADC_Channel_3, 1, ADC_SampleTime_1Cycles5); ADC_RegularChannelConfig(ADC2, ADC_Channel_3, 1, ADC_SampleTime_1Cycles5); //514.3 kHz ADC_RegularChannelConfig(ADC3, ADC_Channel_1, 1, ADC_SampleTime_1Cycles5); ADC_RegularChannelConfig(ADC4, ADC_Channel_3, 1, ADC_SampleTime_1Cycles5); ADC_RegularChannelSequencerLengthConfig(ADC1, 1); ADC_RegularChannelSequencerLengthConfig(ADC2, 1); ADC_RegularChannelSequencerLengthConfig(ADC3, 1); ADC_RegularChannelSequencerLengthConfig(ADC4, 1); initial_opa(); //init NVIC ADC_ITConfig(ADC1, ADC_IT_EOC, ENABLE); NVIC_InitStructure.NVIC_IRQChannel = ADC1_2_IRQn; NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0; NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0; NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE; NVIC_Init(&NVIC_InitStructure); return; }
void VBatInit() { ADC_InitTypeDef ADC_InitStructure; ADC_CommonInitTypeDef ADC_CommonInitStructure; GPIO_InitTypeDef GPIO_InitStructure; GPIO_StructInit(&GPIO_InitStructure); /* ADC Channel configuration */ RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div2); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC12, ENABLE); /* GPIOC Periph clock enable */ RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE); /* Configure ADC Channel11 as analog input */ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 ; 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(ADC2, ENABLE); /* Insert delay equal to 10 µs */ delay_us(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_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(ADC2, &ADC_CommonInitStructure); ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Disable; 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(ADC2, &ADC_InitStructure); /* ADC2 regular channel11 configuration */ ADC_RegularChannelConfig(ADC2, ADC_Channel_11, 1, ADC_SampleTime_19Cycles5); /* Enable ADC2 */ ADC_Cmd(ADC2, ENABLE); /* wait for ADRDY */ while(!ADC_GetFlagStatus(ADC2, ADC_FLAG_RDY)); ADC_StartConversion(ADC2); }
static void adcInstanceInit(ADCDevice adcDevice) { ADC_InitTypeDef ADC_InitStructure; DMA_InitTypeDef DMA_InitStructure; ADC_CommonInitTypeDef ADC_CommonInitStructure; adcDevice_t * adc = &adcHardware[adcDevice]; RCC_ClockCmd(adc->rccADC, ENABLE); RCC_ClockCmd(adc->rccDMA, ENABLE); 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[adcDevice]; DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC; DMA_InitStructure.DMA_BufferSize = adc->usedChannelCount * ADC_AVERAGE_N_SAMPLES; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_MemoryInc = ((adc->usedChannelCount > 1) || (ADC_AVERAGE_N_SAMPLES > 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_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 = adc->usedChannelCount; ADC_Init(adc->ADCx, &ADC_InitStructure); uint8_t rank = 1; for (int i = ADC_CHN_1; i < ADC_CHN_COUNT; i++) { if (!adcConfig[i].enabled || adcConfig[i].adcDevice != adcDevice) { continue; } ADC_RegularChannelConfig(adc->ADCx, adcConfig[i].adcChannel, rank++, adcConfig[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); }
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
void ADC_init(void) { ADC_InitTypeDef ADC_InitStructure; ADC_CommonInitTypeDef ADC_CommonInitStructure; GPIO_InitTypeDef GPIO_InitStructure; ADC_InjectedInitTypeDef ADC_InjectedInitStruct; RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div1); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC12, ENABLE); RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, ENABLE); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_0 | GPIO_Pin_1 | GPIO_Pin_2 | GPIO_Pin_3; GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AN; GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL ; GPIO_Init(GPIOA, &GPIO_InitStructure); ADC_VoltageRegulatorCmd(ADC1, ENABLE); Delay_ms(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_OneShot; ADC_CommonInitStructure.ADC_TwoSamplingDelay = 0; ADC_CommonInit(ADC1, &ADC_CommonInitStructure); ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Disable; 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); ADC_InjectedInitStruct.ADC_ExternalTrigInjecConvEvent = ADC_ExternalTrigInjecConvEvent_9; ADC_InjectedInitStruct.ADC_ExternalTrigInjecEventEdge = ADC_ExternalTrigInjecEventEdge_RisingEdge; ADC_InjectedInitStruct.ADC_InjecSequence1 = ADC_InjectedChannel_1; /* to PA0 (Iout) */ ADC_InjectedInitStruct.ADC_InjecSequence2 = ADC_InjectedChannel_2; /* to PA1 (Vout) */ ADC_InjectedInitStruct.ADC_InjecSequence3 = ADC_InjectedChannel_3; /* to PA2 (Vext) */ ADC_InjectedInitStruct.ADC_InjecSequence4 = ADC_InjectedChannel_4; /* to PA3 (Vin) */ ADC_InjectedInitStruct.ADC_NbrOfInjecChannel = 4; ADC_InjectedInit(ADC1, &ADC_InjectedInitStruct); /* ADC1 channel2 configuration */ ADC_InjectedChannelSampleTimeConfig(ADC1, ADC_Channel_1, ADC_SampleTime_2Cycles5); /* Iout */ ADC_InjectedChannelSampleTimeConfig(ADC1, ADC_Channel_2, ADC_SampleTime_2Cycles5); /* Vout */ ADC_InjectedChannelSampleTimeConfig(ADC1, ADC_Channel_3, ADC_SampleTime_2Cycles5); /* Vext */ ADC_InjectedChannelSampleTimeConfig(ADC1, ADC_Channel_4, ADC_SampleTime_2Cycles5); /* Vin */ /* Enable ADC1 */ ADC_Cmd(ADC1, ENABLE); /* wait for ADRDY */ while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_RDY)); /* Start ADC1 Injected Conversions */ ADC_StartInjectedConversion(ADC1); }
/** * @brief Configures the ADC1 channel7 in continuous mode. * @param None * @retval None */ static void ADC_Config(void) { GPIO_InitTypeDef GPIO_InitStructure; ADC_InitTypeDef ADC_InitStructure; ADC_CommonInitTypeDef ADC_CommonInitStructure; /* Enable the GPIOC Clock */ RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOC, ENABLE); /* Configure the ADC clock */ RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div2); /* ADC1 Periph clock enable */ RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC12, ENABLE); /* Setup SysTick Timer for 1 µsec interrupts */ if (SysTick_Config(SystemCoreClock / 1000000)) { /* Capture error */ while (1) {} } /* Configure PC.1 (ADC Channel7) in analog mode */ GPIO_InitStructure.GPIO_Pin = GPIO_Pin_1; 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_Single); ADC_StartCalibration(ADC1); while(ADC_GetCalibrationStatus(ADC1) != RESET ); calibration_value = ADC_GetCalibrationValue(ADC1); /* Configure the ADC1 in continuous mode */ 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 configuration */ ADC_RegularChannelConfig(ADC1, ADC_Channel_7, 1, ADC_SampleTime_181Cycles5); /* Enable ADC1 */ ADC_Cmd(ADC1, ENABLE); /* wait for ADRDY */ while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_RDY)); /* ADC1 DMA Enable */ ADC_DMACmd(ADC1, ENABLE); ADC_DMAConfig(ADC1, ADC_DMAMode_Circular); /* Start ADC1 Software Conversion */ 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); }
/** * @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(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); }
//CURRENT_ADC: PA0 ADC1_IN1 //OUTPUT_ADC: PA1 ADC1_IN2 //SUPPLY_ADC: PA2 ADC1_IN3 //AUDIO_ADC: PA3 ADC1_IN4 void ADC_config(){ ADC_InitTypeDef ADC_InitStructure; ADC_CommonInitTypeDef ADC_CommonInitStructure; ADC_InjectedInitTypeDef ADC_InjectedInitStruct; /* Configure the ADC clock */ RCC_ADCCLKConfig(RCC_ADC12PLLCLK_Div1); /* Enable ADC1 clock */ RCC_AHBPeriphClockCmd(RCC_AHBPeriph_ADC12, ENABLE); //enable power to ADC ADC_VoltageRegulatorCmd(ADC1, ENABLE); msDelay(1); //allow power to stabilize //calibrate the ADC ADC_SelectCalibrationMode(ADC1, ADC_CalibrationMode_Single); ADC_StartCalibration(ADC1); while(ADC_GetCalibrationStatus(ADC1) != RESET ); //wait for finish //structure to init 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); //init the ADC //more detailed init structure //do not set up in regular sampling mode, want injected sampling mode ADC_InitStructure.ADC_ContinuousConvMode = ADC_ContinuousConvMode_Disable; 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); //set up ADC injection sampling //injected event comes from page 230 of the refrence manual //HRTIM_ADCTRG2 event ADC_InjectedInitStruct.ADC_ExternalTrigInjecConvEvent = ADC_ExternalTrigInjecConvEvent_9; ADC_InjectedInitStruct.ADC_ExternalTrigInjecEventEdge = ADC_ExternalTrigInjecEventEdge_RisingEdge; ADC_InjectedInitStruct.ADC_InjecSequence1 = ADC_InjectedChannel_1; /* corresponds to PA0 (CURRENT_ADC) */ ADC_InjectedInitStruct.ADC_InjecSequence2 = ADC_InjectedChannel_2; /* corresponds to PA1 (OUTPUT_ADC) */ ADC_InjectedInitStruct.ADC_InjecSequence3 = ADC_InjectedChannel_3; /* corresponds to PA2 (SUPPLY_ADC) */ ADC_InjectedInitStruct.ADC_InjecSequence4 = ADC_InjectedChannel_4; /* corresponds to PA3 (AUDIO_ADC) */ ADC_InjectedInitStruct.ADC_NbrOfInjecChannel = 4; ADC_InjectedInit(ADC1, &ADC_InjectedInitStruct); ADC_InjectedChannelSampleTimeConfig(ADC1, ADC_Channel_1, ADC_SampleTime_7Cycles5); //~15ns time constant ADC_InjectedChannelSampleTimeConfig(ADC1, ADC_Channel_2, ADC_SampleTime_7Cycles5); //clk is 14ns ADC_InjectedChannelSampleTimeConfig(ADC1, ADC_Channel_3, ADC_SampleTime_7Cycles5); //~7 time constants ADC_InjectedChannelSampleTimeConfig(ADC1, ADC_Channel_4, ADC_SampleTime_7Cycles5); ADC_Cmd(ADC1, ENABLE); //enable ADC // wait for adc to be ready while(!ADC_GetFlagStatus(ADC1, ADC_FLAG_RDY)); //Start ADC1 Injected Conversions //this actually just enables it ADC_StartInjectedConversion(ADC1); }
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); }
//-----------------------Public functions------------------------------// void InitializeADC( uint8_t GPIO_Selector ) { static uint8_t AlreadyDone = 0; if( 0 == AlreadyDone ) { AlreadyDone = 1; DMA_InitTypeDef DMA_InitStructure; DMA_DeInit(DMA2_Channel2); DMA_InitStructure.DMA_PeripheralBaseAddr = (uint32_t)&ADC4->DR; DMA_InitStructure.DMA_PeripheralInc = DMA_PeripheralInc_Disable; DMA_InitStructure.DMA_PeripheralDataSize = DMA_PeripheralDataSize_HalfWord; DMA_InitStructure.DMA_MemoryBaseAddr = (uint32_t)AdcBufferTable; DMA_InitStructure.DMA_MemoryInc = DMA_MemoryInc_Enable; DMA_InitStructure.DMA_MemoryDataSize = DMA_MemoryDataSize_HalfWord; DMA_InitStructure.DMA_DIR = DMA_DIR_PeripheralSRC; DMA_InitStructure.DMA_BufferSize = 2; DMA_InitStructure.DMA_Mode = DMA_Mode_Circular; DMA_InitStructure.DMA_Priority = DMA_Priority_High; DMA_InitStructure.DMA_M2M = DMA_M2M_Disable; DMA_Init(DMA2_Channel2, &DMA_InitStructure); /* Enable DMA2 Channel2 */ DMA_Cmd(DMA2_Channel2, ENABLE); ADC_InitTypeDef ADC_InitStructure; ADC_CommonInitTypeDef ADC_CommonInitStructure; ADC_StructInit(&ADC_InitStructure); /* Calibration procedure */ ADC_VoltageRegulatorCmd(ADC4, ENABLE); /* Insert delay equal to 10 µs */ uint32_t i; for( i = 0; i < 720; i++ ); ADC_SelectCalibrationMode(ADC4, ADC_CalibrationMode_Single); ADC_StartCalibration(ADC4); while(ADC_GetCalibrationStatus(ADC4) != RESET ); ADC_CommonInitStructure.ADC_Mode = ADC_Mode_Independent; ADC_CommonInitStructure.ADC_Clock = ADC_Clock_AsynClkMode; ADC_CommonInitStructure.ADC_DMAAccessMode = ADC_DMAAccessMode_1; ADC_CommonInitStructure.ADC_DMAMode = ADC_DMAMode_Circular; 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_1; 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 = 2; ADC_Init(ADC4, &ADC_InitStructure); ADC_RegularChannelConfig(ADC4, ADC_BATTERY_CHANNEL, BatteryNumber, ADC_SampleTime_61Cycles5); ADC_RegularChannelConfig(ADC4, ADC_SHARP_CHANNEL, SharpNumber, ADC_SampleTime_61Cycles5); ADC_Cmd(ADC4, ENABLE); /* wait for ADRDY */ while(!ADC_GetFlagStatus(ADC4, ADC_FLAG_RDY)); /* ADC1 DMA Enable */ ADC_DMACmd(ADC4, ENABLE); ADC_DMAConfig(ADC4, ADC_DMAMode_Circular); /* Start ADC1 Software Conversion */ ADC_StartConversion(ADC4); } }