/**
* @brief Configure ADC1 for being used with HRTIM
* @param None
* @retval None
*/
static void ADC_Config(void)
{
ADC_MultiModeTypeDef MultiModeConfig;
ADC_InjectionConfTypeDef InjectionConfig;
AdcHandle.Instance = ADC1;
/* ADC2 is working independently */
MultiModeConfig.DMAAccessMode = ADC_DMAACCESSMODE_DISABLED;
MultiModeConfig.Mode = ADC_MODE_INDEPENDENT;
MultiModeConfig.TwoSamplingDelay = ADC_TWOSAMPLINGDELAY_1CYCLE;
HAL_ADCEx_MultiModeConfigChannel(&AdcHandle, &MultiModeConfig);
/* ADC2 global initialization */
/* 12-bit right-aligned format, discontinuous scan mode, running from PLL */
AdcHandle.Init.ClockPrescaler = ADC_CLOCK_ASYNC;
AdcHandle.Init.Resolution = ADC_RESOLUTION12b;
AdcHandle.Init.DataAlign = ADC_DATAALIGN_RIGHT;
AdcHandle.Init.ScanConvMode = ENABLE;
AdcHandle.Init.EOCSelection = EOC_SINGLE_CONV;
AdcHandle.Init.LowPowerAutoWait = DISABLE;
AdcHandle.Init.ContinuousConvMode = DISABLE;
AdcHandle.Init.NbrOfConversion = 1;
AdcHandle.Init.DiscontinuousConvMode = DISABLE;
AdcHandle.Init.NbrOfDiscConversion = 1;
AdcHandle.Init.ExternalTrigConv = ADC_SOFTWARE_START;
AdcHandle.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
AdcHandle.Init.DMAContinuousRequests = DISABLE;
AdcHandle.Init.Overrun = OVR_DATA_OVERWRITTEN;
HAL_ADC_Init(&AdcHandle);
/* Discontinuous injected mode: 1st injected conversion for Vin on Ch2 */
InjectionConfig.InjectedChannel = ADC_CHANNEL_2;
InjectionConfig.InjectedRank = ADC_INJECTED_RANK_1;
InjectionConfig.InjectedSamplingTime = ADC_SAMPLETIME_7CYCLES_5;
InjectionConfig.InjectedSingleDiff = ADC_SINGLE_ENDED;
InjectionConfig.InjectedOffsetNumber = ADC_OFFSET_NONE;
InjectionConfig.InjectedOffset = 0;
InjectionConfig.InjectedNbrOfConversion = 2;
InjectionConfig.InjectedDiscontinuousConvMode = DISABLE;
InjectionConfig.AutoInjectedConv = DISABLE;
InjectionConfig.QueueInjectedContext = DISABLE;
InjectionConfig.ExternalTrigInjecConv = ADC_EXTERNALTRIGINJECCONV_HRTIM_TRG2;
InjectionConfig.ExternalTrigInjecConvEdge = ADC_EXTERNALTRIGINJECCONV_EDGE_RISING;
HAL_ADCEx_InjectedConfigChannel(&AdcHandle, &InjectionConfig);
/* Configure the 2nd injected conversion for Vout on Ch4 */
InjectionConfig.InjectedChannel = ADC_CHANNEL_4;
InjectionConfig.InjectedRank = ADC_INJECTED_RANK_2;
InjectionConfig.InjectedSamplingTime = ADC_SAMPLETIME_19CYCLES_5;
HAL_ADCEx_InjectedConfigChannel(&AdcHandle, &InjectionConfig);
/* Run the ADC calibration in single-ended mode */
HAL_ADCEx_Calibration_Start(&AdcHandle, ADC_SINGLE_ENDED);
/* Start ADC2 Injected Conversions */
HAL_ADCEx_InjectedStart(&AdcHandle);
}
void init_adc1(void)
{
GPIO_InitTypeDef GPIO_InitStruct;
//Enable peripheral and GPIO clocks
__ADC1_CLK_ENABLE();
__GPIOA_CLK_ENABLE();
//AN0 to AN7 are on PA0 to PA7
//AN0 & 1: 1/10kHz LPF
//AN3 & 3: 1/10kHz LPF, 1<G<10
//AN4 & 5: Buffered
//AN6 & 7: Resistive dividers, buffered
//Config inputs:
GPIO_InitStruct.Pin = GPIO_PIN_0 | GPIO_PIN_1 | GPIO_PIN_2 | GPIO_PIN_3
| GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7;
GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
GPIO_InitStruct.Pull = GPIO_NOPULL;
HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
//ADC1 config: (ToDo: test & optimize, use DMA and multiple conversions)
//===========
//Configure the global features of the ADC (Clock, Resolution, Data Alignment and number of conversion)
hadc1.Instance = ADC1;
hadc1.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV2;
hadc1.Init.Resolution = ADC_RESOLUTION12b;
hadc1.Init.ScanConvMode = DISABLE;
hadc1.Init.ContinuousConvMode = DISABLE;
hadc1.Init.DiscontinuousConvMode = DISABLE;
hadc1.Init.NbrOfDiscConversion = 1;
hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hadc1.Init.NbrOfConversion = 1;
hadc1.Init.DMAContinuousRequests = DISABLE;
hadc1.Init.EOCSelection = EOC_SINGLE_CONV;
HAL_ADC_Init(&hadc1);
//Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time.
sConfig.Channel = ADC_CHANNEL_0;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
HAL_ADC_ConfigChannel(&hadc1, &sConfig);
//Configure the ADC multi-mode
multimode.Mode = ADC_MODE_INDEPENDENT;
multimode.TwoSamplingDelay = ADC_TWOSAMPLINGDELAY_5CYCLES;
HAL_ADCEx_MultiModeConfigChannel(&hadc1, &multimode);
}
STATIC void adc_init_single(pyb_obj_adc_t *adc_obj) {
if (!is_adcx_channel(adc_obj->channel)) {
return;
}
if (ADC_FIRST_GPIO_CHANNEL <= adc_obj->channel && adc_obj->channel <= ADC_LAST_GPIO_CHANNEL) {
// Channels 0-16 correspond to real pins. Configure the GPIO pin in ADC mode.
const pin_obj_t *pin = pin_adc_table[adc_obj->channel];
mp_hal_pin_config(pin, MP_HAL_PIN_MODE_ADC, MP_HAL_PIN_PULL_NONE, 0);
}
adcx_init_periph(&adc_obj->handle, ADC_RESOLUTION_12B);
#if defined(STM32L4) && defined(ADC_DUALMODE_REGSIMULT_INJECSIMULT)
ADC_MultiModeTypeDef multimode;
multimode.Mode = ADC_MODE_INDEPENDENT;
if (HAL_ADCEx_MultiModeConfigChannel(&adc_obj->handle, &multimode) != HAL_OK)
{
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Can not set multimode on ADC1 channel: %d", adc_obj->channel));
}
#endif
}
STATIC void adc_init_single(pyb_obj_adc_t *adc_obj) {
if (!is_adcx_channel(adc_obj->channel)) {
return;
}
if (ADC_FIRST_GPIO_CHANNEL <= adc_obj->channel && adc_obj->channel <= ADC_LAST_GPIO_CHANNEL) {
// Channels 0-16 correspond to real pins. Configure the GPIO pin in
// ADC mode.
const pin_obj_t *pin = pin_adc1[adc_obj->channel];
mp_hal_gpio_clock_enable(pin->gpio);
GPIO_InitTypeDef GPIO_InitStructure;
GPIO_InitStructure.Pin = pin->pin_mask;
#if defined(STM32F4) || defined(STM32F7)
GPIO_InitStructure.Mode = GPIO_MODE_ANALOG;
#elif defined(STM32L4)
GPIO_InitStructure.Mode = GPIO_MODE_ANALOG_ADC_CONTROL;
#else
#error Unsupported processor
#endif
GPIO_InitStructure.Pull = GPIO_NOPULL;
HAL_GPIO_Init(pin->gpio, &GPIO_InitStructure);
}
adcx_clock_enable();
ADC_HandleTypeDef *adcHandle = &adc_obj->handle;
adcHandle->Instance = ADCx;
adcHandle->Init.ContinuousConvMode = DISABLE;
adcHandle->Init.DiscontinuousConvMode = DISABLE;
adcHandle->Init.NbrOfDiscConversion = 0;
adcHandle->Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
adcHandle->Init.DataAlign = ADC_DATAALIGN_RIGHT;
adcHandle->Init.NbrOfConversion = 1;
adcHandle->Init.DMAContinuousRequests = DISABLE;
adcHandle->Init.Resolution = ADC_RESOLUTION_12B;
#if defined(STM32F4) || defined(STM32F7)
adcHandle->Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV2;
adcHandle->Init.ScanConvMode = DISABLE;
adcHandle->Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T1_CC1;
adcHandle->Init.EOCSelection = DISABLE;
#elif defined(STM32L4)
adcHandle->Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV1;
adcHandle->Init.ScanConvMode = ADC_SCAN_DISABLE;
adcHandle->Init.EOCSelection = ADC_EOC_SINGLE_CONV;
adcHandle->Init.ExternalTrigConv = ADC_SOFTWARE_START;
adcHandle->Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
adcHandle->Init.LowPowerAutoWait = DISABLE;
adcHandle->Init.Overrun = ADC_OVR_DATA_PRESERVED;
adcHandle->Init.OversamplingMode = DISABLE;
#else
#error Unsupported processor
#endif
HAL_ADC_Init(adcHandle);
#if defined(STM32L4)
ADC_MultiModeTypeDef multimode;
multimode.Mode = ADC_MODE_INDEPENDENT;
if (HAL_ADCEx_MultiModeConfigChannel(adcHandle, &multimode) != HAL_OK)
{
nlr_raise(mp_obj_new_exception_msg_varg(&mp_type_ValueError, "Can not set multimode on ADC1 channel: %d", adc_obj->channel));
}
#endif
}
/**
* @brief ADC configuration
* @note This function Configure the ADC peripheral
1) Enable peripheral clocks
2) Configure ADC Channel 12 pin as analog input
3) DMA2_Stream0 channel2 configuration
4) Configure ADC1 Channel 12
5) Configure ADC2 Channel 12
* @param None
* @retval None
*/
static void ADC_Config(void)
{
ADC_ChannelConfTypeDef sConfig;
ADC_MultiModeTypeDef mode;
/*##-1- Configure the ADC2 peripheral ######################################*/
AdcHandle2.Instance = ADCy;
AdcHandle2.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV2;
AdcHandle2.Init.Resolution = ADC_RESOLUTION_8B;
AdcHandle2.Init.ScanConvMode = ENABLE;
AdcHandle2.Init.ContinuousConvMode = ENABLE;
AdcHandle2.Init.DiscontinuousConvMode = DISABLE;
AdcHandle2.Init.NbrOfDiscConversion = 0;
AdcHandle2.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
AdcHandle2.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T1_CC1;
AdcHandle2.Init.DataAlign = ADC_DATAALIGN_RIGHT;
AdcHandle2.Init.NbrOfConversion = 1;
AdcHandle2.Init.DMAContinuousRequests = ENABLE;
AdcHandle2.Init.EOCSelection = ENABLE;
if(HAL_ADC_Init(&AdcHandle2) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Configure ADC2 regular channel #####################################*/
sConfig.Channel = ADCxy_CHANNEL;
sConfig.Rank = 1;
sConfig.SamplingTime = ADC_SAMPLETIME_3CYCLES;
sConfig.Offset = 0;
if(HAL_ADC_ConfigChannel(&AdcHandle2, &sConfig) != HAL_OK)
{
/* Channel Configuration Error */
Error_Handler();
}
/*##-3- Configure the ADC1 peripheral ######################################*/
AdcHandle1.Instance = ADCx;
AdcHandle1.Init.ClockPrescaler = ADC_CLOCKPRESCALER_PCLK_DIV2;
AdcHandle1.Init.Resolution = ADC_RESOLUTION_8B;
AdcHandle1.Init.ScanConvMode = DISABLE;
AdcHandle1.Init.ContinuousConvMode = ENABLE;
AdcHandle1.Init.DiscontinuousConvMode = DISABLE;
AdcHandle1.Init.NbrOfDiscConversion = 0;
AdcHandle1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
AdcHandle1.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T1_CC1;
AdcHandle1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
AdcHandle1.Init.NbrOfConversion = 1;
AdcHandle1.Init.DMAContinuousRequests = ENABLE;
AdcHandle1.Init.EOCSelection = ENABLE;
if(HAL_ADC_Init(&AdcHandle1) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-4- Configure ADC1 regular channel #####################################*/
if(HAL_ADC_ConfigChannel(&AdcHandle1, &sConfig) != HAL_OK)
{
/* Channel Configuration Error */
Error_Handler();
}
/*##-5- Configure Multimode ################################################*/
mode.Mode = ADC_DUALMODE_INTERL;
mode.DMAAccessMode = ADC_DMAACCESSMODE_3;
mode.TwoSamplingDelay = ADC_TWOSAMPLINGDELAY_6CYCLES;
if(HAL_ADCEx_MultiModeConfigChannel(&AdcHandle1, &mode) != HAL_OK)
{
/* Channel Configuration Error */
Error_Handler();
}
}
void MX_ADC1_Init(void) {
ADC_MultiModeTypeDef multimode;
ADC_ChannelConfTypeDef sConfig;
__HAL_RCC_ADC1_CLK_ENABLE();
hadc1.Instance = ADC1;
hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE;
hadc1.Init.ContinuousConvMode = DISABLE;
hadc1.Init.DiscontinuousConvMode = DISABLE;
hadc1.Init.ExternalTrigConv = ADC_EXTERNALTRIGCONV_T8_TRGO;
hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
hadc1.Init.NbrOfConversion = 5;
HAL_ADC_Init(&hadc1);
/**Enable or disable the remapping of ADC1_ETRGREG:
* ADC1 External Event regular conversion is connected to TIM8 TRG0
*/
__HAL_AFIO_REMAP_ADC1_ETRGREG_ENABLE();
/**Configure the ADC multi-mode
*/
multimode.Mode = ADC_DUALMODE_REGSIMULT;
HAL_ADCEx_MultiModeConfigChannel(&hadc1, &multimode);
sConfig.SamplingTime = ADC_SAMPLETIME_7CYCLES_5;
sConfig.Channel = ADC_CHANNEL_14;
sConfig.Rank = 1;
HAL_ADC_ConfigChannel(&hadc1, &sConfig);
sConfig.Channel = ADC_CHANNEL_0;
sConfig.Rank = 2;
HAL_ADC_ConfigChannel(&hadc1, &sConfig);
sConfig.SamplingTime = ADC_SAMPLETIME_13CYCLES_5;
sConfig.Channel = ADC_CHANNEL_11;
sConfig.Rank = 3;
HAL_ADC_ConfigChannel(&hadc1, &sConfig);
sConfig.Channel = ADC_CHANNEL_12;
sConfig.Rank = 4;
HAL_ADC_ConfigChannel(&hadc1, &sConfig);
sConfig.Channel = ADC_CHANNEL_12;
sConfig.Rank = 5;
HAL_ADC_ConfigChannel(&hadc1, &sConfig);
hadc1.Instance->CR2 |= ADC_CR2_DMA;
__HAL_ADC_ENABLE(&hadc1);
__HAL_RCC_DMA1_CLK_ENABLE();
DMA1_Channel1->CCR = 0;
DMA1_Channel1->CNDTR = 5;
DMA1_Channel1->CPAR = (uint32_t) & (ADC1->DR);
DMA1_Channel1->CMAR = (uint32_t)&adc_buffer;
DMA1_Channel1->CCR = DMA_CCR_MSIZE_1 | DMA_CCR_PSIZE_1 | DMA_CCR_MINC | DMA_CCR_CIRC | DMA_CCR_TCIE;
DMA1_Channel1->CCR |= DMA_CCR_EN;
HAL_NVIC_SetPriority(DMA1_Channel1_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(DMA1_Channel1_IRQn);
}
/**
* @brief ADC configuration
* @note This function configures the ADC peripheral
1) Configuration of ADCx peripheral (ADC master)
2) Configuration of ADCy peripheral (ADC slave)
3) Configuration of channel on ADCx regular group on rank 1
4) Configuration of channel on ADCy regular group on rank 1
5) Configuration of multimode
* @param None
* @retval None
*/
static void ADC_Config(void)
{
ADC_ChannelConfTypeDef sConfig;
ADC_MultiModeTypeDef mode;
/*##-1- Configuration of ADCx peripheral (ADC master) ######################*/
/* Configuration of ADCx init structure: ADC parameters and regular group */
AdcHandle_master.Instance = ADCx;
AdcHandle_master.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV1; /* ADC clock to AHB without prescaler to have maximum frequency 72MHz */
AdcHandle_master.Init.Resolution = ADC_RESOLUTION6b; /* ADC resolution 6 bits to have conversion time = 6.5 ADC clock cycles */
AdcHandle_master.Init.DataAlign = ADC_DATAALIGN_RIGHT;
AdcHandle_master.Init.ScanConvMode = DISABLE; /* Sequencer disabled (ADC conversion on only 1 channel: channel set on rank 1) */
AdcHandle_master.Init.EOCSelection = EOC_SINGLE_CONV;
AdcHandle_master.Init.LowPowerAutoWait = DISABLE;
AdcHandle_master.Init.ContinuousConvMode = ENABLE; /* Continuous mode to have maximum conversion speed (no delay between conversions) */
AdcHandle_master.Init.NbrOfConversion = 1; /* Parameter discarded because sequencer is disabled */
AdcHandle_master.Init.DiscontinuousConvMode = DISABLE; /* Parameter discarded because sequencer is disabled */
AdcHandle_master.Init.NbrOfDiscConversion = 1; /* Parameter discarded because sequencer is disabled */
AdcHandle_master.Init.ExternalTrigConv = ADC_SOFTWARE_START; /* Software start to trig the 1st conversion manually, without external event */
AdcHandle_master.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
AdcHandle_master.Init.DMAContinuousRequests = ENABLE; /* ADC-DMA continuous requests to match with DMA in circular mode */
AdcHandle_master.Init.Overrun = OVR_DATA_OVERWRITTEN;
if (HAL_ADC_Init(&AdcHandle_master) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-2- Configuration of ADCy peripheral (ADC slave) #######################*/
AdcHandle_slave.Instance = ADCy;
/* Configuration of ADCy init structure: ADC parameters and regular group */
/* Same configuration as ADCx */
AdcHandle_slave.Init = AdcHandle_master.Init;
if (HAL_ADC_Init(&AdcHandle_slave) != HAL_OK)
{
/* Initialization Error */
Error_Handler();
}
/*##-3- Configuration of channel on ADCx regular group on rank 1 ###########*/
sConfig.Channel = ADCx_CHANNELa;
sConfig.Rank = ADC_REGULAR_RANK_1;
sConfig.SamplingTime = ADC_SAMPLETIME_1CYCLE_5;
sConfig.Offset = 0;
if (HAL_ADC_ConfigChannel(&AdcHandle_master, &sConfig) != HAL_OK)
{
/* Channel Configuration Error */
Error_Handler();
}
/*##-4- Configuration of channel on ADCy regular group on rank 1 ###########*/
/* Same channel as ADCx for dual mode interleaved: both ADC are converting */
/* the same channel. */
sConfig.Channel = ADCx_CHANNELa;
if (HAL_ADC_ConfigChannel(&AdcHandle_slave, &sConfig) != HAL_OK)
{
/* Channel Configuration Error */
Error_Handler();
}
/*##-5- Configuration of multimode #########################################*/
/* Multimode parameters settings and set ADCy (slave) under control of */
/* ADCx (master). */
mode.Mode = ADC_DUALMODE_INTERL;
mode.DMAAccessMode = ADC_DMAACCESSMODE_8_6_BITS;
mode.TwoSamplingDelay = ADC_TWOSAMPLINGDELAY_3CYCLES;
if (HAL_ADCEx_MultiModeConfigChannel(&AdcHandle_master, &mode) != HAL_OK)
{
/* Channel Configuration Error */
Error_Handler();
}
}
