Como Utilizar o RTC (Relógio de Tempo Real) da Franzininho C0 para Capturar Data e Hora

19/07/2024

ÍNDICE DE CONTEÚDO

Este post faz parte da série Franzininho C0 com STM32CubeIDE

Introdução

Neste tutorial, você aprenderá a utilizar o RTC (Relógio de Tempo Real) integrado na Franzininho C0 para capturar data e hora de maneira precisa.

O que é RTC?

Um Relógio de Tempo Real (RTC) é um componente essencial em sistemas eletrônicos, responsável por manter o controle do tempo de maneira contínua e precisa. Utilizado em aplicações que vão desde eletrodomésticos, como máquinas de lavar e micro-ondas, até dispositivos de registro de dados, o RTC garante que a contagem do tempo seja mantida mesmo quando o sistema principal está desligado.

Por que utilizar o RTC na Franzininho C0?

Os microcontroladores STM32, como o utilizado na Franzininho C0, possuem módulos RTC integrados. Isso significa que você não precisa de hardware adicional para implementar funcionalidades de cronometragem. Neste tutorial, explicaremos como configurar e usar o RTC da Franzininho C0 para ler e exibir a data e a hora atuais de forma eficiente.

Características do RTC do STM32

Calendário Completo: Com sub segundos, segundos, minutos, horas (12 ou 24 horas), dia da semana, data, mês e ano em formato binário e BCD.
Correção Automática: Para 28, 29 (ano bissexto), 30 e 31 dias do mês.
Alarme Programável.
Correção em Tempo Real: De 1 a 32767 pulsos do relógio RTC, utilizável para sincronização com um relógio mestre.
Detecção de Relógio de Referência: Um relógio de segunda fonte mais preciso (50 ou 60 Hz) pode ser usado para melhorar a precisão do calendário.
Calibração Digital: Com resolução de 0,95 ppm para compensar a imprecisão do cristal de quartzo.
Timestamp: Para salvar um instantâneo do calendário, acionado por um evento no pino de timestamp.
Operação em Múltiplos Modos: O RTC opera nos modos Run, Sleep e Stop.
Múltiplas Fontes de Relógio:
- Cristal externo de 32,768 kHz (LSE)
- Ressonador ou oscilador externo (LSE)
- Oscilador RC interno de baixa potência (LSI, com frequência típica de 32 kHz)
- Relógio externo de alta velocidade (HSE) dividido por 32

Para mais detalhes acesse: introduction-to-using-rtc

Os Melhores Treinamentos sobre Sistemas embarcados e IoT

Cursos com professores qualificados para acelerar sua carreira e projetos

MATRÍCULE-SE AGORA

Configuração no CubeMX

Navegue até a aba Clock Configuration. No bloco de configuração do RTC, selecione a fonte do oscilador. Para este exemplo, usaremos o oscilador interno LSI (Low-Speed Internal). Ele é menos preciso que os osciladores externos, mas é adequado para muitos projetos. Caso você esteja utilizando um oscilador externo, mantenha o LSE (Low-Speed External) habilitado no bloco do RTC. No nosso caso, deixaremos habilitado o LSI. Além disso, defina a frequência do HCLK para 48 MHz.

Volte para aba Pinout e em Timers, selecione RTC, habilite “Activate Clock Source” e “Activate Calendar” e em Data Format escolha Binary.

Nesse exemplo vamos exibir a data e hora pela Serial, logo configure a USART1. Em Sys habilite os pinos pin PA9 e pin PA10, depois os configure, respectivamente, como USART1_TX e USART1_RX. Depois, em Connectivity > USART1 selecione o modo assíncrono e mantenha as demais configurações.

Por fim, clique em em project > generate code para geração do código.

Desenvolvendo o código

Acesse o arquivo main.c
Inclua as seguintes bibliotecas:

#include "stdio.h"
#include "string.h"

Crie as seguintes variáveis globais para salvar os valores que serão exibidos na Serial.

uint8_t dia, mes, ano, horas, segundos, minutos;
char uart_tx_buffer[50];

Crie as declarações RTC_DateTypeDef data e RTC_TimeTypeDef tempo para definir estruturas que será responsável por armazenar a data e a hora no código.

RTC_DateTypeDef data;
RTC_TimeTypeDef tempo;

Por curiosidade, a definição dessas estruturas podem ser encontradas em Drivers > STM32C0xx_hal_Driver > STM32C0xx_hal_rtc.c.

Modifique a função principal, int main, com o seguinte código:

int main(void)
{
 /* USER CODE BEGIN 1 */
 /* USER CODE END 1 */
 /* MCU Configuration--------------------------------------------------------*/
 /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
 HAL_Init();
 /* USER CODE BEGIN Init */
 /* USER CODE END Init */
 /* Configure the system clock */
 SystemClock_Config();
 /* USER CODE BEGIN SysInit */
 /* USER CODE END SysInit */
 /* Initialize all configured peripherals */
 MX_GPIO_Init();
 MX_RTC_Init();
 MX_USART1_UART_Init();
 /* USER CODE BEGIN 2 */
 /* Ajuste a data e a hora aqui */
  data.Year = 24;  // 2024
  data.Month = RTC_MONTH_JUNE;
  data.Date = 25;
  data.WeekDay = RTC_WEEKDAY_TUESDAY;
  tempo.Hours = 9;
  tempo.Minutes = 5;
  tempo.Seconds = 0;
  HAL_RTC_SetDate(&hrtc, &data, RTC_FORMAT_BIN);
  HAL_RTC_SetTime(&hrtc, &tempo, RTC_FORMAT_BIN);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
	HAL_RTC_GetDate(&hrtc, &data, RTC_FORMAT_BIN);
	HAL_RTC_GetTime(&hrtc, &tempo, RTC_FORMAT_BIN);
	horas = tempo.Hours;
	minutos = tempo.Minutes;
	segundos = tempo.Seconds;
	dia = data.Date;
	mes = data.Month;
	ano = data.Year;
	sprintf(uart_tx_buffer, "Data: %02d/%02d/%04d Tempo: %02d:%02d:%02d\r\n", dia, mes, 2000+ano, horas, minutos, segundos);
	HAL_UART_Transmit(&huart1, (uint8_t *)uart_tx_buffer, strlen(uart_tx_buffer), 1000);
 }
 /* USER CODE END 3 */
}

Nesse código, após a configuração do clock do sistema e periféricos, é feita a configuração do RTC, definindo os valores iniciais de data e hora e usando as funções HAL_RTC_SetDate e HAL_RTC_SetTime para configurá-los.

Os parâmetros passados para HAL_RTC_SetDate são:

hrtc: o handle do RTC.
data: uma estrutura RTC_DateTypeDef que contém os valores de ano, mês, dia e dia da semana.
RTC_FORMAT_BIN: especifica que os valores estão no formato binário.

Os parâmetros passados para HAL_RTC_SetTime são:

hrtc: o handle do RTC.
tempo: uma estrutura RTC_TimeTypeDef que contém os valores de horas, minutos e segundos.
RTC_FORMAT_BIN: especifica que os valores estão no formato binário.

Dentro do nosso loop while, a leitura da data e hora é realizada com as funções HAL_RTC_GetDate e HAL_RTC_GetTime. Sendo os parâmetros passados para HAL_RTC_GetDate e HAL_RTC_GetTime os mesmos da função set. Após a leitura, os valores de data e hora são atualizados, formatados e exibidos na serial usando sprintf e HAL_UART_Transmit.

Na imagem abaixo temos o código que foi modificado.

Gravação

Ao finalizar o código, partiremos para gravação. Nessa etapa você pode utilizar o ST-Link seguindo as conexões da imagem abaixo e clicando em “run” no STM32CubeIde.

Ou você pode optar por utilizar um cabo usb e gravar conforme explicado no seguinte tutorial: gravar-franzininho-c0-via-stm32cubeprogrammer

Funcionamento

Bateria para Backup

É importante ressaltar que, para aplicações reais, é essencial garantir que a contagem do RTC seja mantida mesmo quando o dispositivo é desligado. Para isso, a STMicroelectronics recomenda o uso de uma bateria de backup conectada ao pino VBAT.

Existem várias maneiras de implementar esse backup. Duas fontes comuns de backup são:

Bateria: Pequenas células como NiMH, NiCd, Li-ion ou LiPo.
Supercapacitor: Capacitores de alta capacitância (de 0,22F a 1F).

A escolha entre bateria ou supercapacitor depende dos requisitos específicos da aplicação, como consumo de energia, tamanho e custo. Ambos os métodos proporcionam uma fonte confiável de backup para manter a precisão do RTC durante falhas de energia. Exemplos na imagem abaixo.

Conclusão

Neste tutorial proporcionou compreendemos como utilizar o RTC da Franzininho C0 para capturar e exibir a data e hora. Através da configuração inicial do RTC com as funções HAL_RTC_SetDate e HAL_RTC_SetTime, pudemos definir os valores iniciais de data e hora. Durante a execução do programa principal no loop while, as funções HAL_RTC_GetDate e HAL_RTC_GetTime foram utilizadas para atualizar continuamente os valores de data e hora, os quais foram então formatados e transmitidos pela porta serial UART.