Sensor de temperatura: LM35 | TMP36 | DS18B20 (Completo)

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 👇