Hoje você irá aprender como funciona cada sensor de temperatura Arduino: LM35, DS18B20 e TMP36 e também irá aprender a programar todos eles.
- Caso você esteja em busca do sensor DHT11, acesse o artigo: Sensor de umidade e temperatura DHT11
Esses sensores juntos possuem uma grande aplicabilidade quando utilizados para medir a temperatura de animais, humanos e líquidos (sensor de temperatura DS18B20).
No entanto, você verá que é bastante simples obter a temperatura desses 3 sensores: LM35, DS18B20 e TMP36 já que basta saber escrever algumas linhas de código.
Preparado (a)?
Então veja o que separamos para você:
👨💻 Comprar Agora – Kit Iniciante Arduino com Tutorial e + 20 Projetos ✅
Quais são os principais sensores de temperatura e suas principais características?
Na atualidade, dispomos de diversos sensores de temperatura de baixo custo que podem ser usados em nossos projetos com a plataforma Arduino e que calculam a tensão de saída e dispõem a temperatura em outras escalas, como: Celsius, Fahrenheit e Kelvin.
Mas, são tantos que até ficamos meio perdidos, não concorda?
Dessa forma, trago nos próximos tópicos os mais utilizados hoje em dia e suas principais características para que você possa escolher o componente que mais se encaixa no seu projeto.
Mas, se você não domina a plataforma Arduino ainda, recomendo você ler o artigo: tudo sobre o que é a plataforma open-source Arduino.
Ou então, caso queira um curso na área, acesse o guia dos melhores treinamentos online sobre Arduino e se matricule nos Cursos Gratuitos ou Pagos mais bem avaliados deste ano.
- Você também pode se interessar: 10 Melhores invenções com a plataforma Arduino
Família LM 35/335/34
LM35: o que é e como funciona?
O sensor de temperatura Arduino LM35 usa diodos como princípio para medir a temperatura e funciona da seguinte forma: conforme os graus mudam, a tensão se altera a uma taxa conhecida de 10mV/°C.
Sendo assim, para medir a temperatura, precisamos apenas medir a tensão de saída do sensor e fazer um cálculo para converter os Volts em °C.
Esse sensor é bastante preciso e se trata de um componente eletrônico analógico.
No programa você vai encontrar a seguinte conversão, veja só:
// Faz a leitura do sensor valorSensor = analogRead(sensorPin); // Faz a conversão para tensão tensaoSaida = (valorSensor * 5000) / 1024; // Calculando a temperatura para o LM35 temperaturaC = tensaoSaida / 10;
Essa família de sensores LM35, LM335 e LM34 trabalha de forma similar, e, a única diferença entre eles é apresentarem as temperaturas em escalas diferentes (Kelvin, Celsius e Fahrenheit) e serem calibrados de formas diferentes também.
Ou seja, a saída dos sensores no quesito tensão (milivolts) é calibrada de forma proporcional para os diferentes tipos de escalas.
Por exemplo, se o LM35 libera uma tensão de 285 mV, isso significa que o valor da temperatura será 28,5°C.
Da mesma forma se tivermos o LM34 liberando uma tensão de 285 mV, a temperatura proporcional será de 30 °F…
Isso fica mais claro na tabela abaixo, veja as diferenças entre esses sensores e suas respectivas escalas:
| Especificações | LM34 | LM335 | LM35 |
| Escala Usada | Fahrenheit | Kelvin | Celsius |
| Temperatura de trabalho em °C | -50°C até 150°C | -40°C até 100°C | -55°C até 150°C |
| Linearidade | 10 mV/°F | 10 mV/K | 10 mV/°C |
| Precisão a 25 °C | ± 1°F | ± 1 K | ± 0.5°C |
Aqui você encontra os datasheets do LM35, LM335 e do LM34.
Agora, as características que eles possuem em comum, são:
- Temperatura de trabalho que varia de -55°C até 150°C;
- Utilizam tensão negativa para temperaturas negativas;
- Operam entre 4V e 30V.
Mas você deve estar se perguntando por que sensores em escalas diferentes?
Esses sensores foram criados para atender diversos mercados de forma a se adequarem a diversas escalas de temperatura.
Por exemplo, aplicações exteriores onde a escala de graus Celsius não é tão popular, as pessoas preferem utilizar outras escalas, como a escala Fahrenheit nos EUA.
Além disso, qualquer faixa pode ser facilmente convertida para qualquer outra faixa da seguinte forma (digitalmente):
Celsius = Kelvin – 273,15
Fahrenheit = ((Kelvin – 273,15) * 9/5) + 32
Fahrenheit = (Celsius * 9/5) + 32
Ademais, com esses tipos de sensores, você só precisa de um voltímetro e uma fonte de alimentação de 4 ou 5 volts para ler a temperatura.
Se seu LM35 lê 0,28 volts, multiplique isso por 100 e você tem 28 graus C.
Se seu LM34 lê 0,72 volts, multiplique isso por 100 e você tem 72 graus F.
Simples assim!
Pinagem do sensor de temperatura LM35
– Este pino vai conectado no +5V do Arduino;
– Já este, é o pino de dados do sensor, conecte-o no pino analógico A0 do Arduino;
– Por fim, o GND representa o pino negativo, conecte-o ao GND do Arduino.
Montagem do sensor de temperatura Arduino e LM35
Chegou a hora de você aprender a fazer a montagem e a programar o LM35.
A montagem do projeto com o LM35 fica da seguinte forma, observe:
- Apenas conecte o sinal do LM35 no pino A0 do Arduino e o positivo do sensor no +5V e o negativo no GND.
Código utilizado no projeto
Por padrão, o programa está destinado a fazer as leituras do LM35 mas, caso for fazer medidas no LM34 ou no LM335 basta descomentar suas respectivas linhas na IDE.
O Arduino irá então ler os valores medidos do sensor de temperatura e converter em graus kelvin, fahrenheit ou celsius, dependendo de qual sensor que estiver utilizando.
A partir disso, poderemos acompanhar no serial monitor a variação de temperatura e tensão do sensor.
Se liga no código:
/* Código do projeto sensor de temperatura Família LM
Monte seus próprios projetos sem dificuldade com programação!
ACESSE: https://flaviobabos.com.br/
*/
const int sensorPin = A0; // Esse é o pino do Arduino que irá ler a saída do sensor
float valorSensor; // Essa variável irá ser usada para armazenar o input do sensor
float tensaoSaida; // Essa variável irá ser usada para armazenar a tensão do sensor
float temperaturaC, temperaturaF; // Variável que será usada para armazenar a temperatura em graus
// Descomentar se estiver usando o LM335
//float temperaturaK;
void setup() {
pinMode(sensorPin, INPUT); // Declare o tipo de pino que está conectado na placa
Serial.begin(9600); // Inicialize a comunicação serial em 9600 bits por segundo
}
void loop() {
// Insira seu código principal aqui, para rodar repetidamente:
valorSensor = analogRead(sensorPin); // Leia o sensor analógico e armazene seu valor
tensaoSaida = (valorSensor * 5000) / 1024; //Cálculo para obter a tensão de saída do sensor
// Calculando a temperatura para o LM35
temperaturaC = tensaoSaida / 10; // Convertendo a tensão em graus Celsius
temperaturaF = (temperaturaC * 1.8) + 32; // Convertendo para graus Fahrenheit
// Calculando a temperatura para o LM335
//temperaturaK = tensaoSaida / 10;
//temperaturaC = temperaturaK - 273;
//temperaturaF = (temperaturaC * 1.8) + 32;
// Calculando a temperatura para o LM34
//temperaturaF = tensaoSaida / 10;
//temperaturaC = (temperaturaF - 32.0)*(5.0/9.0);
Serial.print("Temperatura(ºC): "); // Printando em graus Celsius
Serial.print(temperaturaC);
Serial.print(" Temperatura(ºF): "); // Printando em graus Fahrenheit
Serial.print(temperaturaF);
Serial.print(" Tensão(mV): "); // Printando a tensão em miliVolts
Serial.println(tensaoSaida);
delay(1000); // Uma pequena pausa para não exibir dados errôneos
}
Explicação do código utilizado:
AS VARIÁVEIS DO CÓDIGO
const int sensorPin = A0;
Primeiramente, comece identificando a porta analógica que o sensor está conectado no Arduino.
float valorSensor; float tensaoSaida;
Depois, crie 2 variáveis para ler o sensor e outra para converter a tensão do sensor futuramente.
float temperaturaC; float temperaturaF;
Declare mais 2 variáveis do tipo flutuante para armazenarem os valores de temperatura em °C e °F.
CONFIGURANDO O SENSOR E O MONITOR SERIAL
pinMode(sensorPin, INPUT); Serial.begin(9600);
Escreva no void setup () que o sensor é um componente INPUT e inicialize a comunicação serial à 9600 bits por segundo (bps) de forma a exibir as leituras no monitor serial.
CONFIGURANDO A FUNÇÃO NATIVA LOOP ()
valorSensor = analogRead(sensorPin);
No void loop (), leia o valor saindo do sensor e armazene-o na variável valorSensor. Para ler o sensor basta usar a função analogRead () e inserir o pino do sensor como argumento da função.
LEITURA DO SENSOR
tensaoSaida = (valorSensor * 5000) / 1024;
Como foi mencionado anteriormente, esses sensores possuem uma tensão proporcional à temperatura.
Já, os valores lidos no Arduino podem variar de 0 a 1023, no qual 0 condiz com 0 Volts e 1023 com 5 Volts. Portanto, podemos facilmente transformar a tensão de saída em mV de acordo com o algoritmo acima.
CONVERSÃO DA TENSÃO EM °C
temperaturaC = tensaoSaida / 10;
Vimos também que a cada 10 mV corresponde a um aumento no valor da temperatura. Sendo assim, use a conversão acima para obter os valores de mV para °C.
CONVERTA PARA A ESCALA FAHRENHEIT
temperaturaF = (temperaturaC * 1.8) + 32;
Já para obter essa medida em °F, basta usar a conversão dada acima.
PS: Lembrando que, caso você estiver usando os outros 2 sensores ao invés do LM35, basta descomentar as linhas do código e lembrar que o LM34 retorna a temperatura em °F e o LM335 em K.
IMPRIMA OS VALORES NO MONITOR SERIAL
Serial.print("Temperatura(ºC): ");
Serial.print(temperaturaC);
Serial.print(" Temperatura(ºF): ");
Serial.print(temperaturaF);
Por último, você deve imprimir as leituras realizadas no monitor serial, utilizando os comandos abaixo:
Serial.print(" Tensão(mV): ");
Serial.println(tensaoSaida);
E, também não se esqueça de exibir os valores de tensão do sensor para verificar se está tudo funcionando ok.
INSIRA UM DELAY
delay(1000);
Forneça uma pausa de 1 segundo durante a execução do código para que o Arduino não faça leituras errôneas.
Família TMP 36/35/37
Esse sensor TMP36 se parece muito com a família dos sensores LM.
Mas, não se deixe enganar em pensar que por serem parecidos eles possuem as mesmas características técnicas.
A diferença entre eles começa na acurácia.
Enquanto os sensores TMP35, TMP36 e TMP37 possuem precisão de ± 2 °C os sensores LM chegam a ±0.5°C.
Pois bem!
Além disso, ao analisar o datasheet separado de cada um, você consegue notar que o range da família LM é de -55°C à 150°C enquanto que a faixa ideal dos sensores TMP é de -40°C à 125°C.
Já as principais funcionalidades dos sensores TMP 36/35/37, se destacam as seguintes:
- Possuem uma tensão de baixa operação (2.7V até 5.5V);
- Trabalham na faixa de -40°C até 125°C e operam até no máximo 150°C;
- Não esquentam tão facilmente;
- São estáveis a grandes cargas capacitivas aplicadas;
- Não precisam de calibração para funcionar e são componentes que já fornecem valores na escala Celsius;
- São qualificados para serem utilizados em automóveis.
Caso deseje se certificar de todas as especificações técnicas da família, acesse o datasheet do TMP36 aqui.
Para se ter uma ideia, encontramos aplicações desses sensores de temperatura:
- no controle de sistemas ambientais;
- na proteção contra superaquecimento de computadores;
- no controle de processos industriais, e;
- entre muitos outros.
Agora, a diferença entre os sensores TMP 36/35/37 você encontra melhor detalhado na tabela abaixo.
Veja só:
| Especificações | TMP35 | TMP36 | TMP37 |
| Temperatura de trabalho | 10°C até 125°C | -40°C até 125°C | 5°C até 100°C |
| Linearidade | 10 mV/°F | 10 mV/K | 20 mV/°C |
| Tensão de saída a 25°C | 250 mV | 750 mV | 500 mV |
Algumas características são comuns para os 3 componentes, tais como:
- Utilizam o mesmo protocolo de comunicação: interface analogRead() com o Arduino;
- Possuem a mesma faixa de alimentação: 2.7V até 5.5V;
- Possuem precisão de +/- 1°C em 25°C e precisão de +/- 2°C entre -40°C e e 150°C.
Pinagem do sensor de temperatura TMP36
– Esse é o pino positivo, portanto conecte-o ao +5V do Arduino;
– Conecte este no pino analógico A0 do Arduino;
– E, o GND você já sabe, né? Vai conectado no negativo (GND) do Arduino!
Montagem do sensor de temperatura Arduino e TMP36
A montagem proposta para este projeto usando o sensor TMP36 está representada abaixo:
Da montagem do LM35 o que muda aqui é apenas o componente TMP36 pois, o restante permanece intacto: mesma polaridade de alimentação e mesmo pino analógico para coleta de dados.
Código utilizado no projeto
O código utilizado para programar o Arduino e o TMP36 é bastante similar com o usado para o LM35.
Então, olhe só:
/* Código do projeto sensor de temperatura Família TMP
Monte seus próprios projetos sem dificuldade com programação!
ACESSE: https://flaviobabos.com.br/
*/
const int sensorPin = A0; // Esse é o pino do Arduino que irá ler a saída do sensor
float valorSensor; // Essa variável irá ser usada para armazenar o input do sensor
float temperaturaC, temperaturaF; // Variável que será usada para armazenar a temperatura em graus
void setup() {
pinMode(sensorPin, INPUT); // Declare o tipo de pino que está conectado na placa
Serial.begin(9600); // Inicialize a comunicação serial em 9600 bits por segundo
}
void loop() {
// Insira seu código principal aqui, para rodar repetidamente:
valorSensor = analogRead(sensorPin); // Leia o sensor analógico e armazene seu valor
temperaturaC = valorSensor / 1024; // Encontrando a porcentagem da leitura de input
temperaturaC = temperaturaC * 5; // Multiplique por 5V para obter a tensão
temperaturaC = temperaturaC - 0.5; // Subtraia o deslocamento
temperaturaC = temperaturaC * 100; // Converta em graus Celsius
temperaturaF = (temperaturaC * 1.8) + 32; // Converta para graus Fahrenheit
Serial.print("Temperatura atual (°C): "); // Printando em graus Celsius
Serial.println(temperaturaC);
Serial.print("Temperatura atual (°F): "); // Printando em graus Fahrenheit
Serial.println(temperaturaF);
delay(1000); // Uma pequena pausa para não exibir dados errôneos
}
Sensor de temperatura DS18B20
Dando sequência nos sensores de temperatura, temos no mercado um bastante preciso: o DS18B20.
Este é um sensor digital de temperatura que se apresenta em duas formas, o modelo em encapsulamento TO92 (modelo mais comum que também se assemelha a um transistor) e o modelo a prova d’água do sensor de temperatura Arduino DS18B20:
Algumas características desse sensor DS18B20 são:
- Escala graduada em graus Celsius;
- Mede entre -55°C até 125°C;
- Possui precisão de 0,5°C entre -10°C e 85°C;
- Alimentação: 3V a 5,5V;
- Consumo de energia: 1,5mA;
- ID Único de 64 bits;
- Protocolo One Wire.
Se interessou? Então acesse o datasheet do sensor DS18B20 aqui.
O protocolo One Wire nos permite que a comunicação com o Arduino seja feita com diversos sensores através de apenas uma porta digital.
Veja este tutorial de uso com 3 sensores DS18B20 utilizando uma mesma porta digital do Arduino.
Além disso, você pode definir através do protocolo, uma temperatura de alarme com temperaturas mínimas e máximas definidas no seu micro-controlador.
Por exemplo, quando a temperatura ultrapassar um determinado valor programado pelo usuário, um LED, um buzzer ou qualquer outro componente pode ser configurado para ser acionado para alertar o usuário.
Pinagem do sensor de temperatura DS18B20
– Ligue este pino no negativo do seu Arduino;
– Já este, conecte-o na porta digital 8 e após, insira um resistor pull-up de 4,7kOHMS e ligue-o no VCC;
– Espete este pino no +5Volts do microcontrolador.
Montagem do sensor de temperatura Arduino e DS18B20
Segue a montagem dos componentes do projeto usando o sensor de temperatura Arduino DS18B20:
Neste projeto, é necessário que utilizemos um resistor de pull-up de 4,7KOhms para manter a transferência de dados de forma estável.
PS: Observe que este sensor possui polaridade inversa aos sensores LM35 e TMP36, portanto, siga a montagem as conexões como mostradas na imagem acima para não queimar o componente.
Agora, caso você possuir o sensor DS18B20 a prova d’água, a montagem fica da seguinte forma:
Com tudo montado na protoboard, vamos partir para a programação do sistema.
Código utilizado no projeto
Utilize o código abaixo para programar o seu sensor de temperatura Arduino:
/* Código do projeto sensor de temperatura DS18B20
Monte seus próprios projetos sem dificuldade com programação!
ACESSE: https://flaviobabos.com.br/
*/
#include <OneWire.h>
#include <DallasTemperature.h>
// Porta do pino de sinal do DS18B20
#define ONE_WIRE_BUS 8
// Define uma instancia do oneWire para comunicacao com o sensor
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
// Armazena temperaturas minima e maxima
float tempMin = 999;
float tempMax = 0;
DeviceAddress sensor1;
void setup()
{
Serial.begin(9600);
sensors.begin();
// Localiza e mostra enderecos dos sensores
Serial.println("Localizando sensores DS18B20...");
Serial.print("Foram encontrados ");
Serial.print(sensors.getDeviceCount(), DEC);
Serial.println(" sensores.");
if (!sensors.getAddress(sensor1, 0))
Serial.println("Sensores nao encontrados !");
// Mostra o endereco do sensor encontrado no barramento
Serial.print("Endereco sensor: ");
mostra_endereco_sensor(sensor1);
Serial.println();
Serial.println();
}
void mostra_endereco_sensor(DeviceAddress deviceAddress)
{
for (uint8_t i = 0; i < 8; i++)
{
// Adiciona zeros se necessário
if (deviceAddress[i] < 16) Serial.print("0");
Serial.print(deviceAddress[i], HEX);
}
}
void loop()
{
// Le a informacao do sensor
sensors.requestTemperatures();
float tempC = sensors.getTempC(sensor1);
// Atualiza temperaturas minima e maxima
if (tempC < tempMin)
{
tempMin = tempC;
}
if (tempC > tempMax)
{
tempMax = tempC;
}
// Mostra dados no serial monitor
Serial.print("Temp C: ");
Serial.print(tempC);
Serial.print(" Min : ");
Serial.print(tempMin);
Serial.print(" Max : ");
Serial.println(tempMax);
delay(3000);
}
Após entender o código e ter ele pronto na sua IDE, você deve baixar as seguintes bibliotecas:
- One Wire, e;
- Dallas Temperature.
Siga o passo-a-passo para download:
Explicação do código utilizado:
AS BIBLIOTECAS DO CÓDIGO
#include <OneWire.h> #include <DallasTemperature.h>
O código precisa começar incluindo as bibliotecas DallasTemperature.h e OneWire.h pois caso contrário seu código não irá funcionar. Além disso, devemos declarar qual pino o seu sensor está conectado (pino digital 8 do Arduino):
CRIE UM OBJETO PARA CONTROLAR O DS18B20
// Porta do pino de sinal do DS18B20 #define ONE_WIRE_BUS 8
Na próxima linha, é preciso criar um objeto One Wire pois assim, nos dará permissão do controle do nosso componente.
CRIE UMA INSTÂNCIA DO ONEWIRE E DEFINA UM OBJETO DA BIBLIOTECA DALLAS TEMPERATURE
// Defina uma instancia do oneWire para comunicacao com o sensor OneWire oneWire(ONE_WIRE_BUS); DallasTemperature sensors(&oneWire);
Após isso, também criamos um objeto da biblioteca Dallas Temperature para passar a referência do objeto One Wire como parâmetro.
INTERAJA COM O SENSOR ATRAVÉS DE COMANDOS BÁSICOS
Por fim, após a criação do objeto DallasTemperature, podemos criar comandos simples, como o exemplo abaixo, para interagir com o sensor.
Se liga:
begin()
A função procura sensores conectados no barramento e define a resolução de bits (12 bits) para cada um.
requestTemperatures()
Função que envia o comando para todos os sensores no barramento para realizar uma conversão de temperatura.
getTempCByIndex(deviceIndex)
Essa função lê e retorna a leitura de temperatura do sensor. O argumento deviceIndex nada mais é que a localização do sensor no barramento.
Se você estiver usando apenas um DS18B20 no barramento, defina-o como 0.
Análise final dos sensores de temperatura
Comparação entre o TMP36, LM35 e DS18B20
Com tantas informações sobre esses sensores, fica um pouco complicado filtrar qual o melhor para se usar, não concorda comigo?
Mas, digo o seguinte, caso seu projeto não requerer muita precisão e não necessitar de um range amplo de medição, eu recomendo o TMP36 para facilitar na aplicação.
No entanto, se seu projeto for algo como um sensor interno conectado a um Arduino que não irá coletar temperaturas negativas, então provavelmente eu ficaria com a precisão extra do LM35, já que a tensão de alimentação e a saída negativa não seria uma preocupação.
Para facilitar na escolha veja as tabelas abaixo.
Tabela de comparação do TMP36:
| Pros | Contras |
|---|---|
| Faixa de tensão operacional de 2,7 V a 5,5 V perfeita para projetos de fabricantes | Precisão menor do que LM35 |
| Toda a faixa de temperatura suportada representada como saída de tensão positiva | Faixa de temperatura ligeiramente menor |
Tabela de comparação do LM35:
| Pros | Contras |
|---|---|
| Precisão de ±0,5 ° C | A tensão de alimentação mínima de 4 V proibe a integração fácil de 3,3 V |
| Excelente faixa de temperatura | Requer saída negativa para temperaturas negativas |
Já o DS18B20 é utilizado em uma situação/ambiente mais específico do que os outros sensores, ou seja, onde é preciso medir a temperatura de um líquido ou de outra coisa no qual o sensor precisa estar bem protegido e bem vedado.
Com relação aos preços dos sensores, não há muita variação.
Após fazer uma breve pesquisa do mercado e dependendo da época, você deve encontrar o seguinte (vendedores da China):
| Sensores | Preço |
|---|---|
| LM35 | R$ 7,95 |
| TMP36 | R$ 7,34 |
| DS18B20 | R$ 7,84 |
| DS18B20 (a prova d’água) | R$ 9,59 |
E aí, com qual sensor de temperatura Arduino você mais se identificou? Comente aqui embaixo e me deixe saber 👇
