Trigger ADC with TIM2 TRGO not showing correct timing

[cristianosar]

Im using the following code that is part of a metal detector I'm building. Im trying to trigger the ADC based on TRGO of TIM2 (I need dma / adc readings every 10us after the of each TX pulse). I expect the TIM2_IRQHandler interrupt to enter 10us (ADC_DELAY_US) after the TX pulse ends (TIM1_CC_IRQHandler). I added a buffer (buffer variable) to keep track of the milliseconds of the events but when I print it on gdb (print buffer) and then subtract tx_end_micros to adc_start_micros, I dont have 10us, as expected:

This is a print of the gdb:

 {{tx_end_micros = 2573435545, adc_start_micros = 2573437222, num_pulses = 2624525, num_pulses_tim2 = 2624526}, {tx_end_micros = 2573436545, adc_start_micros = 2573436542, 
    num_pulses = 2624526, num_pulses_tim2 = 2624527}}

Below is the full code:

#include <stdio.h>
#include "stm32f4xx.h"
#include <math.h>

// Function Prototypes
void SystemClock_Config(void);
void GPIO_Init(void);
void TIM1_PWM_Init(void);
void TIM5_Init(void);
void LED_Init(void);
void TIM2_TRGO_Init(void);
void ADC1_Trigger_TIM2_Setup(void);
uint16_t adc1_read(void);
float compute_average(void);
void Delay_us(uint32_t);
void send_uart(char *msg);
uint32_t micros(void);
void toggle_led(void);
void enviar_dados_adc_serial(void);
void reset_adc(void);

// Settings
#define ADC_DELAY_US 10      // Delay after TX pulse before ADC sampling
#define NUM_SAMPLES 64       // Number of ADC samples to capture

// For alignment in memory
volatile uint16_t adc_buffer[NUM_SAMPLES] __attribute__((aligned(4)));
volatile uint32_t tx_num_pulses = 0;
volatile uint8_t adc_capture_complete = 0;

typedef struct {
    uint32_t tx_end_micros;
    uint32_t adc_start_micros;
    uint32_t num_pulses;
    uint32_t num_pulses_tim2;
} TimingData;

volatile TimingData buffer[2];
volatile uint8_t current_buffer = 0;

volatile TimingData timing;  // Global instance, accessible in both ISRs

volatile uint32_t last_time;
volatile uint32_t curr_time = 0;
volatile uint32_t delta = 0;

void delay_ms(int milliseconds) {
    volatile int i;
    for (i = 0; i < milliseconds * 1000; i++) {
        __NOP();  // No operation, just waste time
    }
}

void reset_adc() {
    // Reset DMA for next capture
    ADC1->CR2 &= ~ADC_CR2_DMA; // Desliga DMA
    ADC1->CR2 |= ADC_CR2_DMA;  // Religa DMA
    DMA2_Stream0->CR &= ~DMA_SxCR_EN;
    while (DMA2_Stream0->CR & DMA_SxCR_EN);
    
    // Clear DMA flags
    DMA2->LIFCR |= DMA_LIFCR_CTCIF0 | DMA_LIFCR_CHTIF0 |
                    DMA_LIFCR_CTEIF0 | DMA_LIFCR_CDMEIF0 | DMA_LIFCR_CFEIF0;
    
    // Reset DMA counter
    DMA2_Stream0->NDTR = NUM_SAMPLES;
    // Re-enable DMA
    DMA2_Stream0->CR |= DMA_SxCR_EN;
}

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

    ADC1->CR2 = 0; // rests all (not using continuous capture)
    ADC1->CR2 |= ADC_CR2_ADON;
    Delay_us(1); // Small delay for ADC stabilization

    ADC1->SMPR2 = 0; // 3 cycles sampling time (channels 0-9)
    ADC1->SQR3 = 1; // Channel 1 (PA1)
    
    // Configure for TIM2_TRGO triggering
    ADC1->CR2 &= ~(0xF << ADC_CR2_EXTSEL_Pos); // Clear EXTSEL
    ADC1->CR2 |= (6 << ADC_CR2_EXTSEL_Pos);    // TIM2_TRGO
    ADC1->CR2 |= (1 << ADC_CR2_EXTEN_Pos);     // Rising edge

    // Configure DMA
    ADC1->CR2 |= ADC_CR2_DMA;  // Enable DMA

    ADC1->CR2 &= ~ADC_CR2_CONT;  // Desativa modo contínuo
}


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

    TIM2->PSC = 84 - 1;       // 1 µs per tick
    TIM2->ARR = ADC_DELAY_US - 1;  // Count to delay value
    TIM2->CNT = 0;

    // Configure TIM2 to generate TRGO on Update event
    TIM2->CR2 &= ~TIM_CR2_MMS;
    TIM2->CR2 |= TIM_CR2_MMS_1; // MMS = 010 = Update Event

    // Configure TIM2 as slave of TIM1 in Trigger mode (starts when receiving trigger)
    TIM2->SMCR &= ~(TIM_SMCR_SMS | TIM_SMCR_TS);  // Clear all
    TIM2->SMCR |= (0x6 << TIM_SMCR_SMS_Pos);      // SMS=110 (Trigger Mode)
    TIM2->SMCR |= (0x0 << TIM_SMCR_TS_Pos);       // TS=000 (ITR0 = TIM1)
    TIM2->SMCR |= (0x6 << TIM_SMCR_SMS_Pos); // SMS=110 (Trigger Mode)

    // Enable one-pulse mode so TIM2 stops after one cycle (form dma in non circular mode)
    // TIM2->CR1 |= TIM_CR1_OPM;

    // Enable update interrupt for TIM2
    TIM2->DIER |= TIM_DIER_UIE;
    NVIC_EnableIRQ(TIM2_IRQn);
}

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

    // Make sure stream is disabled
    DMA2_Stream0->CR &= ~DMA_SxCR_EN;
    while (DMA2_Stream0->CR & DMA_SxCR_EN); // Wait for deactivation

    // Clear interrupt flags
    DMA2->LIFCR |= DMA_LIFCR_CTCIF0 | DMA_LIFCR_CHTIF0 |
                   DMA_LIFCR_CTEIF0 | DMA_LIFCR_CDMEIF0 | DMA_LIFCR_CFEIF0;

    // Configure peripheral address (ADC1_DR)
    DMA2_Stream0->PAR = (uint32_t)&ADC1->DR;
    // Buffer address in memory
    DMA2_Stream0->M0AR = (uint32_t)&adc_buffer;
    // Number of transfers
    DMA2_Stream0->NDTR = NUM_SAMPLES;
    
    // Configure for channel 0 (ADC1)
    DMA2_Stream0->CR =
        (0 << DMA_SxCR_CHSEL_Pos) |  // Channel 0
        (1 << DMA_SxCR_MSIZE_Pos) |  // Memory 16 bits
        (1 << DMA_SxCR_PSIZE_Pos) |  // Peripheral 16 bits
        (1 << DMA_SxCR_MINC_Pos)  |  // Increment memory
        (0 << DMA_SxCR_PINC_Pos)  |  // Don't increment peripheral
        (0 << DMA_SxCR_CIRC_Pos)  |  // Normal mode (not circular) circular 1
        (0 << DMA_SxCR_DIR_Pos)   |  // Peripheral -> Memory
        (1 << DMA_SxCR_TCIE_Pos);    // Transfer complete interrupt

    // Enable DMA interrupt
    NVIC_EnableIRQ(DMA2_Stream0_IRQn);
}

void toggle_led() {
    GPIOD->ODR |= (1 << 12);  // Turn LED on
    Delay_us(10);
    GPIOD->ODR &= ~(1 << 12); // Turn LED off
}

void uart_init(void) {
    // Enable clocks for GPIOA and USART1
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
    RCC->APB2ENR |= RCC_APB2ENR_USART1EN;

    // Configure PA9 and PA10 for alternate function (AF7)
    // TX = PA9, RX = PA10
    GPIOA->MODER &= ~((3 << (9 * 2)) | (3 << (10 * 2)));  // clear bits
    GPIOA->MODER |=  (2 << (9 * 2)) | (2 << (10 * 2));    // alternate function mode

    GPIOA->AFR[1] &= ~((0xF << ((9 - 8) * 4)) | (0xF << ((10 - 8) * 4)));
    GPIOA->AFR[1] |=  (7 << ((9 - 8) * 4)) | (7 << ((10 - 8) * 4));  // AF7 (USART1)

    // Configure USART1: 115200 baud, 8N1
    USART1->BRR = 0x2D9;  // For 115200 baud with PCLK2 = 84 MHz
    USART1->CR1 = USART_CR1_TE | USART_CR1_UE;  // Enable transmitter and USART
}

void send_uart(char *msg) {
    while (*msg) {
        while (!(USART1->SR & USART_SR_TXE));  // wait for empty buffer
        USART1->DR = *msg++;
    }
}

int main(void) {
    // Configure system clock
    SystemClock_Config();

    // Initialize UART for debug via serial
    uart_init();

    // Initialize GPIO (PE13 as TIM1_CH3 Alternate Function)
    GPIO_Init();

    LED_Init();

    TIM5_Init();

    // Initialize TIM1 for PWM on PE13
    TIM1_PWM_Init();

    // Initialize TIM2 for ADC triggering
    TIM2_TRGO_Init();

    // Configure ADC and DMA
    DMA2_Stream0_ADC_Config();
    ADC1_Trigger_TIM2_Setup();

    while (1) {
        if (adc_capture_complete) {            
            // Reset flag
            adc_capture_complete = 0;
            
            /* // Reset DMA for next capture
            ADC1->CR2 &= ~ADC_CR2_DMA; // Desliga DMA
            ADC1->CR2 |= ADC_CR2_DMA;  // Religa DMA
            DMA2_Stream0->CR &= ~DMA_SxCR_EN;
            while (DMA2_Stream0->CR & DMA_SxCR_EN);
            
            // Clear DMA flags
            DMA2->LIFCR |= DMA_LIFCR_CTCIF0 | DMA_LIFCR_CHTIF0 |
                          DMA_LIFCR_CTEIF0 | DMA_LIFCR_CDMEIF0 | DMA_LIFCR_CFEIF0;
            
            // Reset DMA counter
            DMA2_Stream0->NDTR = NUM_SAMPLES;
            // Re-enable DMA
            DMA2_Stream0->CR |= DMA_SxCR_EN; */
        }
    }
}

void SystemClock_Config(void) {
    // 1. Enable HSE (High-Speed External Clock, typically 8 MHz)
    RCC->CR |= RCC_CR_HSEON;  
    while (!(RCC->CR & RCC_CR_HSERDY));  // Wait for HSE to stabilize
    
    // 2. Configure PLL to multiply frequency
    RCC->PLLCFGR = (8 << RCC_PLLCFGR_PLLM_Pos)  |  // HSE 8MHz /8 = 1MHz
                   (336 << RCC_PLLCFGR_PLLN_Pos) | // 1MHz × 336 = 336MHz
                   (0 << RCC_PLLCFGR_PLLP_Pos)  |  // 00 = divide by 2 → 168MHz
                   (7 << RCC_PLLCFGR_PLLQ_Pos)  |  // USB clock = 336/7 = 48MHz
                   RCC_PLLCFGR_PLLSRC_HSE;         // Use HSE as source

    // 3. Activate PLL
    RCC->CR |= RCC_CR_PLLON;
    while (!(RCC->CR & RCC_CR_PLLRDY));  // Wait for PLL to stabilize
    
    // 4. Configure bus frequencies to avoid overclock
    RCC->CFGR |= RCC_CFGR_HPRE_DIV1;   // AHB Prescaler = 1 (168 MHz)
    RCC->CFGR |= RCC_CFGR_PPRE1_DIV4;  // APB1 Prescaler = 4 (42 MHz)
    RCC->CFGR |= RCC_CFGR_PPRE2_DIV2;  // APB2 Prescaler = 2 (84 MHz)
    
    FLASH->ACR |= FLASH_ACR_LATENCY_5WS | FLASH_ACR_PRFTEN | FLASH_ACR_ICEN | FLASH_ACR_DCEN;

    // 6. Switch System Clock to PLL
    RCC->CFGR |= RCC_CFGR_SW_PLL;
    while ((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_PLL);  // Wait for switch

    // Configure ADC clock
    ADC->CCR &= ~ADC_CCR_ADCPRE;       // Clear ADCPRE bits
    ADC->CCR |= (3 << ADC_CCR_ADCPRE_Pos);  // 11b → divide APB2 por 8 → ADCCLK = 84 / 8 = 10.5 MHz :white_heavy_check_mark:

    SystemCoreClockUpdate();
}

void GPIO_Init(void) {
    // Enable clocks for GPIOs A and E
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;  // Enable GPIOA clock (for PA8)
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIOEEN;  // Enable GPIOE clock

    // Configure PE13 as alternate function (TIM1_CH3)
    GPIOE->MODER &= ~(3 << (13 * 2));
    GPIOE->MODER |= (2 << (13 * 2));      // Alternate function mode
    GPIOE->OSPEEDR |= (3 << (13 * 2));    // High speed for PE13
    
    GPIOE->AFR[1] &= ~(0xF << ((13 - 8) * 4)); // Clear AFR[1] bits for PE13
    GPIOE->AFR[1] |= (1 << ((13 - 8) * 4));    // Set AF1 for PE13 (TIM1_CH3)

    // Configure PA8 as alternate function (TIM1_CH1)
    GPIOA->MODER &= ~(3 << (8 * 2));
    GPIOA->MODER |= (2 << (8 * 2));       // Alternate function mode
    GPIOA->OSPEEDR |= (3 << (8 * 2));     // High speed
    GPIOA->AFR[1] &= ~(0xF << ((8 - 8) * 4)); // Clear AF bits
    GPIOA->AFR[1] |= (1 << ((8 - 8) * 4));    // AF1 (TIM1_CH1)

    // Configure PA1 as analog input for ADC
    GPIOA->MODER |= GPIO_MODER_MODER1;  // Analog mode (0b11)

    // Debug pin (set PE1 as debug pin)
    GPIOE->MODER |= (1 << (1 * 2));  // PE1 as output
    GPIOE->ODR &= ~(1 << 1);         // Start low
}

// Timer used only for debug timing
void TIM5_Init(void) {
    // Enable clock for TIM5
    RCC->APB1ENR |= RCC_APB1ENR_TIM5EN;
    // APB1 is 42MHz, but timer clock is 2x that (84MHz)
    // For 1 µs resolution: 84MHz / 84 = 1MHz
    TIM5->PSC = 84 - 1;
    // Max auto-reload (32 bits)
    TIM5->ARR = 0xFFFFFFFF;
    // Start counting
    TIM5->CR1 |= TIM_CR1_CEN;
    // Reset TIM5 counter
    TIM5->CNT = 0;
}

uint32_t micros(void) {
    return TIM5->CNT;
}

void TIM1_PWM_Init(void) {
    // Enable TIM1 clock on APB2 bus
    RCC->APB2ENR |= RCC_APB2ENR_TIM1EN;

    // Set timer frequency (reduce clock to 1 MHz, so 1 tick = 1 µs)
    TIM1->PSC = 168-1;    // Prescaler (divides timer clock)
    // Set PWM period (1ms = 1000 µs)
    TIM1->ARR = 1000 - 1;  // Define maximum count (PWM period)
    // Set duty cycle (100 µs)
    TIM1->CCR3 = 100; // TX pulse width
    TIM1->CCR1 = 500; // 500µs pulse width (for PA8)

    // Configure TIM1 Channel 3 for PWM1 mode
    TIM1->CCMR2 &= ~TIM_CCMR2_OC3M; // Clear output mode bits for Channel 3
    TIM1->CCMR2 |= (6 << TIM_CCMR2_OC3M_Pos); // Set Channel 3 to PWM1 mode
    TIM1->CCMR2 |= TIM_CCMR2_OC3PE; // Enable Preload for CCR3
    // Configure polarity (active high)
    TIM1->CCER &= ~TIM_CCER_CC3P;
    TIM1->CCER |= TIM_CCER_CC3E; // Enable PWM output on Channel 3

    // Configure Channel 1 (for PA8 charge pump pulse) as PWM Mode 1
    TIM1->CCMR1 &= ~TIM_CCMR1_OC1M;
    TIM1->CCMR1 |= (6 << TIM_CCMR1_OC1M_Pos); // PWM Mode 1
    TIM1->CCMR1 |= TIM_CCMR1_OC1PE;           // Enable preload
    // Configure polarity (active high) and enable output
    TIM1->CCER &= ~TIM_CCER_CC1P;             // Active high
    TIM1->CCER |= TIM_CCER_CC1E;              // Enable output
    
    // Configure TIM1 to generate TRGO on OC3REF signal (when TX pulse ends)
    TIM1->CR2 &= ~TIM_CR2_MMS;
    //TIM1->CR2 |= TIM_CR2_MMS_1 | TIM_CR2_MMS_0; // MMS = 011 = OC3REF as trigger
    // TIM1->CR2 |= (TIM_CR2_MMS_1 | TIM_CR2_MMS_0);
    TIM1->CR2 |= (0x3 << TIM_CR2_MMS_Pos);  // MMS=011 (OC3REF = PWM end)

    // Enable interrupt at compare match (when CCR3 is reached)
    TIM1->DIER |= TIM_DIER_CC3IE;
    
    // Enable both compare and update interrupts
    TIM1->DIER |= TIM_DIER_CC3IE | TIM_DIER_UIE;
    NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn); // Enable update interrupt
    NVIC_EnableIRQ(TIM1_CC_IRQn);       // Enable compare interrupt

    // Start TIM1 counter, generating PWM
    TIM1->CR1 |= TIM_CR1_CEN;
    // Enable PWM output on physical pins (only for advanced timers like TIM1 and TIM8)
    TIM1->BDTR |= TIM_BDTR_MOE;
}

void LED_Init(void) {
    RCC->AHB1ENR |= RCC_AHB1ENR_GPIODEN;
    GPIOD->MODER |= (1 << (12 * 2));
    GPIOD->ODR &= ~(1 << 12);  // Ensure LED starts off
}

uint16_t adc1_read(void) {
    ADC1->CR2 |= ADC_CR2_SWSTART;          // Start conversion
    while (!(ADC1->SR & ADC_SR_EOC));      // Wait until conversion complete
    return ADC1->DR;                       // Read result
}

/* === Interrupt Handlers === */

// TIM1 update interrupt handler (debug: used only for debug of TX pulse start with LED)
void TIM1_UP_TIM10_IRQHandler(void) {
    if (TIM1->SR & TIM_SR_UIF) {
        TIM1->SR &= ~TIM_SR_UIF;
        // TX pulse start logic here if needed
    }
}

// TIM1 compare interrupt handler (at end of TX pulse)
void TIM1_CC_IRQHandler(void) {
    if (TIM1->SR & TIM_SR_CC3IF) {
        TIM1->SR &= ~TIM_SR_CC3IF;
        tx_num_pulses++;
        
        buffer[current_buffer].tx_end_micros = micros();
        buffer[current_buffer].num_pulses = tx_num_pulses;
        uint8_t buf = current_buffer ^ 1;
        current_buffer = buf;
    }
}

void TIM2_IRQHandler(void) {
    // Check if update interrupt occurred
    if (TIM2->SR & TIM_SR_UIF) {
        TIM2->SR &= ~TIM_SR_UIF;  // Clear interrupt flag
        
        buffer[current_buffer].adc_start_micros = micros();
        buffer[current_buffer].num_pulses_tim2 = tx_num_pulses;
    }
}

void DMA2_Stream0_IRQHandler(void) {
    if (DMA2->LISR & DMA_LISR_TCIF0) {
        // Clear the transfer complete flag
        DMA2->LIFCR |= DMA_LIFCR_CTCIF0;
        adc_capture_complete = 1;
    }
}

// --- Utilities ---
void Delay_us(uint32_t us) {
    volatile uint32_t count = us * (SystemCoreClock / 1000000) / 5;
    while (count--);
}

[Sarra.S · Accepted solution]

Hello @cristianosar, 

With TIM2->PSC = 84 - 1; and TIM2->ARR = ADC_DELAY_US - 1, this configuration should give you a 10 µs delay,  if your timer clock is 84 MHz 

Also, If you want TIM2 to stop after one cycle, this line (TIM2->CR1 |= TIM_CR1_OPM) should be uncommented.

[cristianosar]

Thanks!