ADC in continuous mode only reading once

[RPape.1]

I am trying to read data using ADC1 continuously and copy it into a buffer via DMA.

However, the data is only read and copied once (seemingly correctly), and afterwards nothing happens anymore (data in buffer does not change, ADC1_IRQHandler() is not called anymore).

If I set a breakpoint somewhere in the program, the value of the ADC_CFGR register equals 2147495944, i. e. the DMNGT bits are both 0. Shouldn't they be both 1, as I enabled DMA Circular Mode?

As you can see in the code, the MX_DMA_Init() function is called before HAL_ADC_Init(), which was seemingly a bug in earlier versions of STM32CubeIDE (see this thread: How to enable ADC continuous mode with DMA? (st.com)).

I already tried setting the DMNGT bits manually and also tried setting the ADSTART bit manually in the ADC1_IRQHandler() on EOC interrupt, but both did not work.

I am using an STM32MP153AAB3 on a custom board.

The relevant parts of code look like this (I left out unrelated things, timer inits etc. for the sake of clarity):

main.cpp:

/* Private variables ---------------------------------------------------------*/
ADC_HandleTypeDef hadc1;
DMA_HandleTypeDef hdma_adc1;
IPCC_HandleTypeDef hipcc;
 
static MyAdc myAdc(ADC1, ADC_CHANNEL_12, &hadc1);
static MyMeasurement myMeasurement{&myAdc};
 
/* USER CODE END PV */
 
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_IPCC_Init(void);
 
/* 
... 
*/
 
int main(void)
{
 /* USER CODE BEGIN 1 */
 /* USER CODE END 1 */
 
 /* MCU Configuration--------------------------------------------------------*/
 
 /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
 HAL_Init();
 
 /* USER CODE BEGIN Init */
 
 /* USER CODE END Init */
 
 if(IS_ENGINEERING_BOOT_MODE())
 {
 /* Configure the system clock */
 SystemClock_Config();
 }
 else
 {
 /* IPCC initialisation */
 MX_IPCC_Init();
 }
 
 /* USER CODE BEGIN SysInit */
 
 /* USER CODE END SysInit */
 
 /* Initialize all configured peripherals */
 MX_GPIO_Init();
 /* USER CODE BEGIN 2 */
 
 MX_DMA_Init();
 myMeasurement.init();
 
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
 
	/* USER CODE END WHILE */
 /* USER CODE BEGIN 3 */
 }
 /* USER CODE END 3 */
}
 
 
/**
 * @brief System Clock Configuration
 * @retval None
 */
void SystemClock_Config(void)
{
 RCC_OscInitTypeDef RCC_OscInitStruct = {0};
 RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
 
 /** Initializes the RCC Oscillators according to the specified parameters
 * in the RCC_OscInitTypeDef structure.
 */
 RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI;
 RCC_OscInitStruct.HSIState = RCC_HSI_ON;
 RCC_OscInitStruct.HSIDivValue = RCC_HSI_DIV1;
 RCC_OscInitStruct.PLL.PLLState = RCC_PLL_NONE;
 RCC_OscInitStruct.PLL2.PLLState = RCC_PLL_NONE;
 RCC_OscInitStruct.PLL3.PLLState = RCC_PLL_NONE;
 RCC_OscInitStruct.PLL4.PLLState = RCC_PLL_ON;
 RCC_OscInitStruct.PLL4.PLLSource = RCC_PLL4SOURCE_HSI;
 RCC_OscInitStruct.PLL4.PLLM = 4;
 RCC_OscInitStruct.PLL4.PLLN = 25;
 RCC_OscInitStruct.PLL4.PLLP = 2;
 RCC_OscInitStruct.PLL4.PLLQ = 2;
 RCC_OscInitStruct.PLL4.PLLR = 4;
 RCC_OscInitStruct.PLL4.PLLRGE = RCC_PLL4IFRANGE_1;
 RCC_OscInitStruct.PLL4.PLLFRACV = 0;
 RCC_OscInitStruct.PLL4.PLLMODE = RCC_PLL_INTEGER;
 if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
 {
 Error_Handler();
 }
 
 /** RCC Clock Config
 */
 RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_ACLK
 |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2
 |RCC_CLOCKTYPE_PCLK3|RCC_CLOCKTYPE_PCLK4
 |RCC_CLOCKTYPE_PCLK5;
 RCC_ClkInitStruct.AXISSInit.AXI_Clock = RCC_AXISSOURCE_HSI;
 RCC_ClkInitStruct.AXISSInit.AXI_Div = RCC_AXI_DIV1;
 RCC_ClkInitStruct.MCUInit.MCU_Clock = RCC_MCUSSOURCE_HSI;
 RCC_ClkInitStruct.MCUInit.MCU_Div = RCC_MCU_DIV1;
 RCC_ClkInitStruct.APB4_Div = RCC_APB4_DIV1;
 RCC_ClkInitStruct.APB5_Div = RCC_APB5_DIV1;
 RCC_ClkInitStruct.APB1_Div = RCC_APB1_DIV1;
 RCC_ClkInitStruct.APB2_Div = RCC_APB2_DIV1;
 RCC_ClkInitStruct.APB3_Div = RCC_APB3_DIV1;
 
 if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct) != HAL_OK)
 {
 Error_Handler();
 }
}
 
/**
 * Enable DMA controller clock
 */
static void MX_DMA_Init(void)
{
 
 /* DMA controller clock enable */
 __HAL_RCC_DMAMUX_CLK_ENABLE();
 __HAL_RCC_DMA2_CLK_ENABLE();
 
 /* DMA interrupt init */
 /* DMA2_Stream0_IRQn interrupt configuration */
 HAL_NVIC_SetPriority(DMA2_Stream0_IRQn, 0, 0);
 HAL_NVIC_EnableIRQ(DMA2_Stream0_IRQn);
 
}

MyMeasurement.cpp:

MyMeasurement::MyMeasurement(MyAdc* myAdc)
{
 this->myAdc= myAdc;
}
 
void MyMeasurement::init()
{
 myAdc->Init();
 myAdc->Start();
}

MyAdc.cpp:

MyAdc::MyAdc(ADC_TypeDef* adc, uint32_t adcChannel, ADC_HandleTypeDef* adcHandle)
{
 this->adcChannel = adcChannel;
 this->adcHandle = adcHandle;
 
 /** Common config
 */
 adcHandle->Instance = adc;
 adcHandle->Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV2;
 adcHandle->Init.Resolution = ADC_RESOLUTION_12B;
 adcHandle->Init.ScanConvMode = ADC_SCAN_DISABLE;
 adcHandle->Init.EOCSelection = ADC_EOC_SEQ_CONV;
 adcHandle->Init.LowPowerAutoWait = DISABLE;
 adcHandle->Init.ContinuousConvMode = ENABLE;
 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.ConversionDataManagement = ADC_CONVERSIONDATA_DMA_CIRCULAR;
 adcHandle->Init.Overrun = ADC_OVR_DATA_OVERWRITTEN;
 adcHandle->Init.OversamplingMode = DISABLE;
}
 
void MyAdc::Init(void)
{
 ASSERT(HAL_ADC_DeInit(adcHandle) == HAL_OK);
 ASSERT(HAL_ADC_Init(adcHandle) == HAL_OK);
 
 /** Configure the ADC multi-mode
 */
 ADC_MultiModeTypeDef multimode = {0};
 multimode.Mode = ADC_MODE_INDEPENDENT; // multi-mode disabled
 ASSERT(HAL_ADCEx_MultiModeConfigChannel(adcHandle, &multimode) == HAL_OK);
 
 /** Configure Regular Channel
 */
 ADC_ChannelConfTypeDef sConfig = {0};
 sConfig.Channel = adcChannel;
 sConfig.Rank = ADC_REGULAR_RANK_1;
 sConfig.SamplingTime = ADC_SAMPLETIME_387CYCLES_5; 
 sConfig.SingleDiff = ADC_SINGLE_ENDED;
 sConfig.OffsetNumber = ADC_OFFSET_NONE;
 sConfig.Offset = 0;
 
 HAL_ADC_ConfigChannel(adcHandle, &sConfig);
 
 /* Run the ADC calibration in single-ended mode */
 ASSERT(HAL_ADCEx_Calibration_Start(adcHandle, ADC_CALIB_OFFSET_LINEARITY, ADC_SINGLE_ENDED) == HAL_OK);
 
 // enable End of Conversion interrupt (call ADC1_IRQHandler at the end of each conversion)
 SET_BIT(adcHandle->Instance->IER, ADC_IER_EOCIE);
}
 
void MyAdc::Start()
{
 ASSERT(HAL_ADC_Start_DMA(adcHandle, (uint32_t*) &samplingData[0], BUFFER_SIZE) == HAL_OK);
}