Skip to main content
N
NRumm.1
Explorer II
January 27, 2024
Solved

ADC in dual regular simultaneous mode - no DMA result

  • January 27, 2024
  • 1 reply
  • 2110 views

Hi, I'm using ADC1 and ADC2 of a STM32F303RE in dual regular simultaneous mode. Each ADC should sample 5 independent channels and a sampling cycle is triggered by software, so I don't use continuous mode.

I do get DMA interrupts and everything seems to work fine, except that the buffer which should contain the ADC samples which got transferred by DMA is untouched - no results transferred.

adc.c is:

 

 

 

void MX_ADC1_Init(void)
{

 /* USER CODE BEGIN ADC1_Init 0 */

 /* USER CODE END ADC1_Init 0 */

 ADC_MultiModeTypeDef multimode = {0};
 ADC_ChannelConfTypeDef sConfig = {0};

 /* USER CODE BEGIN ADC1_Init 1 */

 /* USER CODE END ADC1_Init 1 */

 /** Common config
 */
 hadc1.Instance = ADC1;
 hadc1.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV1;
 hadc1.Init.Resolution = ADC_RESOLUTION_10B;
 hadc1.Init.ScanConvMode = ADC_SCAN_ENABLE;
 hadc1.Init.ContinuousConvMode = DISABLE;
 hadc1.Init.DiscontinuousConvMode = DISABLE;
 hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
 hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
 hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
 hadc1.Init.NbrOfConversion = 5;
 hadc1.Init.DMAContinuousRequests = ENABLE;
 hadc1.Init.EOCSelection = ADC_EOC_SEQ_CONV;
 hadc1.Init.LowPowerAutoWait = DISABLE;
 hadc1.Init.Overrun = ADC_OVR_DATA_PRESERVED;
 if (HAL_ADC_Init(&hadc1) != HAL_OK)
 {
 Error_Handler();
 }

 /** Configure the ADC multi-mode
 */
 multimode.Mode = ADC_DUALMODE_REGSIMULT;
 multimode.DMAAccessMode = ADC_DMAACCESSMODE_12_10_BITS;
 multimode.TwoSamplingDelay = ADC_TWOSAMPLINGDELAY_1CYCLE;
 if (HAL_ADCEx_MultiModeConfigChannel(&hadc1, &multimode) != HAL_OK)
 {
 Error_Handler();
 }

 /** Configure Regular Channel
 */
 sConfig.Channel = ADC_CHANNEL_1;
 sConfig.Rank = ADC_REGULAR_RANK_1;
 sConfig.SingleDiff = ADC_SINGLE_ENDED;
 sConfig.SamplingTime = ADC_SAMPLETIME_61CYCLES_5;
 sConfig.OffsetNumber = ADC_OFFSET_NONE;
 sConfig.Offset = 0;
 if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
 {
 Error_Handler();
 }

 /** Configure Regular Channel
 */
 sConfig.Channel = ADC_CHANNEL_2;
 sConfig.Rank = ADC_REGULAR_RANK_2;
 if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
 {
 Error_Handler();
 }

 /** Configure Regular Channel
 */
 sConfig.Channel = ADC_CHANNEL_3;
 sConfig.Rank = ADC_REGULAR_RANK_3;
 if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
 {
 Error_Handler();
 }

 /** Configure Regular Channel
 */
 sConfig.Channel = ADC_CHANNEL_4;
 sConfig.Rank = ADC_REGULAR_RANK_4;
 if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
 {
 Error_Handler();
 }

 /** Configure Regular Channel
 */
 sConfig.Channel = ADC_CHANNEL_TEMPSENSOR;
 sConfig.Rank = ADC_REGULAR_RANK_5;
 if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
 {
 Error_Handler();
 }
 /* USER CODE BEGIN ADC1_Init 2 */

 /* USER CODE END ADC1_Init 2 */

}
/* ADC2 init function */
void MX_ADC2_Init(void)
{

 /* USER CODE BEGIN ADC2_Init 0 */

 /* USER CODE END ADC2_Init 0 */

 ADC_ChannelConfTypeDef sConfig = {0};

 /* USER CODE BEGIN ADC2_Init 1 */

 /* USER CODE END ADC2_Init 1 */

 /** Common config
 */
 hadc2.Instance = ADC2;
 hadc2.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV1;
 hadc2.Init.Resolution = ADC_RESOLUTION_10B;
 hadc2.Init.ScanConvMode = ADC_SCAN_ENABLE;
 hadc2.Init.ContinuousConvMode = DISABLE;
 hadc2.Init.DiscontinuousConvMode = DISABLE;
 hadc2.Init.DataAlign = ADC_DATAALIGN_RIGHT;
 hadc2.Init.NbrOfConversion = 5;
 hadc2.Init.DMAContinuousRequests = DISABLE;
 hadc2.Init.EOCSelection = ADC_EOC_SEQ_CONV;
 hadc2.Init.LowPowerAutoWait = DISABLE;
 hadc2.Init.Overrun = ADC_OVR_DATA_PRESERVED;
 if (HAL_ADC_Init(&hadc2) != HAL_OK)
 {
 Error_Handler();
 }

 /** Configure Regular Channel
 */
 sConfig.Channel = ADC_CHANNEL_1;
 sConfig.Rank = ADC_REGULAR_RANK_1;
 sConfig.SingleDiff = ADC_SINGLE_ENDED;
 sConfig.SamplingTime = ADC_SAMPLETIME_61CYCLES_5;
 sConfig.OffsetNumber = ADC_OFFSET_NONE;
 sConfig.Offset = 0;
 if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
 {
 Error_Handler();
 }

 /** Configure Regular Channel
 */
 sConfig.Channel = ADC_CHANNEL_2;
 sConfig.Rank = ADC_REGULAR_RANK_2;
 if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
 {
 Error_Handler();
 }

 /** Configure Regular Channel
 */
 sConfig.Channel = ADC_CHANNEL_3;
 sConfig.Rank = ADC_REGULAR_RANK_3;
 if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
 {
 Error_Handler();
 }

 /** Configure Regular Channel
 */
 sConfig.Channel = ADC_CHANNEL_4;
 sConfig.Rank = ADC_REGULAR_RANK_4;
 if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
 {
 Error_Handler();
 }

 /** Configure Regular Channel
 */
 sConfig.Channel = ADC_CHANNEL_5;
 sConfig.Rank = ADC_REGULAR_RANK_5;
 if (HAL_ADC_ConfigChannel(&hadc2, &sConfig) != HAL_OK)
 {
 Error_Handler();
 }
 /* USER CODE BEGIN ADC2_Init 2 */

 /* USER CODE END ADC2_Init 2 */

}

static uint32_t HAL_RCC_ADC12_CLK_ENABLED=0;

void HAL_ADC_MspInit(ADC_HandleTypeDef* adcHandle)
{

 GPIO_InitTypeDef GPIO_InitStruct = {0};
 if(adcHandle->Instance==ADC1)
 {
 /* USER CODE BEGIN ADC1_MspInit 0 */

 /* USER CODE END ADC1_MspInit 0 */
 /* ADC1 clock enable */
 HAL_RCC_ADC12_CLK_ENABLED++;
 if(HAL_RCC_ADC12_CLK_ENABLED==1){
 __HAL_RCC_ADC12_CLK_ENABLE();
 }

 __HAL_RCC_GPIOC_CLK_ENABLE();
 __HAL_RCC_GPIOA_CLK_ENABLE();
 /**ADC1 GPIO Configuration
 PC0 ------> ADC1_IN6
 PA0 ------> ADC1_IN1
 PA1 ------> ADC1_IN2
 PA2 ------> ADC1_IN3
 PA3 ------> ADC1_IN4
 */
 GPIO_InitStruct.Pin = ADC9_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 HAL_GPIO_Init(ADC9_GPIO_Port, &GPIO_InitStruct);

 GPIO_InitStruct.Pin = ADC0_Pin|ADC1_Pin|ADC2_Pin|ADC3_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

 /* ADC1 DMA Init */
 /* ADC1 Init */
 hdma_adc1.Instance = DMA1_Channel1;
 hdma_adc1.Init.Direction = DMA_PERIPH_TO_MEMORY;
 hdma_adc1.Init.PeriphInc = DMA_PINC_DISABLE;
 hdma_adc1.Init.MemInc = DMA_MINC_ENABLE;
 hdma_adc1.Init.PeriphDataAlignment = DMA_PDATAALIGN_WORD;
 hdma_adc1.Init.MemDataAlignment = DMA_MDATAALIGN_WORD;
 hdma_adc1.Init.Mode = DMA_CIRCULAR;
 hdma_adc1.Init.Priority = DMA_PRIORITY_LOW;
 if (HAL_DMA_Init(&hdma_adc1) != HAL_OK)
 {
 Error_Handler();
 }

 __HAL_LINKDMA(adcHandle,DMA_Handle,hdma_adc1);

 /* USER CODE BEGIN ADC1_MspInit 1 */

 /* USER CODE END ADC1_MspInit 1 */
 }
 else if(adcHandle->Instance==ADC2)
 {
 /* USER CODE BEGIN ADC2_MspInit 0 */

 /* USER CODE END ADC2_MspInit 0 */
 /* ADC2 clock enable */
 HAL_RCC_ADC12_CLK_ENABLED++;
 if(HAL_RCC_ADC12_CLK_ENABLED==1){
 __HAL_RCC_ADC12_CLK_ENABLE();
 }

 __HAL_RCC_GPIOA_CLK_ENABLE();
 __HAL_RCC_GPIOC_CLK_ENABLE();
 /**ADC2 GPIO Configuration
 PA4 ------> ADC2_IN1
 PA5 ------> ADC2_IN2
 PA6 ------> ADC2_IN3
 PA7 ------> ADC2_IN4
 PC4 ------> ADC2_IN5
 */
 GPIO_InitStruct.Pin = ADC4_Pin|ADC5_Pin|ADC6_Pin|ADC7_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

 GPIO_InitStruct.Pin = ADC8_Pin;
 GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
 GPIO_InitStruct.Pull = GPIO_NOPULL;
 HAL_GPIO_Init(ADC8_GPIO_Port, &GPIO_InitStruct);

 /* USER CODE BEGIN ADC2_MspInit 1 */

 /* USER CODE END ADC2_MspInit 1 */
 }
}

void HAL_ADC_MspDeInit(ADC_HandleTypeDef* adcHandle)
{

 if(adcHandle->Instance==ADC1)
 {
 /* USER CODE BEGIN ADC1_MspDeInit 0 */

 /* USER CODE END ADC1_MspDeInit 0 */
 /* Peripheral clock disable */
 HAL_RCC_ADC12_CLK_ENABLED--;
 if(HAL_RCC_ADC12_CLK_ENABLED==0){
 __HAL_RCC_ADC12_CLK_DISABLE();
 }

 /**ADC1 GPIO Configuration
 PC0 ------> ADC1_IN6
 PA0 ------> ADC1_IN1
 PA1 ------> ADC1_IN2
 PA2 ------> ADC1_IN3
 PA3 ------> ADC1_IN4
 */
 HAL_GPIO_DeInit(ADC9_GPIO_Port, ADC9_Pin);

 HAL_GPIO_DeInit(GPIOA, ADC0_Pin|ADC1_Pin|ADC2_Pin|ADC3_Pin);

 /* ADC1 DMA DeInit */
 HAL_DMA_DeInit(adcHandle->DMA_Handle);
 /* USER CODE BEGIN ADC1_MspDeInit 1 */

 /* USER CODE END ADC1_MspDeInit 1 */
 }
 else if(adcHandle->Instance==ADC2)
 {
 /* USER CODE BEGIN ADC2_MspDeInit 0 */

 /* USER CODE END ADC2_MspDeInit 0 */
 /* Peripheral clock disable */
 HAL_RCC_ADC12_CLK_ENABLED--;
 if(HAL_RCC_ADC12_CLK_ENABLED==0){
 __HAL_RCC_ADC12_CLK_DISABLE();
 }

 /**ADC2 GPIO Configuration
 PA4 ------> ADC2_IN1
 PA5 ------> ADC2_IN2
 PA6 ------> ADC2_IN3
 PA7 ------> ADC2_IN4
 PC4 ------> ADC2_IN5
 */
 HAL_GPIO_DeInit(GPIOA, ADC4_Pin|ADC5_Pin|ADC6_Pin|ADC7_Pin);

 HAL_GPIO_DeInit(ADC8_GPIO_Port, ADC8_Pin);

 /* USER CODE BEGIN ADC2_MspDeInit 1 */

 /* USER CODE END ADC2_MspDeInit 1 */
 }
}

 

 

 

main.c is, so DMA does get initialized before the ADC.

 

 

 

 /* Initialize all configured peripherals */
 MX_GPIO_Init();
 MX_DMA_Init();
 MX_ADC1_Init();
 MX_ADC2_Init();

 

 

 

ADC is initially started with...

 

 

 

HAL_StatusTypeDef AdcScreenSensor::start(void) {
	// start the slave
	HAL_StatusTypeDef ret = HAL_ADC_Start(m_hadc_slave);
	ETL_ASSERT(ret == HAL_OK, DriverException(E010204_UNABLE_TO_START_ADC));

	// start the master
	ret = HAL_ADCEx_MultiModeStart_DMA(m_hadc_master, m_sample_buffer/*._buffer*/, SCREEN_WIDTH / 2/*SAMPLE_BUFFER_SIZE*/);
	ETL_ASSERT(ret == HAL_OK, DriverException(E010206_UNABLE_TO_START_ADC_MULTIMODE));

	return ret;
}

 

 

 

Consecutive cycles are started with...

 

 

 

HAL_StatusTypeDef AdcScreenSensor::restart(void) {
	// restart the slave
	HAL_StatusTypeDef ret = HAL_ADC_Start(m_hadc_slave);
	ETL_ASSERT(ret == HAL_OK, DriverException(E010204_UNABLE_TO_START_ADC));

	// restart the master
	ret = HAL_ADCEx_MultiModeStart_DMA(m_hadc_master, m_sample_buffer/*._buffer*/, SCREEN_WIDTH / 2/*SAMPLE_BUFFER_SIZE*/);
	ETL_ASSERT(ret == HAL_OK, DriverException(E010211_UNABLE_TO_RESTART_ADC_MULTIMODE));

	return ret;
}

 

 

 

And after each cycle the ADC is stopped with...

 

 

 

HAL_StatusTypeDef AdcScreenSensor::stop(void) {
	HAL_StatusTypeDef ret = HAL_ADC_Stop_DMA(m_hadc_slave);
	ETL_ASSERT(ret != HAL_ERROR, DriverException(E010202_UNABLE_TO_STOP_ADC_MULTIMODE_DMA));

	ret = HAL_ADCEx_MultiModeStop_DMA(m_hadc_master);
	ETL_ASSERT(ret == HAL_OK, DriverException(E010202_UNABLE_TO_STOP_ADC_MULTIMODE_DMA));

	return ret;
}

 

 

 

The ISR for the DMA interrupts is...

 

 

 

void AdcScreenSensor::HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc) {
	ETL_ASSERT_OR_RETURN(instance != nullptr, DriverException(E010210_ADC_NOT_INITIALIZED));
	if (hadc == instance->m_hadc_master) {
		instance->copyFull();
		instance->m_isr_callback_queue->push_from_unlocked(0);
	}
}

 

 

 

The ISR does get called and the calling stack clearly shows that DMA is called properly:

NRumm1_0-1706385188133.png

However, the result buffer which should be filled with 5 x 32 bits of data is left untouched.

Fun fact: Calling HAL_ADCEx_MultiModeGetValue(m_hadc_master) in the ISR does give me the last result.

DMA settings for ADC1 are...

NRumm1_1-1706385325073.png

 

...and DMA settings for ADC2 are empty, so only one DMA channel is used:

NRumm1_2-1706385372075.png

I'm lost and the HAL documentation regarding dual regular simultaneous mode is almost non-existing. Any ideas ?

 

 

    This topic has been closed for replies.
    Best answer by NRumm.1

    Ok, I found the reason - my ADC wrapper was not that singleton as it should be.

    1 reply

    N
    NRumm.1AuthorAnswer
    Explorer II
    January 27, 2024

    Ok, I found the reason - my ADC wrapper was not that singleton as it should be.

    Terms & ConditionsAccessibility statement