Live Coding Musical com RP Pico e Sonic Pi
abril 24, 2026
Neste post, será demonstrado o uso de um Termistor NTC para medição de temperatura utilizando um ESP32. Para o cálculo da temperatura, será utilizado a equação Steinhart-Hart, que determina a temperatura do termistor a partir de sua resistência. Por fim, será desenvolvido um projeto de exemplificação para controle de temperatura interna de uma chocadeira que ,através de um cooler e uma resistência de aquecimento, será mantida uma temperatura aproximada de 37.7 °C. Como otimização da leitura do sensor, será utilizado um algoritmo que realizará a média das 10 últimas leituras para o cálculo da temperatura com menos ruído do sensor. Para a visualização da temperatura, será utilizado o Plotter Serial da própria IDE Arduino.
Para este post, serão utilizados os seguintes materiais:
O termistor, nome derivado do termo resistor termicamente sensível, é um sensor muito preciso e econômico para medição de temperatura. Estes sensores são, normalmente, usados em uma faixa de -55 a +200 °C, mas há termistores que podem ter a faixa de medição de cerca de 0,01 kelvin a 2000 kelvins (-273,14 ° C a 1726,85 ° C).
Para a obtenção da temperatura a partir da resistência, é utilizada a equação de parâmetro β, uma equação derivada da equação de Steinhart-Hart. A equação de Steinhart-Hart é uma expressão empírica que foi determinada como sendo a melhor expressão matemática para a relação de temperatura e de resistência de termistores NTC, pois fornece uma boa aproximação da temperatura real e é útil em toda a faixa de temperatura de trabalho do sensor.
Onde,
Onde,
Para posterior cálculo da temperatura, é necessário obter a resistência do termistor. O algoritmo abaixo calcula a resistência do termistor. A ele, deve ser informado o pino ao qual o termistor e o resistor em série estão conectados (na configuração de divisor de tensão), a tensão do microcontrolador (ESP32 é 3.3V), a resolução do ADC (ESP32 é 4095.0), e o valor da resistência do resistor em série, em Ohm's.
/**
Obtém a resistência de uma porta analógica informada do microcontrolador. Para isso,
deve-se estar conectado um resistor em série na montagem de um divisor de tensão.
@param pin - O pino da porta à ser medida a resistência.
@param voltageUc - A tensão nominal do microcontrolador.
@param adcResolutionUc - O valor máximo da saída do
ADC (Arduino UNO = 1024.0 | ESP32 = 4095.0).
@param resistenciaEmSerie - A resistência do resistor em série ao qual
está conectado à porta analógica.
@return a resistência, em OHM, obtida.
*/
float getResistencia(int pin, float voltageUc, float adcResolutionUc, float resistenciaEmSerie) {
float resistenciaDesconhecida = 0;
resistenciaDesconhecida =
resistenciaEmSerie *
(voltageUc /
(
(analogRead(pin) * voltageUc) /
adcResolutionUc
) - 1
);
return resistenciaDesconhecida;
}
O circuito para a captura da resistência pode ser visto abaixo:
Na Serial, será mostrado o valor da resistência, lida em ohms (11328.12 Ω ≅ 11 KΩ):
Caso deseje, obtenha o sketch de teste completo clicando na imagem de download abaixo: 
Para posterior cálculo da temperatura, é necessário obter o valor Beta do termistor. O valor Beta do Termistor pode ser obtido de suas formas: diretamente no datasheet do Termistor ou calculando através de um algoritmo.
/**
Calcule o valor Beta de um termistor, com os valores de resistência (RT1 e RT2)
obtidos do datasheet nas temperaturas correspondentes (T1 e T2).
@return O valor Beta.
*/
float calcularCoeficienteBetaTermistor() {
float beta;
const float T1 = 273.15; // valor de temperatura 0º C convertido em Kelvin.
const float T2 = 373.15; // valor de temperatura 100º C convertido em Kelvin.
const float RT1 = 27.219; // valor da resistência (em ohm) na temperatura T1.
const float RT2 = 0.974; // valor da resistência (em ohm) na temperatura T2.
beta = (log(RT1 / RT2)) / ((1 / T1) - (1 / T2)); // cálculo de beta.
return beta;
}
RT1 e RT2 pelos valores obtidos no passo 3 (valores 1. e 2., respectivamente).
Caso deseje, obtenha o sketch de teste completo clicando na imagem de download abaixo: Com a resistência e o valor Beta obtidos, é possível obter a temperatura lida pelo termistor. Ao algoritmo, devem ser informados o valor da resistência do Termistor, calculada anteriormente (em ohm), o valor da resistência do resistor em série com o Termistor (em ohm), a tensão do Microcontrolador (em Volts) e o valor Beta do Termistor, calculado ou obtido anteriormente (em Kelvin).
/**
Calcule a temperatura de um termistor através da equação de perâmetro Beta,
informando como parâmetros o valor da resistência do Termistor (em OHM),
o valor da resistência do resistor em série com o Termistor (em OHM),
a tensão do Microcontrolador (em Volts), e o valor Beta do Termistor (em Kelvin).
@param resistenciaTermistor - A resistência do Termistor.
@param resistenciaResistorSerie - A resistência do Resistor que está
ligado em série com o Termsitor.
@param voltageUc - A tensão de trabalho do Microcontrolador.
@param Beta - O valor Beta do Termistor.
@return A temperatura em Graus Celsius.
*/
float readTemperatureNTC(float resistenciaTermistor,
float resistenciaResistorSerie,
float voltageUc,
float Beta) {
// Constantes locais
const double To = 298.15; // Temperatura em Kelvin para 25 graus Celsius
const double Ro = 10000.0; // Resistência do termistor a 25 graus Celsius
// Variáveis locais
double Vout = 0; // Tensão lida da porta analógica do termistor.
double Rt = 0; // Resistência lida da porta analógica.
double T = 0; // Temperatura em Kelvin.
double Tc = 0; // Temperatura em Graus Celsius.
Vout = resistenciaResistorSerie /
(resistenciaResistorSerie + resistenciaTermistor) *
voltageUc; // Cálculo da tensão lida da porta analógica do termistor.
Rt = resistenciaResistorSerie * Vout /
(voltageUc - Vout); // Cálculo da resistência da porta analógica.
T = 1 /
(
1 / To + log(Rt / Ro) / Beta
); // Aplicação da equação de parâmetro Beta para obtenção da Temperatura em Kelvin.
Tc = T - 273.15; // Conversão de Kelvin para Celsius.
return Tc;
}
No algoritmo acima, foi utilizado uma equação de conversão de Kelvin para Celsius na linha 40. Esta fórmula é:
Onde,
Na Serial será mostrado o valor da temperatura lida em ºCelsius (15.334 ºC):
Caso deseje, obtenha o sketch de teste completo clicando na imagem de download abaixo: O projeto de exemplificação possui um circuito como no seguinte esquemático:
O projeto de exemplificação possui o seguinte sketch:
/******************************************************************************
Utilize o Termistor NTC junto de um ESP32 como Termômetro
Criado em 06 de Maio de 2021
por Michel Galvão
Eletrogate - Loja de Arduino \\ Robótica \\ Automação \\ Apostilas \\ Kits
https://www.eletrogate.com/
******************************************************************************/
// Definição dos pinos utilizados
#define pinTermistor 13
#define pinVentilador 32
#define pinAquecedor 33
// Variáveis Globais
const float setPoint = 37.7;
// Protótipo das Funções
float readTemperatureNTC(float resistenciaTermistor,
float resistenciaResistorSerie,
float voltageUc,
float Beta);
float getResistencia(int pin,
float voltageUc,
float adcResolutionUc,
float resistenciaEmSerie);
float calcularCoeficienteBetaTermistor();
float mediaDeVariavel(float variavel);
void setup() {
Serial.begin(115200);
pinMode(pinVentilador, OUTPUT);
pinMode(pinAquecedor, OUTPUT);
pinMode(pinTermistor, INPUT);
digitalWrite(pinAquecedor, HIGH);
digitalWrite(pinVentilador, HIGH);
}
void loop() {
float resistencia = getResistencia(13, 3.3, 4095.0, 10000.0);
float beta = calcularCoeficienteBetaTermistor();
float temperatura = readTemperatureNTC(resistencia,
10000.0,
3.3,
beta);
Serial.print("Temperatura:");
Serial.print(temperatura);
Serial.print(",Média:");
temperatura = mediaDeVariavel(temperatura);
Serial.println(temperatura);
if (temperatura > setPoint) {
digitalWrite(pinAquecedor, HIGH); // desliga aquecedor
digitalWrite(pinVentilador, LOW); // liga ventilador
delay(200);
} else if (temperatura < setPoint) {
digitalWrite(pinAquecedor, LOW); // liga aquecedor
digitalWrite(pinVentilador, HIGH); // desliga ventilador
delay(200);
} else {
digitalWrite(pinAquecedor, HIGH); // desliga aquecedor
digitalWrite(pinVentilador, HIGH); // desliga ventilador
delay(200);
}
delay(1000);
}
/**
Calcule a temperatura de um termistor através da equação de perâmetro Beta,
informando como parâmetros o valor da resistência do Termistor (em OHM),
o valor da resistência do resistor em série com o Termistor (em OHM),
a tensão do Microcontrolador (em Volts), e o valor Beta do Termistor (em Kelvin).
@param resistenciaTermistor - A resistência do Termistor.
@param resistenciaResistorSerie - A resistência do Resistor que está
ligado em série com o Termsitor.
@param voltageUc - A tensão de trabalho do Microcontrolador.
@param Beta - O valor Beta do Termistor.
@return A temperatura em Graus Celsius.
*/
float readTemperatureNTC(float resistenciaTermistor,
float resistenciaResistorSerie,
float voltageUc,
float Beta) {
// Constantes locais
const double To = 298.15; // Temperatura em Kelvin para 25 graus Celsius
const double Ro = 10000.0; // Resistência do termistor a 25 graus Celsius
// Variáveis locais
double Vout = 0; // Tensão lida da porta analógica do termistor.
double Rt = 0; // Resistência lida da porta analógica.
double T = 0; // Temperatura em Kelvin.
double Tc = 0; // Temperatura em Graus Celsius.
Vout = resistenciaResistorSerie /
(resistenciaResistorSerie + resistenciaTermistor) *
voltageUc; // Cálculo da tensão lida da porta analógica do termistor.
Rt = resistenciaResistorSerie * Vout /
(voltageUc - Vout); // Cálculo da resistência da porta analógica.
T = 1 /
(
1 / To + log(Rt / Ro) / Beta
); // Aplicação da equação de parâmetro Beta para obtenção da Temperatura em Kelvin.
Tc = T - 273.15; // Conversão de Kelvin para Celsius.
return Tc;
}
/**
Calcule o valor Beta de um termistor, com os valores de resistência (RT1 e RT2)
obtidos do datasheet nas temperaturas correspondentes (T1 e T2).
@return O valor Beta.
*/
float calcularCoeficienteBetaTermistor() {
float beta;
const float T1 = 273.15; // valor de temperatura 0º C convertido em Kelvin.
const float T2 = 373.15; // valor de temperatura 100º C convertido em Kelvin.
const float RT1 = 27.219; // valor da resistência (em ohm) na temperatura T1.
const float RT2 = 0.974; // valor da resistência (em ohm) na temperatura T2.
beta = (log(RT1 / RT2)) / ((1 / T1) - (1 / T2)); // cálculo de beta.
return beta;
}
/**
Obtém a resistência de uma porta analógica informada do microcontrolador. Para isso,
deve-se estar conectado um resistor em série na montagem de um divisor de tensão.
@param pin - O pino da porta à ser medida a resistência.
@param voltageUc - A tensão nominal do microcontrolador.
@param adcResolutionUc - O valor máximo da saída do
ADC (Arduino UNO = 1024.0 | ESP32 = 4095.0).
@param resistenciaEmSerie - A resistência do resistor em série ao qual
está conectado à porta analógica.
@return a resistência, em OHM, obtida.
*/
float getResistencia(int pin, float voltageUc, float adcResolutionUc, float resistenciaEmSerie) {
float resistenciaDesconhecida = 0;
resistenciaDesconhecida =
resistenciaEmSerie *
(voltageUc /
(
(analogRead(pin) * voltageUc) /
adcResolutionUc
) - 1
);
return resistenciaDesconhecida;
}
/**
Calcula a média de uma varável qualquer.
@param variavel - O valor da variável à ser feita a média.
@return a média da variável.
*/
float mediaDeVariavel(float variavel) {
const int qtdLeituras = 10;
static bool fistExecution = true; // é a primeira execução do algoritmo de média?
static float readings[qtdLeituras]; // as leituras da variável
static int readIndex = 0; // o índice da leitura atual
static float total = 0; // o total de corrida
float average = 0; // a média
if (fistExecution == true) { // se for a primeira execução do algoritmo de média, ...
for (int thisReading = 0; thisReading < qtdLeituras; thisReading++) { // Preenche todo o array das leituras da variável com o valor inicial da variável
readings[thisReading] = variavel;
}
total = variavel * qtdLeituras; // faz a soma de todos os valores do array de média
fistExecution = false; //
}
total = total - readings[readIndex]; // subtrai a última leitura
// define o valor atua ldo array com o valor da variável:
readings[readIndex] = variavel;
// some a leitura ao total:
total = total + readings[readIndex];
// avançar para a próxima posição no array:
readIndex = readIndex + 1;
// se estivermos no final do array, ...
if (readIndex >= qtdLeituras) {
// ...volta para o início do array:
readIndex = 0;
}
// calcula a média:
average = total / qtdLeituras;
return average;
}
Logo após, criamos variáveis locais para o setPoint (valor alvo no qual o ESP32 tenta manter a temperatura).
Fazemos, também, os protótipos das funções utilizadas no programa.
Em void setup(), configuramos a taxa de transferência para 115200 bits por segundo para a transmissão serial. Também configuramos os pinos utilizados pelo ESP32 com seus devidos valores (OUTPUT para saída e INPUT para entrada). Os pinos do módulo rele, configuramos como desligados (O módulo rele tem sua lógica de ativação dos reles invertida: HIGH desliga o rele e LOW liga o rele).
Em void loop(), criamos as variáveis locais que calcularão a resistência, o valor Beta e a temperatura do termistor.
Ainda em void loop(), fazemos a impressão dos valores de temperatura e média na Serial. A média da temperatura é calculada passando, para a função mediaDeVariavel(), o parâmetro de temperatura (verifique na seção Algoritmo de média abaixo a explicação do algoritmo de média). Estes dados serão visualizados no Plotter Serial da IDE Arduino. Para isso, devem ser formatados de modo correto: cada variável deve ser separada por um caractere de separação (seja ele um espaço (" "), um caractere qualquer (",") ou um caractere de tabulação ("\t")).
Em seguida, verificamos se a temperatura está maior do que o setPoint definido anteriormente. Caso seja maior, desligamos o aquecedor e ligamos o ventilador.
Caso a temperatura seja menor do que o setPoint definido anteriormente, ligamos o aquecedor e desligamos o ventilador.
Agora, se a temperatura não atender a nenhuma das condições anteriores, desligamos tanto o aquecedor quanto o ventilador.
/**
Calcula a média de uma varável qualquer.
@param variavel - O valor da variável à ser feita a média.
@return a média da variável.
*/
float mediaDeVariavel(float variavel) {
const int qtdLeituras = 10;
static bool fistExecution = true; // é a primeira execução do algoritmo de média?
static float readings[qtdLeituras]; // as leituras da variável
static int readIndex = 0; // o índice da leitura atual
static float total = 0; // o total de corrida
float average = 0; // a média
if (fistExecution == true) { // se for a primeira execução do algoritmo de média, ...
// Preenche todo o array das leituras da variável com o valor inicial da variável:
for (int thisReading = 0; thisReading < qtdLeituras; thisReading++) {
readings[thisReading] = variavel;
}
total = variavel * qtdLeituras; // faz a soma de todos os valores do array de média
fistExecution = false; //
}
total = total - readings[readIndex]; // subtrai a última leitura
// define o valor atual do array com o valor da variável:
readings[readIndex] = variavel;
// some a leitura ao total:
total = total + readings[readIndex];
// avançar para a próxima posição no array:
readIndex = readIndex + 1;
// se estivermos no final do array, ...
if (readIndex >= qtdLeituras) {
// ...volta para o início do array:
readIndex = 0;
}
// calcula a média:
average = total / qtdLeituras;
return average;
}
O termistor foi instalado no interior de uma chocadeira (incubadora de aves) para controle de sua temperatura interna utilizando uma resistência de aquecimento como aquecedor e um ventilador como resfriador.
Veja, no vídeo abaixo, a demonstração de funcionamento do esquemático:
Conhecendo, agora, como operar um termistor no ESP32, pode-se desenvolver outros projetos, como, por exemplo, uma impressora 3D que necessite de um sensor de temperatura em sua extrusora ou, ainda, um visualizador de temperatura ambiente em um display. Curtiu o post? Avalie e deixe um comentário! Siga-nos também no Instagram e nos marque quando fizer algum projeto nosso: @eletrogate. Até a próxima! Tenha a Metodologia Eletrogate na sua Escola! Conheça nosso Programa de Robótica Educacional.
|
Aprenda a medir temperatura com um Termistor NTC junto de um ESP32 utilizando a equação Steinhart-Hart para realizar o cálculo de temperatura detectada pelo termistor NTC.
Encontre tudo na Loja Eletrogate com frete grátis para compras acima de R$ 200
