Introdução
Os temporizadores são um dos recursos mais importantes dos microcontroladores. Eles nos permitem medir quanto tempo algo leva para ser executado, controlar com precisão o tempo dos pinos e até mesmo implementar sistemas operacionais.
Neste guia, apresentaremos o processo de configuração do STM32CubeIDE para utilização de Timers, além de demonstrar a criação de atrasos e interrupções através desse recurso na Franzininho C0.
Noções básicas sobre Timers
Um timer (temporizador) conta para cima ou para baixo a depender da configuração. Por exemplo, um temporizador de 16 bits contará de 0 a 65535. Podemos citar comparação de saída (OC), captura de entrada (IC) e a modulação por largura de pulso (PWM) como aplicações comuns com Timers.
No Franzininho C0, temos disponíveis 8 timers, sendo:
Os Melhores Treinamentos sobre Sistemas embarcados e IoT
Cursos com professores qualificados para acelerar sua carreira e projetos
- 1 para controle de motor e 4 de uso geral, descritos na tabela abaixo.
- O temporizador SysTick, o qual é um contador decrescente de 24 bits, ou seja, faz a contagem regressiva de um valor inicial até 0 e é usado para iniciar uma ação periodicamente.
- 2 watchdogs que servem para identificar mau funcionamento do programa e reiniciar o sistema a partir de um reset.
Prescaler
Os temporizadores funcionam com velocidade de relógio que você configura. Por exemplo, em um microcontrolador STM32C0 possui um clock de 48 MHz e 16 bits, podendo contar até 65.535 antes de reiniciar. Isso significa que podemos medir eventos de até 819 microssegundos. Se precisarmos medir eventos mais longos, ajustamos o prescaler, que divide a velocidade do relógio.
Fórmulas para cálculo de ajuste Prescaler e contador:
Observação: o “-1” na fórmula ocorre porque tanto a contagem do contador quanto a do prescaler começam em 0.
Exemplo 01 — criação de atraso com timer
Nesse exemplo, nosso objetivo é piscar um LED, conectado ao PB6, a cada 0,5s (500ms) utilizando a criação de atraso com o Timer 3.
Hardware necessário:
- 1 franzininho C0.
- 1 led (cor a sua escolha)
- 1 resistor 300 ohms
Esquemático:
Observação: Fica ao seu critério utilizar o LED da placa franzininho ou adicionar um LED na protoboard e conectar conforme o esquemático ilustrado na imagem acima.
Configuração CubeMX:
- Abra STM32Cube , crie um novo projeto e selecione o microcontrolador de destino “STM32C011F6P6”.
- Vá para a página de configurações de relógio e em HCLK digite 48 MHz para a frequência de saída desejada do sistema. Pressione a tecla “Enter” e deixe o aplicativo resolver os divisores/multiplicadores PLL necessários para atingir a taxa de clock desejada.
- Volte para a página de configuração dos pinos, selecione “Trace and Debug” e habilite “Serial Wire”
- Selecione no microcontrolador o pino “PB6” e escolha “GPIO_Output”. Em System Core > GPIO selecione o pino “PB6” e mude a LABEL para “LED”.
- Por fim, avançaremos para a configuração do TIMER. Nesta fase, é necessário calcular os valores do contador e do prescaler, ambos podendo variar até 65.535, uma vez que estamos lidando com um timer de 16 bits.
Cálculo do timer para delay de 0,5s (500ms):
- Clock do sistema: interno 48 MHz
- Prescaler escolhido para o exemplo: 48000 – 1
6. Após obter os valores de ajuste, clique em “Timers”, selecione “TIM3” e escolha o clock interno como fonte. Em “Parameter Settings”, ajuste os valores de PSC e contador conforme necessário. Verifique se o modo de contagem está definido como “UP” para garantir uma contagem crescente e certifique-se de que o “auto-reload” esteja habilitado.
- A última etapa é gerar o código, clicando em project > generate code.
Código:
Em Core > Src > main.c modifiquei a função main com o código abaixo.
int main(void)
{
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
MX_TIM3_Init();
HAL_TIM_Base_Start(&htim3); //inicia contagem
/* USER CODE BEGIN WHILE */
while (1)
{
if(__HAL_TIM_GET_FLAG(&htim3, TIM_FLAG_UPDATE)){
__HAL_TIM_CLEAR_FLAG(&htim3, TIM_FLAG_UPDATE);
HAL_GPIO_TogglePin(GPIOB, LED_Pin);
}
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
}
/* USER CODE END 3 */
}
Gravação STM32CubeIde:
- Utilizando um gravador ST-LINK realize as conexões como indicado na figura.
- Pressione no ícone semelhante a um martelo, aguarde o build do projeto e caso não tenha erros pressione “run”.
- Após o run, configure o debugguer conforme a imagem abaixo e aguarde a gravação do código.
Funcionamento:
Pronto! Agora você terá seu LED piscando, utilizando a criação de atrasos com timers:
Exemplo 02 – gerando interrupção com o timer.
No exemplo 02, queremos criar o mesmo efeito do exemplo 01, ou seja, piscar um LED, conectado ao PB6, a cada 0,5s (500ms). No entanto, vamos utilizar outra abordagem: uma interrupção será gerada quando o timer atingir 500ms.
Hardware necessário e esquemático da montagem:
Será usado o mesmo hardware e esquemático apresentado no exemplo 01.
Configuração CubeMX:
- Clique duas vezes sobre o arquivo .ioc
- Mantenha todas as configurações feitas no exemplo 01, modificando apenas um detalhe: em TIM3, vá em “NVIC Settings” e habilite a interrupção.
- Gere o código novamente.
Código:
Em Core > Src > main.c adicione no int main HAL_TIM_Base_Start_IT .
int main(void)
{
HAL_Init();
SystemClock_Config();
MX_GPIO_Init();
MX_TIM3_Init();
HAL_TIM_Base_Start_IT(&htim3);
while (1)
{
}
}
Após o int main, adicione a função abaixo.
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
HAL_GPIO_TogglePin(GPIOB, LED_Pin);
}
Gravação STM32CubeIde:
Para gravação repita o mesmo processo explicado no exemplo 01.
Funcionamento:
Pronto! Você terá o mesmo efeito do exemplo 01, mas utilizando a abordagem de interrupção que é extremamente útil para lidar com eventos assíncronos em tempo real.
Desvendando as funções dos exemplos de código
Exemplo 01:
O código começa com a inicialização do sistema, configuração do clock, dos pinos GPIO e do Timer TIM3. A função HAL_TIM_Base_Start(&htim3) é usada para iniciar a contagem do timer.
Dentro do loop principal while(1), o código verifica se a flag de atualização do timer foi acionada (__HAL_TIM_GET_FLAG(&htim3, TIM_FLAG_UPDATE)). Se essa flag estiver ativada, indica que o timer atingiu o período desejado. Então, o código limpa essa flag e alterna o estado do pino GPIO que controla o LED.
Exemplo 02:
A abordagem muda para utilizar uma interrupção do timer. Após as mesmas configurações iniciais, a função HAL_TIM_Base_Start_IT(&htim3) é usada para iniciar o timer com interrupção.
Além disso, é adicionada uma função de callback HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim), que é chamada sempre que o timer atinge o período desejado. Dentro dessa função, o estado do pino GPIO é invertido, alcançando o mesmo efeito de piscar o LED.
Conclusão
Ao longo deste tutorial, aprendemos a usar os timers do Franzininho C0 para criar atrasos e gerenciar interrupções. Com exemplos práticos, mostramos como configurar o STM32CubeIDE e calcular os valores necessários para ajustar os timers conforme desejado. Ao entender os conceitos básicos e aplicá-los em projetos simples, como piscar um LED, vocês estão preparados para utilizar os timers em suas aplicações, garantindo precisão no controle do tempo ou lidar com eventos assíncronos em tempo real.
