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ê:
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.
Como Usar Seu Projeto com Arduino para Crescer no Instagram
Projetos como o desenvolvimento de um sensor de temperatura com Arduino não são apenas uma oportunidade de aprendizado, mas também uma chance de compartilhar seu conhecimento e criatividade com uma audiência maior.
Muitos entusiastas de tecnologia adoram ver projetos DIY (faça você mesmo) e experimentos inovadores, e plataformas como o Instagram são perfeitas para divulgar suas criações.
Ao compartilhar o passo a passo do seu projeto de sensor de temperatura, você não só educa outros interessados no assunto, mas também posiciona seu perfil como uma referência em tecnologia. Isso pode atrair seguidores que compartilham da mesma paixão por Arduino e projetos eletrônicos, aumentando seu alcance e engajamento na plataforma.
Dica: Invista na compra de seguidores reais e brasileiros para dar um impulso inicial ao seu perfil. Com uma base sólida, seus conteúdos técnicos têm mais chances de se espalhar e alcançar um público que realmente valoriza suas contribuições. A combinação de conteúdo de qualidade e uma estratégia eficaz de crescimento pode transformar seu perfil em uma verdadeira comunidade de entusiastas por tecnologia.
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 👇
