Desenvolvimento de um Sistema Inteligente de Alerta de Temperatura com a Franzininho C0

Introdução

Neste artigo, vamos criar um sistema inteligente de alerta de temperatura utilizando um Termistor NTC, um LED RGB e um Buzzer. Este sistema será capaz de monitorar a temperatura ambiente e fornecer alertas visuais e sonoros quando a temperatura ultrapassar determinados limites.

Materiais Necessários

• 1 Termistor NTC 10k
• 1 LED RGB
• 1 Buzzer
• 3 Resistores de 300 ohms
• 1 Resistor de 10k ohms
• 1 Franzininho C0

Esquemático

Visão geral do Termistor NTC

Antes de colocar a mão na massa e criar o código, vamos entender o NTC. 

NTC é a sigla para Negative Temperature Coefficient, ou Coeficiente Negativo de Temperatura, em português. O termistor NTC é um componente eletrônico cuja resistência elétrica diminui à medida que a temperatura aumenta, seja no ambiente ou no dispositivo que está monitorando. 

Esse tipo de termistor é muito utilizado devido à sua alta sensibilidade às mudanças de temperatura e ao processo de fabricação simples. No entanto, devido à sua alta sensibilidade, a relação entre temperatura e resistência elétrica do NTC não é linear, apresentando um comportamento exponencial. Isso significa que pequenas mudanças na temperatura podem causar grandes variações na resistência elétrica. 

Os Melhores Treinamentos sobre Sistemas embarcados e IoT

Cursos com professores qualificados para acelerar sua carreira e projetos

MATRÍCULE-SE AGORA

Seu gráfico pode ser visto na imagem abaixo.

Intervalo de medição de Temperatura do Termistor NTC

Geralmente, os termistores conseguem operar em um intervalo de temperatura que vai de -200ºC a +1000ºC. No entanto, o sensor NTC apresenta maior estabilidade na faixa de -50ºC a +150ºC. Fora dessa faixa, o NTC pode funcionar, mas sem a precisão que é sua principal característica.

Aplicações do Sensor NTC

Devido às suas características, o sensor NTC pode ser utilizado em várias aplicações, como:

• Indicação de temperatura em amostras líquidas
• Acionamento e desligamento de carga:
• Disparo de alarme
• Medição de temperatura interna
• Circuitos de proteção

Circuito e Calibração do NTC 

Neste tutorial, estaremos utilizando um Termistor NTC 10kΩ de 3mm. Em seu circuito de calibração precisamos utilizar um resistor em série, como apresentado na imagem abaixo.

É necessário realizar a escolha do valor apropriado do resistor em série (Rs) para o termistor NTC baseado na faixa de temperatura a ser monitorada, que no exemplo vamos utilizar de 0°C a 50°C. Portanto, precisamos encontrar ou calcular a resistência do termistor NTC nos dois pontos de temperatura especificados, 0°C e 50°C.

Consultando os valores de resistência do termistor NTC no datasheet: datasheet 

• R0 (resistência a 0°C) = 32116  ohms
• R50 (resistência a 50°C) = 3588 ohms

Para calcular o resistor em série:

Portanto, utilizamos um resistor em série no valor de 10k ohms.  

Cálculo de Temperatura Utilizando a Equação de Steinhart-Hart

A curva de temperatura-resistência (T-R) de um termistor pode ser descrita por meio de equações matemáticas. A forma mais comumente utilizada é a Equação de Steinhart-Hart, que é apresentada abaixo:

Onde:

• T é a temperatura em Kelvin.
• R é a resistência do termistor em ohms.
• A, B, e C são coeficientes específicos do termistor.

Configuração 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. 

3. Volte para a página de configuração dos pinos, selecione “Trace and Debug” e  habilite “Serial Wire.

4. Clique sobre os pinos PA1, PA2 e PA3 e selecione para cada um “Gpio_Outuput”. 

5. Nomeie PA1 como “RED”, PA2 como “GREEN” e PA3 como “BLUE”.

6. Clique sobre o pino PA6 e selecione “Gpio_Outuput”. Depois, o renomeie como “BUZZER”. 

7. Clique sobre o pino PA5 e selecione “ADC1_IN5”.  Depois, em Analog > ADC1 habilite “IN5” e mantenha as demais configurações de Parameter Settings.

8. Em System Core > Sys habilite o uso dos pinos PA9 e PA10. Em seguida, selecione PA10 como “USART1_RX” e PA9 como “USART1_TX” e em “Connectivity” selecione a opção “USART1”, depois escolha o Mode “Asynchronous”. 

9. Gere o código em “Project” > “Generate Code”.

Código

1. Acesse Core > Src > main.c.

2. Faça a Inclusão das bibliotecas.

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "stdio.h"
#include "math.h"
#include "string.h"
/* USER CODE END Includes */

3. Crie as seguintes variáveis e constantes:

/* USER CODE BEGIN PV */
/* resistencia resistor serie */
#define resistor 10000.0f
/* contantes equacao Steinhart-Hart  */
#define A 0.001125308852122f
#define B 0.000234711863267f
#define C 0.000000085663516f
uint32_t leitura;
float temperatura;
/* USER CODE END PV */

• resistor: Valor do resistor de referência (10k ohms).
• A, B, C: Constantes da equação de Steinhart-Hart para cálculo de temperatura.
• leitura: Armazena o valor lido do ADC.
• temperatura: Armazena a temperatura calculada.

4. Adicione os protótipos de funções privadas:

/* USER CODE BEGIN PFP */
float calcular_temperatura();
void controlar_leds_e_buzzer();
void transmitir_temperatura();
/* USER CODE END PFP */

5. Crie a seguinte Função para Calcular Temperatura:

Essa função calcula a temperatura com base no valor lido de um sensor NTC (Negative Temperature Coefficient) usando a equação de Steinhart-Hart.

float calcular_temperatura(){
	float ntc_resistance;
	/* calcula resistencia NTC */
	ntc_resistance = ((resistor)/((4095.0f/leitura) - 1.0f));
	/* Calcula temperatura usando equacao Steinhart-Hart  */
	float ntc_ln = log(ntc_resistance);
	temperatura = (1.0f / (A + B * ntc_ln + C * (ntc_ln * ntc_ln * ntc_ln))) - 273.15f;
	return temperatura;
}

• ntc_resistance: Calcula a resistência do NTC a partir do valor lido pelo ADC. Foi utilizado a fórmula de divisor de tensão, isolando a resistência que queremos encontrar.

• ntc_ln: Calcula o logaritmo natural da resistência.
• temperatura: Calcula a temperatura usando a equação de Steinhart-Hart e converte para Celsius.

6. Crie a função de controle dos LEDs e Buzzer

Essa função será responsável por ajustar o estado de três LEDs e um buzzer com base no valor da variável temperatura. Dependendo da faixa de temperatura, ela liga uma cor de um LED específico e o buzzer (em temperaturas extremas).

void controlar_leds_e_buzzer() {
   if (temperatura <= 15) {
       // Ligar LED azul
       HAL_GPIO_WritePin(BLUE_GPIO_Port, BLUE_Pin, GPIO_PIN_SET);
       // Desligar outros LEDs
       HAL_GPIO_WritePin(GREEN_GPIO_Port, GREEN_Pin, GPIO_PIN_RESET);
       HAL_GPIO_WritePin(RED_GPIO_Port, RED_Pin, GPIO_PIN_RESET);
        // Desligar buzzer
       HAL_GPIO_WritePin(BUZZER_GPIO_Port, BUZZER_Pin, GPIO_PIN_RESET);
   } else if (temperatura > 15 && temperatura <= 30) {
       // Ligar LED verde
       HAL_GPIO_WritePin(GREEN_GPIO_Port, GREEN_Pin, GPIO_PIN_SET);
       // Desligar outros LEDs
       HAL_GPIO_WritePin(BLUE_GPIO_Port, BLUE_Pin, GPIO_PIN_RESET);
       HAL_GPIO_WritePin(RED_GPIO_Port, RED_Pin, GPIO_PIN_RESET);
       // Desligar buzzer
       HAL_GPIO_WritePin(BUZZER_GPIO_Port, BUZZER_Pin, GPIO_PIN_RESET);
   } else if (temperatura > 30) {
       // Ligar LED vermelho
       HAL_GPIO_WritePin(RED_GPIO_Port, RED_Pin, GPIO_PIN_SET);
       // Desligar outros LEDs
       HAL_GPIO_WritePin(BLUE_GPIO_Port, BLUE_Pin, GPIO_PIN_RESET);
       HAL_GPIO_WritePin(GREEN_GPIO_Port, GREEN_Pin, GPIO_PIN_RESET);
       // Ligar buzzer
       HAL_GPIO_WritePin(BUZZER_GPIO_Port, BUZZER_Pin, GPIO_PIN_SET);
   }
}

7. Crie a função para transmitir pela UART o valor de temperatura calculado.

void transmitir_temperatura() {
   // Divida a temperatura em parte inteira e parte decimal
   int parte_inteira = (int)temperatura;
   int parte_decimal = (int)((temperatura - parte_inteira) * 100); // Duas casas decimais
   // Buffer para a string a ser transmitida
   char buffer[50];
   // Converta as partes para string e envie via UART
   sprintf(buffer, "Temperatura: %d.%02d\r\n", parte_inteira, parte_decimal);
   HAL_UART_Transmit(&huart1, (uint8_t*)buffer, strlen(buffer), HAL_MAX_DELAY);
}

8. Por fim, ajuste a função principal conforme abaixo. 

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_ADC1_Init();
 MX_USART1_UART_Init();
 /* USER CODE BEGIN 2 */
 /* USER CODE END 2 */
 /* Infinite loop */
 /* USER CODE BEGIN WHILE */
 while (1)
 {
   /* USER CODE END WHILE */
   /* USER CODE BEGIN 3 */


	// ADC Polling
	HAL_ADC_Start (&hadc1);   // inicia leitura ADC
	HAL_ADC_PollForConversion (&hadc1, 1000); //aguarda conversao seja concluida
	leitura = HAL_ADC_GetValue (&hadc1); //  armazenar o valor lido pelo ADC
	HAL_ADC_Stop(&hadc1);
	// Calcula a temperatura
	temperatura = calcular_temperatura();
	// Controla os LEDs e o buzzer baseado na temperatura
	controlar_leds_e_buzzer();
	// Transmite a temperatura via UART
	transmitir_temperatura();
 }


 /* USER CODE END 3 */
}

No Loop Infinito (while(1)) realiza-se a leitura do ADC pelo método polling e chama-se as funções de calcular a temperatura, controlar LEDs e buzzer e transmitir por  UART.

9. O código modificado pode ser visto na imagem abaixo. 

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

No vídeo abaixo temos o funcionamento do projeto. Se a temperatura está menor ou igual a 15°C o LED liga na cor azul, se está entre 15° e 30°C o LED liga na cor verde ligado e se está maior que 30°C o LED liga na cor vermelho e o buzzer dispara. Você pode ajustar esses limites de temperatura no código conforme quiser. 

Além disso, na serial está sendo exibido o valor da temperatura. 

Conclusão

Neste artigo, desenvolvemos um sistema inteligente de alerta de temperatura usando a Franzininho C0, um Termistor NTC, um LED RGB e um Buzzer. O sistema monitora a temperatura ambiente e emite alertas visuais e sonoros quando a temperatura passa de certos limites.

Montamos o circuito, configuramos o CubeMx, e escrevemos o código necessário para leitura do sensor e para que o LED mude de cor e o Buzzer toque dependendo da temperatura medida.
Imagens do documento: https://drive.google.com/drive/folders/1Q_b8hUim65sVFyyukCFvSbXBcN0Hb7CZ?usp=drive_link