ADC1 not starting conversion with TIM2_TRGO trigger on STM32F407VET6 (bare metal, no HAL)

[cristianosar]

I'm working on a bare-metal project using an STM32F407VET6 (generic “black board” from China - https://stm32-base.org/boards/STM32F407VET6-STM32-F4VE-V2.0.html). I'm trying to trigger ADC1 conversions using TIM2_TRGO (timer trigger output), but the ADC only works when using SWSTART. I've done extensive testing and debugging to isolate the problem. Here's what I found:

What works:
ADC1 works with SWSTART: I can read from channel 1 (PA1) manually and see the expected values.

LED debug: PD12 lights up if the ADC reads a value above 1000.

TIM2 generates update events: Confirmed by enabling the TIM2 UIF interrupt and toggling PD12 on each update.

Trigger configuration:

EXTSEL = 4 → TIM2_TRGO

EXTEN = 1 → rising edge

Forced trigger via TIM2->EGR |= TIM_EGR_UG does not trigger the ADC.

VREF+ is connected to 3.3V, and VREF- to GND, with a 100nF decoupling cap.

TIM2_TRGO is confirmed to work via IRQ debug (PD12 blinks).

DMA is configured (when enabled), but never triggers → PD12 never toggles.

Debug setup:

I'm using a LED on PD12 to debug, I comment / uncomment the code during the tests.

PA1 is directly connected to a 3.3v source on the board.

PD12: toggles if ADC value > 1000

PD12: toggles in TIM2_IRQHandler() → confirms update event

PD12: toggles in DMA2_Stream0_IRQHandler() → never fires (ADC not triggering)

Problem:
ADC1 never starts conversion from external trigger (TRGO), despite all relevant settings and confirmed timer behavior. No conversion ever occurs unless I manually call SWSTART.

Am I doing something wrong or is there any undocumented requirement for STM32F4 (F407 specifically) to accept external triggers like TIM2_TRGO?
Are there any known silicon errata or obscure setup steps that could block the trigger path to the ADC?

My code (made with the help of ChatGpt) is the following:

#include "stm32f4xx.h"

void LED_Init(void);
void TIM2_TRGO_Init(void);
void ADC1_Trigger_TIM2_Setup(void);
void DMA2_Stream0_ADC_Config(void);


void LED_Init(void) {
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN;
    GPIOD->MODER |= (1 << (12 * 2));
}

void TIM2_TRGO_Init(void) {
    RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;

    TIM2->PSC = 84 - 1;       // 1 MHz
    TIM2->ARR = 10000 - 1;    // 10ms

    TIM2->EGR |= TIM_EGR_UG;        // FORÇA UPDATE ANTES DE CR2
    TIM2->CR2 &= ~TIM_CR2_MMS;      // Limpa
    TIM2->CR2 |= TIM_CR2_MMS_1;     // MMS = 010 (update event)

    TIM2->CR1 |= TIM_CR1_CEN;       // Agora sim liga o timer
    TIM2->DIER |= TIM_DIER_UIE;   // Habilita interrupção de update
    NVIC_EnableIRQ(TIM2_IRQn);    // NVIC
}

void ADC1_Trigger_TIM2_Setup(void) {
    RCC->APB2ENR |= RCC_APB2ENR_ADC1EN;
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
    GPIOA->MODER |= (3 << (1 * 2)); // PA1 analógico

    ADC1->CR2 = 0;
    ADC1->SQR3 = 1;
    ADC1->SMPR2 |= (7 << 3); // canal 1, 480 ciclos

    ADC1->CR2 |= (4 << ADC_CR2_EXTSEL_Pos); // TIM2_TRGO
    ADC1->CR2 |= (1 << ADC_CR2_EXTEN_Pos);  // rising edge
    ADC1->CR2 |= ADC_CR2_ADON;
    NVIC_EnableIRQ(DMA2_Stream0_IRQn); // interrupt
}


int main(void) {
    LED_Init();
    DMA2_Stream0_ADC_Config();
    ADC1_Trigger_TIM2_Setup();
    TIM2_TRGO_Init();

    while (1) {
        if (ADC1->SR & ADC_SR_EOC) {
            uint16_t value = ADC1->DR;

            if (value > 1000)
                GPIOD->ODR |= (1 << 12); // debug: NEVER TOGGLES
            else
                GPIOD->ODR &= ~(1 << 12);  // debug: NEVER TOGGLES
        }
    }
}

void TIM2_IRQHandler(void) {
    if (TIM2->SR & TIM_SR_UIF) {
        TIM2->SR &= ~TIM_SR_UIF;

        //  DEBUG: Pisca PD12 ao disparar TRGO
        // GPIOD->ODR ^= (1 << 12); // debug: OK
    }
}

void DMA2_Stream0_ADC_Config(void) {
    RCC->AHB1ENR |= RCC_AHB1ENR_DMA2EN; // Habilita clock do DMA2

    DMA2_Stream0->CR &= ~DMA_SxCR_EN; // Garante que o stream está desligado
    while (DMA2_Stream0->CR & DMA_SxCR_EN); // Espera desativação

    // Limpa flags de interrupção
    DMA2->LIFCR |= DMA_LIFCR_CTCIF0 | DMA_LIFCR_CHTIF0 |
                   DMA_LIFCR_CTEIF0 | DMA_LIFCR_CDMEIF0 | DMA_LIFCR_CFEIF0;

    // Configura o endereço do periférico (ADC1_DR)
    DMA2_Stream0->PAR = (uint32_t)&ADC1->DR;

    // Endereço do buffer na memória
    DMA2_Stream0->M0AR = (uint32_t)&adc_buffer[0];

    // Número de transferências
    DMA2_Stream0->NDTR = 1;

    // Configura canal 0 (para ADC1)
    DMA2_Stream0->CR =
        (0 << DMA_SxCR_CHSEL_Pos) |  // Canal 0
        (1 << DMA_SxCR_MSIZE_Pos) |  // Memória 16 bits
        (1 << DMA_SxCR_PSIZE_Pos) |  // Periférico 16 bits
        (1 << DMA_SxCR_MINC_Pos)  |  // Incrementa memória
        (0 << DMA_SxCR_PINC_Pos)  |  // Não incrementa periférico
        (0 << DMA_SxCR_CIRC_Pos)  |  // Sem circular (1 se quiser contínuo)
        (0 << DMA_SxCR_DIR_Pos)   |  // Periférico -> Memória
        (1 << DMA_SxCR_TCIE_Pos);    // Interrupção por transferência completa

    DMA2_Stream0->CR |= DMA_SxCR_EN; // Liga o DMA
}

void DMA2_Stream0_IRQHandler(void) {
    if (DMA2->LISR & DMA_LISR_TCIF0) {
        DMA2->LIFCR |= DMA_LIFCR_CTCIF0;

        //  DEBUG: Pisca PD12 quando o DMA completar
        GPIOD->ODR ^= (1 << 12); // debug: NEVER TOGGLES
    }
}

Thanks for the help.

[cristianosar · Accepted solution]

I've found the problem, the code above was missing 

DMA2_Stream0_ADC_Config

but the real problem was me setting the wrong bits of the external trigger:
changed from:

// ADC1->CR2 |= (4 << ADC_CR2_EXTSEL_Pos); // TIM2_TRGO

to

ADC1->CR2 |= (6 << ADC_CR2_EXTSEL_Pos); // TIM2_TRGO

Thanks all for the help.