The problem was just my oscilloscope (not calibrated), so I calibrated it through an internal trimmer and now it's working properly as you can see below (100us/Div)
Anyway, the final code I have to generate de 100us pulse is the following (there are some Portuguese comments and additional code I added for debugging with GDB, please don't mind it).
//#include <stdint.h>
//#include <stdio.h>
#include "stm32f4xx.h"
// Function Prototypes
void SystemClock_Config(void);
void GPIO_Init(void);
void TIM1_PWM_Init(void);
// interrupcao do systick
void SysTick_Init(void);
//volatile uint32_t hse_value = HSE_VALUE;
volatile uint32_t pulse_count = 0;
volatile uint32_t pulses_per_second = 0;
volatile uint32_t seconds_elapsed = 0;
int main(void) {
// Configure system clock
SystemClock_Config();
// Initialize GPIO (PE13 as TIM1_CH3 Alternate Function)
GPIO_Init();
// Initialize TIM1 for PWM on PE13
TIM1_PWM_Init();
SysTick_Init(); // Para debugar
while (1) {
// PWM runs automatically in hardware
}
}
// Configura o SysTick para 1 segundo
void SysTick_Init(void) {
// Configura para interrupção a cada 1 segundo
// Como SysTick é 24-bit, precisamos dividir o clock
uint32_t ticks = SystemCoreClock / 1000; // 1ms (168000 ticks @ 168MHz)
SysTick->LOAD = ticks - 1; // Configura para 1ms
SysTick->VAL = 0; // Zera o contador
SysTick->CTRL = SysTick_CTRL_CLKSOURCE_Msk |
SysTick_CTRL_TICKINT_Msk |
SysTick_CTRL_ENABLE_Msk;
// Configura prioridade da interrupção (opcional)
NVIC_SetPriority(SysTick_IRQn, (1 << __NVIC_PRIO_BITS) - 1);
}
// Handler do SysTick
volatile uint32_t milliseconds = 0;
void SysTick_Handler(void) {
milliseconds++;
if(milliseconds >= 1000) { // A cada 1000ms = 1s
milliseconds = 0;
pulses_per_second = pulse_count;
pulse_count = 0;
seconds_elapsed++;
}
}
void SystemClock_Config(void) {
// 1. Habilita o HSE (High-Speed External Clock, normalmente 8 MHz)
RCC->CR |= RCC_CR_HSEON;
while (!(RCC->CR & RCC_CR_HSERDY)); // Espera o HSE estabilizar
// 2. Configura o PLL para multiplicar a frequência
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. Ativa o PLL
RCC->CR |= RCC_CR_PLLON;
while (!(RCC->CR & RCC_CR_PLLRDY)); // Espera o PLL estabilizar
// 4. Configura os barramentos para evitar overclock
// define a freq. maxima de cada barramento
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)
// 5. Configura o Flash para rodar a 168 MHz
// Set Flash Latency and Enable Prefetch Buffer
// essa linha so funciona aqui e nessa ordem (o chat gpt havia criado outra ordem no final)
// e nao funcionava!
FLASH->ACR |= FLASH_ACR_LATENCY_5WS | FLASH_ACR_PRFTEN | FLASH_ACR_ICEN | FLASH_ACR_DCEN;
// 6. Troca o System Clock para o PLL
RCC->CFGR |= RCC_CFGR_SW_PLL;
while ((RCC->CFGR & RCC_CFGR_SWS) != RCC_CFGR_SWS_PLL); // Espera a troca
// Atualiza a variável global com a nova frequência do clock
// SystemCoreClock = 168000000;
// ou, se quiser usar a função CMSIS:
SystemCoreClockUpdate();
}
void GPIO_Init(void) {
// Habilitar clock dos GPIOs A e E (porque no Stm32 os clocks estao desaticados por padrao)
// 7.3.10 - pag 244 do reference manual
// RCC->AHB1ENR |= RCC_AHB1ENR_GPIOAEN; // Habilita o clock do GPIOA (pra pa8)
RCC->AHB1ENR |= RCC_AHB1ENR_GPIOEEN; // Habilita o clock do GPIOE
// Ver Memory Map (2.2 para ver os enderecos de memoria) no reference manual
// Configurar PE13 como função alternativa (TIM1_CH3)
// gpio_set_mode(GPIOE, 13 /* pin */, GPIO_MODE_AF); // Set PE13 to alternate function
GPIOE->MODER &= ~(3 << (13 * 2));
GPIOE->MODER |= (2 << (13 * 2));
GPIOE->OSPEEDR |= (3 << (13 * 2)); // Alta velocidade para PE13
// todo: repetir processo para o PA8 depois
// AFR[1] → Configura funções alternativas para os pinos PE8 a PE15.
// (13 - 8) * 4 → Calcula a posição dos bits no AFR[1] para o pino PE13.
// AF1 (valor 1) → Faz PE13 trabalhar com TIM1_CH3.
GPIOE->AFR[1] &= ~(0xF << ((13 - 8) * 4)); // Zera os bits do AFR[1] para PE13
GPIOE->AFR[1] |= (1 << ((13 - 8) * 4)); // Define AF1 para PE13 (TIM1_CH3)
}
void TIM1_PWM_Init(void) {
// Habilita o clock do timer TIM1 no barramento APB2 (Advanced Peripheral Bus 2)
RCC->APB2ENR |= RCC_APB2ENR_TIM1EN;
// Define a frequência do timer (reduz clock para 1 MHz, ou seja, 1 tick = 1 µs)
TIM1->PSC = 168-1; // Prescaler (divide o clock do timer)
// Define o período do PWM (1ms = 1000 µs)
TIM1->ARR = 1000 - 1; // Define a contagem máxima (Período do PWM)
// Define o duty cycle (100 µs)
TIM1->CCR3 = 100; // para compensar eventuais atrasos de clock
// todo: fazer o necessario para PA8
// Configurar o canal 3 do TIM1 para operar no modo PWM1.
TIM1->CCMR2 &= ~TIM_CCMR2_OC3M; // Zerar os bits que definem o modo de saída do Canal 3
TIM1->CCMR2 |= (6 << TIM_CCMR2_OC3M_Pos); // Configurar o Canal 3 no modo PWM1
TIM1->CCMR2 |= TIM_CCMR2_OC3PE; // Habilitar o Preload para CCR3
// Configura a polaridade (ativo alto)
TIM1->CCER &= ~TIM_CCER_CC3P;
TIM1->CCER |= TIM_CCER_CC3E; // Habilitar a saída PWM no Canal 3
// as duas linhas abaixo sao para habilitar o interrupt q faz o pulse_count (remover)
// :down_arrow: Habilita interrupção de atualização
TIM1->DIER |= TIM_DIER_UIE;
// :down_arrow: Habilita a interrupção do TIM1 no NVIC
NVIC_EnableIRQ(TIM1_UP_TIM10_IRQn);
TIM1->CR1 |= TIM_CR1_CEN; // Inicia o contador primeiro do TIM1, fazendo com que o PWM comece a ser gerado
// Ativar a saída PWM nos pinos físicos (somente para timers avançados como TIM1 e TIM8)
TIM1->BDTR |= TIM_BDTR_MOE; // Ativa a saída PWM depois
}
// Handler da interrupção de update do TIM1 (a cada 1ms)
void TIM1_UP_TIM10_IRQHandler(void) {
if (TIM1->SR & TIM_SR_UIF) {
TIM1->SR &= ~TIM_SR_UIF; // Limpa flag de update
pulse_count++; // Incrementa contador de pulsos
}
}Thanks all for the help!
