STM32 controlled PI detector

[cristiano.sar]

I'm trying to build a Stm32 controlled Pi detector. Until now, I have made the TX part and I'm now in the step of reading the ADC data to detect metal and ignore the unwanted signals (EFE, GB, etc).
The MCU I'm using is stm32f407xx and I'm using one of its internal ADCs (ADC1) with DMA transfer.
My doubt is if I should make ADC readings at specific time windows (for example, 10us after TX pulse ends like in regular Analog detectors (sample delay)) or if I should use the DMA in circular mode and make some kind of calculations to check at what moments look for the relevant signals.

Below is a capture of 64 samples of my ADC with DMA in circular mode:

Below is a capture of 64 samples of the ADC in normal mode, captured after a delay of TX pulse end (seems a little strange to me):

I have experience with programming with high level languages but not with low level (in embedded systems) but I'm learning and also getting some help from AIs.
Thanks.

[moodz]

I would rrecommend to sample synchronously.
... all ADCs basically have a modulator at their input so if you sample asynchronously you are looking at the product of Fo and So where Fo is your signal fundamental Tx Frequency and So is your sampling frequency.
If this product falls within your target passband then you will get uwanted side effects in the data.
Oversample and integrate for best results.

[cristiano.sar]

Thanks, I'm trying to implement it that way using timer triggers and interrupts. I'm currently using bare metal code, if I choose to use the HAL library, you see a relevant performance impact or is this something I should not worry about?

[cristiano.sar]

I have tried to use the ADC with DMA but was not able to properly synchronize the sampling to the correct times (decay curve). So I make a "manual" ADC read (Capture_ADC_Samples() method ) and now it basically works with a simple average.

#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);
uint16_t adc1_read(void);
void Delay_us(uint32_t);
void send_uart(char *msg);
uint32_t micros(void);
void toggle_led(void);
void Capture_ADC_Samples(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_capture_start;
uint32_t adc_capture_end;
uint32_t num_pulses;
uint32_t num_pulses_tim2;
uint32_t adc_captures;
} TimingData;
volatile TimingData debug_buffer[2];
volatile uint8_t current_debug_buffer = 0;
volatile TimingData timing; // Global instance, accessible in both ISRs
static float baseline = 0;
static float previous_average = 0;
static int baseline_captured = 0;
volatile uint32_t dma_armed = 0;
void delay_ms(int milliseconds) {
volatile int i;
for (i = 0; i < milliseconds * 1000; i++) {
__NOP(); // No operation, just waste time
}
}
void ADC_Configure() {
// Habilitar o clock do ADC
RCC->APB2ENR |= RCC_APB2ENR_ADC1EN;
// Configurar o pino de entrada (por exemplo, PA1)
RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN;
GPIOA->MODER |= (3 << (1 * 2)); // Configura PA1 como modo analógico
// Configurações do ADC
ADC1->CR2 = 0; // Reseta o ADC
ADC1->CR2 |= ADC_CR2_ADON; // Liga o ADC
Delay_us(1); // Atraso pequeno para estabilizar o ADC
ADC1->SMPR2 = 0; // 3 ciclos de amostragem (menor tempo de amostragem)
ADC1->SQR3 = 1; // Canal 1 (PA1)
}
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)
// CORRECT TIM2 SLAVE MODE (Triggered by TIM1 TRGO)
//TIM2->SMCR &= ~TIM_SMCR_SMS; // Clear SMS bits
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)
// Enable one-pulse mode so TIM2 stops after one cycle (form dma in non circular mode)
TIM2->CR1 |= TIM_CR1_OPM;
//TIM2->CR1 &= ~TIM_CR1_OPM; // no opm
// Enable update interrupt for TIM2
TIM2->DIER |= TIM_DIER_UIE;
NVIC_EnableIRQ(TIM2_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();
// Initilize ADC
ADC_Configure();
while (1) {
if (adc_capture_complete) {
Capture_ADC_Samples();
// Reset flag
adc_capture_complete = 0;
}
}
}
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 ✅
ADC->CCR |= (1 << ADC_CCR_ADCPRE_Pos); // PCLK2 / 4 = 21 MHz
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 detect_metal_simple(volatile uint16_t *adc_buffer, int buffer_size) {
uint32_t sum = 0;
for (int i = 0; i < buffer_size; i++) {
sum += adc_buffer[i];
}
float average = sum / (float)buffer_size;
if (!baseline_captured) {
// Primeira média usada como base
baseline = average;
baseline_captured = 1;
} else {
// Compara média atual com a de referência
float diff = fabsf(average - baseline); // diferença absoluta
// Se houver variação significativa, detecta metal
if (diff > 2000.0f) { // Limiar ajustável conforme seu circuito
GPIOD->ODR |= (1 << 12); // Liga LED
} else {
GPIOD->ODR &= ~(1 << 12); // Desliga LED
}
}
}
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
}
void TIM2_Rearm(void) {
// Reset o contador
TIM2->CNT = 0;
// Habilita o contador (aguarda novo TRGO)
TIM2->CR1 |= TIM_CR1_CEN;
}

/* === 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++;
// Debug signal on PE1 (to verify timing)
// GPIOE->ODR |= (1 << 1); // Set PE1 high
debug_buffer[current_debug_buffer].tx_end_micros = micros();
debug_buffer[current_debug_buffer].num_pulses = tx_num_pulses;
uint8_t buf = current_debug_buffer ^ 1;
current_debug_buffer = buf;
//GPIOE->ODR |= (1 << 1); // Set PE1 high
// reset tim2 counter
TIM2->CNT = 0; // Reset counter
TIM2->CR1 |= TIM_CR1_CEN; // Enable counter
}
}
void TIM2_IRQHandler(void) {
// Check if update interrupt occurred
if (TIM2->SR & TIM_SR_UIF) {
TIM2->SR &= ~TIM_SR_UIF; // Clear interrupt flag
debug_buffer[current_debug_buffer].num_pulses_tim2 += 1;
GPIOE->ODR |= (1 << 1); // Set PE1 high
adc_capture_complete = 1;
}
}
void Capture_ADC_Samples() {
//GPIOE->ODR |= (1 << 1); // Set PE1 high
//buffer[current_buffer].adc_capture_start = micros();
for (int i = 0; i < NUM_SAMPLES; i++) {
// Inicia a conversão
ADC1->CR2 |= ADC_CR2_SWSTART;
// Espera até a conversão ser concluída
while (!(ADC1->SR & ADC_SR_EOC)); // Espera o flag EOC (End of Conversion)
// Lê o valor convertido
adc_buffer[i] = ADC1->DR;
// Limpa o flag EOC
ADC1->SR &= ~ADC_SR_EOC;
}
detect_metal_simple(adc_buffer, NUM_SAMPLES);
debug_buffer[current_debug_buffer].adc_captures += 1;
//buffer[current_buffer].adc_capture_end = micros();
GPIOE->ODR &= ~(1 << 1); // Set PE1 low
}
// --- Utilities ---
void Delay_us(uint32_t us) {
volatile uint32_t count = us * (SystemCoreClock / 1000000) / 5;
while (count--);
}​

I added a simple youtube video showing basic detection of a gold ring, for now it is sinalized as a green led. In the oscilloscope, the second channel is showing just a debug pulse to capture the ADC sampling window (STM32 pin PE1).
For now, this project is just a way of learning but I will try to evolve it.

[dbanner]

here is an optimization of your code done by deepseek. Will it work?

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

// Settings
#define ADC_DELAY_US 10 // Delay after TX pulse before ADC sampling
#define NUM_SAMPLES 64 // Number of ADC samples to capture
#define METAL_THRESHOLD 2000.0f // Detection threshold
#define BASELINE_ALPHA 0.01f // EMA filter coefficient for baseline
#define HYSTERESIS_FACTOR 0.9f // Hysteresis factor for detection

// Aligned buffers for DMA
volatile uint16_t adc_buffer[NUM_SAMPLES] __attribute__((aligned(4)));
volatile uint8_t adc_capture_complete = 0;

// Detection state
typedef struct {
float baseline;
float previous_avg;
uint8_t baseline_captured;
uint8_t metal_detected;
} DetectionState;

static DetectionState detector;

// Timer debug information
typedef struct {
uint32_t tx_end_micros;
uint32_t adc_capture_start;
uint32_t adc_capture_end;
uint32_t num_pulses;
uint32_t num_pulses_tim2;
uint32_t adc_captures;
} TimingData;

volatile TimingData debug_buffer[2];
volatile uint8_t current_debug_buffer = 0;

// Function Prototypes
void SystemClock_Config(void);
void GPIO_Init(void);
void TIM1_PWM_Init(void);
void TIM2_TRGO_Init(void);
void ADC_DMA_Init(void);
void LED_Init(void);
void UART_Init(void);
void send_uart(const char *msg);
uint32_t micros(void);
void Capture_ADC_Samples(void);
void Detect_Metal(volatile uint16_t *samples, uint16_t count);
void Delay_us(uint32_t us);

// Simplified delay function
void Delay_us(uint32_t us) {
uint32_t ticks = us * (SystemCoreClock / 1000000) / 5;
while(ticks--) {
__NOP();
}
}

void SystemClock_Config(void) {
// Enable HSE (8MHz crystal)
RCC->CR |= RCC_CR_HSEON;
while(!(RCC->CR & RCC_CR_HSERDY));

// Configure PLL (168MHz system clock)
RCC->PLLCFGR = (8 << RCC_PLLCFGR_PLLM_Pos) | // M=8
(336 << RCC_PLLCFGR_PLLN_Pos) | // N=336
(0 << RCC_PLLCFGR_PLLP_Pos) | // P=2
(7 << RCC_PLLCFGR_PLLQ_Pos) | // Q=7 (48MHz for USB)
RCC_PLLCFGR_PLLSRC_HSE;

// Enable PLL and wait for lock
RCC->CR |= RCC_CR_PLLON;
while(!(RCC->CR & RCC_CR_PLLRDY));

// Configure flash latency and prefetch
FLASH->ACR = FLASH_ACR_LATENCY_5WS | FLASH_ACR_PRFTEN | FLASH_ACR_ICEN | FLASH_ACR_DCEN;

// Set clock dividers
RCC->CFGR |= RCC_CFGR_HPRE_DIV1 | // AHB = 168MHz
RCC_CFGR_PPRE1_DIV4 | // APB1 = 42MHz
RCC_CFGR_PPRE2_DIV2; // APB2 = 84MHz

// Switch to PLL
RCC->CFGR |= RCC_CFGR_SW_PLL;
while((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_PLL);

// ADC clock = APB2 / 4 = 21MHz
ADC->CCR = (1 << ADC_CCR_ADCPRE_Pos);

SystemCoreClockUpdate();
}

void GPIO_Init(void) {
// Enable GPIO clocks
RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN | RCC_AHB1ENR_GPIOEEN | RCC_AHB1ENR_GPIODEN;

// Configure PE13 (TIM1_CH3) as AF
GPIOE->MODER = (GPIOE->MODER & ~(3 << (13*2))) | (2 << (13*2));
GPIOE->OSPEEDR |= (3 << (13*2)); // High speed
GPIOE->AFR[1] = (GPIOE->AFR[1] & ~(0xF << ((13-8)*4))) | (1 << ((13-8)*4));

// Configure PA1 as analog input
GPIOA->MODER |= (3 << (1*2));

// Configure PE1 as debug output
GPIOE->MODER |= (1 << (1*2));
GPIOE->ODR &= ~(1 << 1);
}

void ADC_DMA_Init(void) {
// Enable ADC and DMA clocks
RCC->APB2ENR |= RCC_APB2ENR_ADC1EN;
RCC->AHB1ENR |= RCC_AHB1ENR_DMA2EN;

// Configure ADC
ADC1->CR2 = 0;
ADC1->SQR3 = 1; // Channel 1 (PA1)
ADC1->SMPR2 = 0; // 3 cycles sampling time

// Configure DMA
DMA2_Stream0->CR &= ~DMA_SxCR_EN;
while(DMA2_Stream0->CR & DMA_SxCR_EN);

DMA2_Stream0->PAR = (uint32_t)&ADC1->DR;
DMA2_Stream0->M0AR = (uint32_t)adc_buffer;
DMA2_Stream0->NDTR = NUM_SAMPLES;

DMA2_Stream0->CR = DMA_SxCR_CHSEL_0 | // Channel 0
DMA_SxCR_MINC | // Memory increment
DMA_SxCR_CIRC | // Circular mode
DMA_SxCR_TCIE | // Transfer complete interrupt
DMA_SxCR_DMEIE | // Direct mode error interrupt
DMA_SxCR_TEIE; // Transfer error interrupt

// Enable DMA for ADC
ADC1->CR2 |= ADC_CR2_DMA | ADC_CR2_DDS;

// Enable DMA stream
DMA2_Stream0->CR |= DMA_SxCR_EN;

// Enable ADC
ADC1->CR2 |= ADC_CR2_ADON;
Delay_us(1);

// Enable DMA interrupt
NVIC_EnableIRQ(DMA2_Stream0_IRQn);
}

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

// Configure PWM
TIM1->PSC = 168-1; // 1MHz clock (1µs resolution)
TIM1->ARR = 1000-1; // 1ms period
TIM1->CCR3 = 100; // 100µs pulse width

// Configure Channel 3 (PE13)
TIM1->CCMR2 = (6 << TIM_CCMR2_OC3M_Pos) | TIM_CCMR2_OC3PE;
TIM1->CCER |= TIM_CCER_CC3E;

// Configure TRGO output on OC3REF
TIM1->CR2 = (3 << TIM_CR2_MMS_Pos);

// Enable interrupts
TIM1->DIER |= TIM_DIER_CC3IE;
NVIC_EnableIRQ(TIM1_CC_IRQn);

// Enable timer and outputs
TIM1->BDTR |= TIM_BDTR_MOE;
TIM1->CR1 |= TIM_CR1_CEN;
}

void TIM2_TRGO_Init(void) {
// Enable TIM2 clock
RCC->APB1ENR |= RCC_APB1ENR_TIM2EN;

// Configure timer
TIM2->PSC = 84-1; // 1MHz clock (1µs resolution)
TIM2->ARR = ADC_DELAY_US-1;
TIM2->CNT = 0;

// Configure TRGO on update
TIM2->CR2 = (1 << TIM_CR2_MMS_Pos);

// Configure as slave (triggered by TIM1)
TIM2->SMCR = (6 << TIM_SMCR_SMS_Pos) | (0 << TIM_SMCR_TS_Pos);

// One-pulse mode
TIM2->CR1 |= TIM_CR1_OPM;

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

void Detect_Metal(volatile uint16_t *samples, uint16_t count) {
uint32_t sum = 0;

// Calculate average
for(uint16_t i = 0; i < count; i++) {
sum += samples[i];
}
float average = sum / (float)count;

if(!detector.baseline_captured) {
// First sample becomes baseline
detector.baseline = average;
detector.previous_avg = average;
detector.baseline_captured = 1;
} else {
// Exponential moving average for baseline
detector.baseline = BASELINE_ALPHA * average + (1.0f - BASELINE_ALPHA) * detector.baseline;

// Calculate difference with hysteresis
float diff = fabsf(average - detector.baseline);
float threshold = detector.metal_detected ?
METAL_THRESHOLD * HYSTERESIS_FACTOR :
METAL_THRESHOLD;

// Detection logic
if(diff > threshold) {
detector.metal_detected = 1;
GPIOD->ODR |= (1 << 12); // LED on
} else {
detector.metal_detected = 0;
GPIOD->ODR &= ~(1 << 12); // LED off
}

detector.previous_avg = average;
}
}

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

void TIM1_CC_IRQHandler(void) {
if(TIM1->SR & TIM_SR_CC3IF) {
TIM1->SR &= ~TIM_SR_CC3IF;

// Record timing info
debug_buffer[current_debug_buffer].tx_end_micros = micros();
debug_buffer[current_debug_buffer].num_pulses++;

// Start TIM2 for ADC delay
TIM2->CNT = 0;
TIM2->CR1 |= TIM_CR1_CEN;
}
}

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

// Trigger ADC sampling via DMA
ADC1->CR2 |= ADC_CR2_SWSTART;
GPIOE->ODR |= (1 << 1); // Debug pin high
}
}

void Capture_ADC_Samples() {
// Process samples (DMA has already filled the buffer)
Detect_Metal(adc_buffer, NUM_SAMPLES);

// Update debug info
debug_buffer[current_debug_buffer].adc_captures++;
GPIOE->ODR &= ~(1 << 1); // Debug pin low
adc_capture_complete = 0;
}

int main(void) {
// Initialize hardware
SystemClock_Config();
GPIO_Init();
LED_Init();
UART_Init();

// Initialize peripherals
TIM1_PWM_Init();
TIM2_TRGO_Init();
ADC_DMA_Init();

// Main loop
while(1) {
if(adc_capture_complete) {
Capture_ADC_Samples();
}
}
}​​

[dbanner]

Key Improvements:

1. DMA for ADC Sampling:
   • Eliminates CPU overhead during sampling
   • Provides more consistent timing between samples
   • Allows CPU to perform other tasks during sampling
2. Improved Metal Detection Algorithm:
   • Exponential moving average for baseline tracking
   • Hysteresis in detection threshold to prevent flickering
   • Better noise immunity
3. Optimized Interrupt Handlers:
   • Minimized processing in ISRs
   • Moved sample processing to main loop
4. Memory Efficiency:
   • Better organized data structures
   • Reduced global variables
5. Timing Precision:
   • More accurate timer configurations
   • Hardware-based triggering for consistent timing
6. Code Organization:
   • More modular structure
   • Clearer separation of concerns

This optimized version should provide:

• More reliable metal detection
• Lower CPU usage
• Better timing precision
• Improved noise immunity
• More maintainable code structure

[dbanner]

What is Hardware-Based Triggering?


In your pulse induction metal detector, timing between the TX pulse, ADC sampling, and signal processing is critical. Instead of using software delays (like Delay_us()), we use:

1. Timer triggers (TIM1 → TIM2)
2. Hardware-controlled ADC sampling (TIM2 → ADC via TRGO)
3. DMA for automatic data transfer (ADC → memory)

All of this happens without CPU involvement, eliminating jitter caused by interrupt latency or software delays.

---

How It Works in Your Code

TIM1 (PWM)	Generates TX pulse	Outputs TRGO signal on PWM edge
TIM2	Delays ADC sampling after TX pulse	Triggered by TIM1's TRGO
ADC	Samples the coil signal	Triggered by TIM2's TRGO
DMA	Moves ADC data to memory	Automatic after ADC conversion

---

Key Improvements Over Software Timing

Software delays (Delay_us())	~1–5µs (varies)	High (CPU blocked)	Unpredictable (interrupts can delay)
Hardware triggering	~0.1µs (consistent)	Zero (CPU free)	Minimal (synchronized by hardware)

---

Why This Matters for Your Metal Detector

1. TX Pulse → ADC Sampling Delay
   • Your original code used a software delay (Delay_us(ADC_DELAY_US)).
   • Optimized version uses TIM2 (configured as a hardware one-shot timer) for exact 10µs delay.
   • No CPU intervention needed!
2. ADC Sampling Consistency
   • Original: Manual ADC reads in a loop (timing varies due to loop overhead).
   • Optimized: ADC samples are triggered by TIM2 and stored via DMA (perfectly spaced).
3. CPU Efficiency
   • Frees up the CPU to process data while hardware handles timing-critical tasks.

---

No Hardware Changes Required


The optimization only involves STM32 internal peripheral configuration. Your circuit remains identical—the improvements come from smarter use of the microcontroller's features.

Key Takeaways

1. No circuit modifications needed – It’s all firmware improvements.
2. More reliable timing – Hardware triggers eliminate software jitter.
3. Faster sampling – DMA lets you capture all ADC samples back-to-back without CPU delays.

[dbanner]

All of the above was deepseek in action. Done in 45 seconds.
But will the optimized code work as written?

[dbanner]

Deepseek says:



My confidence level that the core functionality of the optimized code will work is high (~85-90%), but with some caveats. Here’s why:

---

High-Confidence Components (Tested Patterns)

1. Hardware Timers (TIM1 → TIM2 → ADC Triggering)
   • The timer synchronization (TIM1 TRGO → TIM2 → ADC) uses STM32 reference manual-recommended configurations.
   • Confidence: 95% (this is a standard STM32 peripheral interaction).
2. DMA for ADC Sampling
   • DMA-driven ADC reads are widely used and reliable. The DMA_SxCR_CIRC (circular mode) ensures continuous sampling.
   • Confidence: 90% (assuming correct buffer alignment and IRQ priorities).
3. PWM Generation (TX Pulse on PE13)
   • TIM1 PWM mode is unchanged from your original working code.
   • Confidence: 98%.

---

Moderate-Confidence Components (May Need Tuning)

1. ADC/DMA Timing
   • The exact delay between TX pulse end and ADC sampling (ADC_DELAY_US) depends on:
     • Timer clock synchronization (APB1/APB2 prescalers).
     • ADC startup time (if ADON was delayed).
   • Suggestion: Verify with an oscilloscope (PE13 for TX pulse, PE1 for ADC trigger).
   • Confidence: 80% (may need slight ADC_DELAY_US adjustment).
2. Metal Detection Algorithm
   • The exponential moving average (EMA) and hysteresis logic are mathematically sound, but:
     • Threshold (METAL_THRESHOLD) is hardware-dependent (coil sensitivity, gain, etc.).
     • EMA coefficient (BASELINE_ALPHA) may need tuning for your environment.
   • Confidence: 75% (empirical testing required).
3. Interrupt Priorities
   • If interrupts (TIM1, TIM2, DMA) conflict, timing could break.
   • Suggestion: Ensure NVIC priorities are set (e.g., TIM1 > TIM2 > DMA).
   • Confidence: 85% (if priorities are correct).

---

Low-Risk but Needs Verification

1. Debug Pins (PE1)
   • Assumes PE1 is unused in your hardware. If connected, double-check.
   • Confidence: 99% (but trivial to disable if problematic).
2. UART Debugging
   • The send_uart() function is stripped down. If debugging is critical, re-add your original UART code.
   • Confidence: 70% (if UART is essential).

---

How to Test Systematically

1. Stage 1: Verify Timers
   • Probe PE13 (TX pulse) and PE1 (ADC trigger). Confirm:
     • PWM width = 100µs (TIM1 CCR3).
     • PE1 toggles exactly 10µs after PE13 falls (TIM2 delay).
2. Stage 2: Validate ADC Sampling
   • Use a known DC voltage (e.g., 1.5V) on PA1 (ADC input).
   • Check adc_buffer in debugger—values should be stable (±1 LSB).
3. Stage 3: Metal Detection
   • Test with a metal object at fixed distance. Adjust:
     • METAL_THRESHOLD (start with 2000, then fine-tune).
     • BASELINE_ALPHA (higher = faster adaptation, but more noise).

---

Fallback Options


If issues arise:

1. Revert to Polled ADC
   • Replace DMA with your original adc1_read() loop (less efficient but simpler).
2. Disable EMA Filter
   • Use your original baseline logic if EMA behaves unpredictably.

---

Final Answer


The code is highly likely to work for PWM generation and ADC sampling, but the detection algorithm may need tuning for your specific hardware. I recommend:

1. Verify timing with an oscilloscope (PE13 + PE1).
2. Start with conservative thresholds (e.g., METAL_THRESHOLD = 3000).
3. Monitor adc_buffer in a debugger to validate samples.

[dbanner]

Sorry for all that, I just wanted to see what deepseek AI would spit out.

[cristiano.sar]

Thank you, I will try that later, anyway I tried to use hardware triggers and ACD with DMA but was not able to check the capture times in the oscilloscope in a consistent way.

[cristiano.sar]

I tried your code from Deepseek (it required some fixes to work) but again, as I have tried before, when using DMA with circuar mode, I have ADC data from the entire time window and not only the most important part (the decay curve), as it can be seen below.

I added an image for each case (a python chart displaying 64 samples and a scope image showing the preamp output on channel 1 and the ADC capture start / end on channel 2)

ADC with DMA in circular mode:



Synchronized ADC (sample window):




I think I will use the second approach (synchronized sampling) as it contains only the useful data and I can focus on it, otherwise I will need to have logic to extract the decay curve only.

[cristiano.sar]

For now, I just gave up the direct sampling because it seems too slow. Now I will use the Stm32 just for controlling the timings and to add some detection logic at the end, using analog demodulation.

My doubt now is:
1 - Is it better to make the Target - EFE and Ground - EFE directly in the analog circuit or is it better to do this digitally?
2 - If doing it digitally, should I have 3 channels (Target, EFE and Ground), read each one in the ADC and compute the values?

Thanks.