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:
Para o projeto de exemplificação, será utilizado, adicionalmente o seguinte material:
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).
O primeiro termistor NTC foi descoberto em 1833 por Michael Faraday (1791-1867), que relatou o comportamento semicondutor do sulfeto de prata. Faraday notou que a resistência do sulfeto de prata diminuiu drasticamente com o aumento da temperatura (Esta foi também a primeira observação documentada de um material semicondutor). Como os primeiros termistores eram de dificil produção e as aplicações para a tecnologia eram limitadas, a produção comercial de termistores não começou até a década de 1930 quando um termistor comercialmente viável foi inventado por Samuel Ruben (1900-1988).
Neste, a resistência do sensor diminui conforme sua temperatura aumenta. Muitos destes termistores NTC são feitos de um disco prensado, haste, placa, cordão ou chip fundido de material semicondutor, como óxidos metálicos sintetizados. Eles funcionam porque o aumento da temperatura de um semicondutor aumenta o número de portadores de carga ativos. Quanto mais portadores de carga estiverem disponíveis, mais corrente um material pode conduzir.
Neste, a resistência aumenta conforme a temperatura aumenta. A maioria dos termistores PTC são feitos de cerâmica policristalina dopada (contendo titanato de bário e outros compostos), que tem a propriedade de aumentar sua resistência repentinamente a uma determinada temperatura crítica. O titanato de bário é ferroelétrico e sua constante dielétrica varia com a temperatura. Por sua vez, este tipo de termistor é sub-dividido em duas categorias: Silistores e Termistor PTC tipo chaveamento.
Utilizam o silício como material semicondutor. Ao contrário dos termistores PTC cerâmicos, os silistores têm uma característica de resistência-temperatura quase linear. Os termistores PTC de silício têm um desvio muito menor do que um termistor NTC.
O termistor PTC do tipo chaveado possui uma curva resistência-temperatura altamente não linear. Quando o termistor PTC tipo chaveamento é aquecido, a resistência começa a diminuir inicialmente, até que uma determinada temperatura crítica seja atingida. À medida que a temperatura é aumentada acima desse valor crítico, a resistência aumenta drasticamente.
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.
A equação recebeu o nome de John S. Steinhart (1929-2003) e Stanley R. Hart(1935-) , que publicaram a relação pela primeira vez em 1968. O Professor Steinhart foi membro da União Geofísica Americana e da Associação Americana para o Avanço da Ciência e também foi membro do corpo docente da Universidade de Wisconsin-Madison de 1969 a 1991. O Dr. Hart é um cientista sênior da Woods Hole Oceanographic Institution desde 1989 e membro da Sociedade Geológica da América, da União Geofísica Americana, da Sociedade Geoquímica e Associação Europeia de Geoquímica, à qual foi associado com o professor Steinhart na Carnegie Institution de Washington quando a equação foi desenvolvida.
A sentença da equação Steinhart-Hart, descrita anteriormente, é
Onde,
A Equação de parâmetro β, como dito antes, é uma equação derivada da equação de Steinhart-Hart. A sentença desta equação é
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.
O seguinte algoritmo, desenvolvido no Framework Arduino, permite obter a resistência de uma determinada porta analógica de um microcontrolador.
/**
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.
Para obter o valor Beta de um Termistor pelo datasheet, siga os passos abaixo:
O valor Beta do Termistor, de acordo com o datasheet, é 3380 Kelvin.
Para obter o valor Beta de um Termistor através de um algoritmo no Arduino, siga os passos abaixo:
/**
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).
O seguinte algoritmo, desenvolvido no Framework Arduino, permite obter a temperatura de um determinado termistor aplicando a equação de parâmetro β:
/**
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,
Após criar e fazer o upload de um sketch para exibir, através do Monitor Serial, a resistência de um termistor, utilizando o algoritmo acima, e montar o circuito abaixo:
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;
}Neste código, não é preciso adicionar nenhuma biblioteca externa. Fazemos, primeiro, a definição das portas do ESP32 utilizadas:
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.
O cálculo da média de uma determinada variável é feita através do seguinte algoritmo:
/**
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;
}Verifique, na imagem abaixo, que, enquanto, a temperatura possui ruído de leitura, a média corrige e suaviza as leituras da temperatura.
Este gráfico foi gerado com o Plotter Serial da IDE Arduino. Para acessar esta ferramenta, vá em: Ferramentas → Plotter Serial (Ctrl + Shift + L)
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.
|
A Eletrogate é uma loja virtual de componentes eletrônicos do Brasil e possui diversos produtos relacionados à Arduino, Automação, Robótica e Eletrônica em geral.
Conheça a Metodologia Eletrogate e Lecione um Curso de Robótica nas Escolas da sua Região!
Rua Rio de Janeiro, 441
Centro - Belo Horizonte/MG
CEP 30160-041
*Não temos atendimento físico
Eletrogate Componentes Eletrônicos
CNPJ: 18.917.521/0001-73
