Trabalhando com o sensor de temperatura interno da Franzininho C0

Introdução

Os microcontroladores STM32 possuem um sensor de temperatura interno conectado a um canal de entrada ADC dedicado. Destina-se a ser usado como um indicador da temperatura central do MCU. Nesse tutorial aprenderemos a trabalhar com esse sensor, realizando as devidas configurações pelo CubeMx. 

Como trabalhar com o sensor de temperatura interno

A figura abaixo, mostra como é o diagrama de blocos do sensor de temperatura interno STM32. Ele está conectado internamente a um canal ADC dedicado, bem como a tensão de referência analógica interna (VREFINT ).

Para ler o sensor de temperatura interno do STM32, realizaremos os seguintes passos:

• Habilitar o canal ADC do sensor de temperatura
• Definir seu tempo de amostragem
• Iniciar a conversão ADC
• Obter a leitura ADC e calcular a tensão Vsense
• Obter a temperatura (em °C) usando a equação mostrada abaixo

Onde, V30 é a tensão de saída do sensor em (30°C) e AvgSlope é a inclinação média dada em mV/C°. Ambos valores estão definidos na ficha técnica do microcontrolador. 

Os Melhores Treinamentos sobre Sistemas embarcados e IoT

Cursos com professores qualificados para acelerar sua carreira e projetos

MATRÍCULE-SE AGORA

E, Vsense precisará ser calculado utilizando o valor de VREFINT que também pode ser encontrado nas especificações do microcontrolador. 

Configurando CubeMx

1. Abra STM32Cube , crie um novo projeto e selecione o microcontrolador de destino “STM32C011F6P6”. 

2. 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. Depois volte para a página de configuração dos pinos, selecione “Trace and Debug” e  habilite “Serial Wire

3. Em Analog > ADC1, habilite “Temperature Sensor Channel” e “Vrefint channel”. Em parameters settings, deixe desabilitado o modo de conversão contínua, defina o tempo de amostragem para 160,5 ciclos, escolha 2 para número de conversões e  selecione o evento Timer1 como fonte de disparo. 

4. Na guia DMA do ADC, adicione 1 canal DMA para ler ambos os canais no modo circular, conforme mostrado abaixo.

5. Em NVIC habilite a interrupção. 

6. Após configurar o ADC, é necessário ajustar o Timer para sincronizar a leitura do sensor de temperatura. Para isso, ajuste o TIM1 para gerar eventos de atualização a cada 20 ms. Configure o valor do Prescaler para 1000-1 e em seguida, defina o Counter Period para 960-1. Além disso, escolha o evento TRGO como “Evento de atualização”.

7. Em seguida, ajuste a USART1 no modo assíncrono. Exibiremos o valor da temperatura pela Serial. 

8. Por fim, gere o código em “Project” > “Generate Code”.

Implementando o código

1. Acesse o arquivo main.c

2. Inclua as seguintes bibliotecas

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

3. Declare os parâmetros necessários para o cálculo de temperatura. 

#define AVG_SLOPE (0.00253F) // 2.53 mV/°C
#define V_AT_30C  (0.76F)   // 0.76V at 30°C
#define V_REF_INT (1.12F)    // reference voltage

4. Declare as seguintes variáveis

uint8_t UpdateEvent = 0;
uint16_t AD_RES[2];
float Temperature, V_Sense, V_Ref;
char TxBuffer[30];

5. Crie a função callback “HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)”. Ela será  chamada automaticamente  quando a conversão ADC estiver concluída. Dentro desta função, defina como 1 a variável “UpdateEvent”, a fim de sinalizar que a conversão foi completada.

void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
{
   UpdateEvent = 1;
}

6. Ajuste a função principal com o seguinte código:

nt 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_DMA_Init();
 MX_ADC1_Init();
 MX_TIM1_Init();
 MX_USART1_UART_Init();
 /* USER CODE BEGIN 2 */
 HAL_TIM_Base_Start(&htim1); 
 HAL_ADCEx_Calibration_Start(&hadc1);
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */
	  HAL_ADC_Start_DMA(&hadc1, (uint32_t*)AD_RES, 2);   // Start ADC Conversion
	  if(UpdateEvent){
	   // Calculate The Temperature
	    V_Ref = (float)((V_REF_INT * 4095.0) / AD_RES[0]);
	    V_Sense = (float)(AD_RES[1] * V_Ref) / 4095.0;
	    Temperature = (((V_AT_30C  - V_Sense) * 1000.0) / AVG_SLOPE) + 30.0;
	    int parte_inteira = (int)Temperature/1000.0;
	    int parte_decimal = (int)((Temperature - parte_inteira) * 100.0); // Uma casa decimal
	   // Send The Result To PC Over Serial Port
	   sprintf(TxBuffer, "Temperatura: %d.%02d\r\n", parte_inteira, parte_decimal);
	   HAL_UART_Transmit(&huart1, (uint8_t*)TxBuffer, strlen(TxBuffer), 100);
	   UpdateEvent = 0;
  }
 }
 /* USER CODE END 3 */
}

Neste código, iniciamos o timer com a função `HAL_TIM_Base_Start(&htim1)` e calibramos o ADC com `HAL_ADCEx_Calibration_Start(&hadc1)`. No loop infinito, a conversão do ADC é iniciada utilizando DMA com a função `HAL_ADC_Start_DMA(&hadc1, (uint32_t*)AD_RES, 2)`. Sempre que a variável `UpdateEvent` é atualizada, os cálculos para determinar a temperatura são realizados e o valor calculado é enviado pela UART.

7. Na imagem abaixo temos o código modificado.

Gravação do código

Ao finalizar o código, partiremos para gravação. Nessa etapa você pode utilizar o ST-Link seguindo as conexões adequadas ou utilizar um cabo USB como explicado no tutorial:  https://embarcados.com.br/gravar-franzininho-c0-via-stm32cubeprogrammer/.

Funcionamento

Conclusão

Neste tutorial, aprendemos a trabalhar com o sensor de temperatura interno da Franzininho C0. Configuramos o ADC e o Timer1 para realizar leituras de temperatura sincronizadas e enviamos os resultados via UART. O processo incluiu a inicialização de periféricos, calibração do ADC, configuração do DMA para conversões contínuas e a implementação de um loop infinito para processar e transmitir as leituras de temperatura.