Sensor de Temperatura DS18B20: Manual Técnico Completo

Introdução

Neste tutorial, será apresentado como instalar, configurar e utilizar o sensor de temperatura digital DS18B20. Se desejar adquirir este sensor, clique aqui.

Descrição geral do produto

O que é o DS18B20?

O DS18B20 é um sensor de temperatura digital fabricado pela Maxim Integrated (família Dallas). Diferente de sensores analógicos como o LM35 e o NTC, ele converte a temperatura diretamente em um sinal digital, eliminando a necessidade de conversores ADC externos e de calibração manual — a calibração é feita de fábrica, com precisão de ±0,5°C entre −10°C e +85°C.

É um dos sensores mais usados em projetos de automação, aquário, estufas, câmaras frias, fermentadoras e monitoramento IoT por três motivos: comunicação por um único fio, endereço único por sensor e robustez das versões com ponteira em aço inox.

Para que serve?

O DS18B20 mede a temperatura ambiente ou do meio onde está instalado e entrega o valor já digitalizado ao microcontrolador. É aplicado em projetos como:

• Monitoramento de temperatura em aquários, fermentadoras, estufas e câmaras frias;
• Proteção contra superaquecimento (motores, fontes, impressoras 3D);
• Registro contínuo da temperatura (datalogger) e monitoramento remoto (IoT).

Por que devo usar?

• Fiação mínima: comunicação por um único fio (1-Wire), com vários sensores no mesmo barramento graças ao endereço ROM único de 64 bits;
• Precisão sem calibração: ±0,5°C na faixa de −10°C a +85°C, com versão à prova d’água em aço inox (RB0005);
• Compatibilidade ampla: Arduino, ESP32, ESP8266, Raspberry Pi, bibliotecas gratuitas e custo acessível.

Quando devo usar?

O DS18B20 é indicado quando:

• São necessárias várias medições em pontos diferentes com uma única fiação;
• A medição ocorre em líquidos ou ambientes úmidos, com cabo longo ou ambiente agressivo;
• É exigida precisão de até ±0,5°C com implementação simples e custo baixo.

Não é a melhor escolha quando:

• A temperatura varia rapidamente — o tempo de conversão máximo é de 750 ms;
• Também é necessária a medição de umidade (preferir DHT11/DHT22);
• Basta uma leitura analógica barata, sem grande precisão (LM35).

Como funciona o protocolo 1-Wire

O DS18B20 utiliza o protocolo 1-Wire da Dallas Semiconductor: dados, endereçamento e controle trafegam por um único fio de dados (DQ) — além dele, apenas terra e alimentação (que pode até ser dispensada no modo parasita).

• Endereço único de 64 bits (ROM): cada sensor nasce com um código gravado em fábrica. O endereço contém a família (0x28), o número de série e um byte de checagem CRC.
• Múltiplos sensores no mesmo barramento: como cada sensor tem endereço único, dezenas de sensores podem compartilhar o mesmo fio de dados — o programa pergunta “quem está aí?” e lê cada um pelo seu endereço.
• Busca ROM: o microcontrolador usa o algoritmo de busca ROM para enumerar todos os sensores conectados, sem precisar saber seus endereços de antemão.

💡 Dica: o endereço ROM permite que sensores “flutuem” no barramento — se você remove um deles e religa, o programa continua funcionando com os que permaneceram.

Variantes disponíveis

O DS18B20 é vendido em três versões básicas, todas com o mesmo chip e o mesmo funcionamento:

• TO-92: componente avulso de 3 pinos (GND, DQ, VDD), para soldar em placa ou protoboard. Uso em ambientes secos e internos.
• Módulo para Arduino (RB2078): o sensor TO-92 já montado em uma placa pronta de 32×12 mm, com terminais para ligação direta em protoboard — ideal para quem quer começar o projeto sem solda.
• Sonda à prova d’água (RB0005): sensor encapsulado em ponteira de aço inoxidável (6×50 mm) com cabo de 100 cm (também disponível em cabo de 5 metros). Uso em líquidos, ambientes úmidos e externos.

Especificações técnicas

Principais especificações

Parâmetro	Valor
Tensão de operação (VDD)	3,0 – 5,5 VDC
Faixa de medição	−55°C a +125°C
Precisão (−10°C a +85°C)	±0,5°C
Resolução	9 a 12 bits (configurável)
Comunicação	1-Wire (1 fio de dados)
Endereço único	64 bits (ROM, com CRC)
Corrente de operação	1,5 mA (máx.)
Corrente em standby	1 µA (máx.)
Tempo de conversão (12 bits)	750 ms (máx.)
Temperatura de armazenamento	−55°C a +125°C

Faixa de temperatura e precisão

Condição	Valor
Faixa de medição completa	−55°C a +125°C
Precisão entre −10°C e +85°C	±0,5°C
Precisão fora dessa faixa	até ±2°C (ver datasheet)

⚠️ ATENÇÃO: a faixa de medição do chip vai até +125°C, mas na versão sonda o cabo de PVC limita o uso recomendado a +100°C — acima disso o isolamento pode degradar.

Resoluções programáveis

Resolução	Incremento	Tempo de conversão
9 bits	0,5°C	93,75 ms
10 bits	0,25°C	187,5 ms
11 bits	0,125°C	375 ms
12 bits (padrão)	0,0625°C	750 ms

💡 Dica: precisão e resolução são coisas diferentes. Para a maioria das aplicações, 11 bits (0,125°C) é o melhor equilíbrio entre velocidade e refinamento — o padrão de 12 bits só faz sentido quando o tempo de conversão não importa.

Pinagem e descrição dos terminais

Encapsulamento TO-92 (face plana, esquerda → direita)

Pino	Nome	Função	Cabo (sonda)
1	GND	Terra (0V)	Preto
2	DQ	Dados 1-Wire (bidirecional)	Amarelo / Branco
3	VDD	Alimentação (3,0 – 5,5V)	Vermelho

⚠️ OBRIGATÓRIO: instalar resistor de pull-up de 4,7 kΩ entre o pino DQ e VDD. A ausência causa leitura −127°C ou falha de comunicação.

⛔ ATENÇÃO: a inversão dos pinos GND e VDD causa dano permanente ao sensor. Sempre verifique a pinagem antes de energizar o circuito.

Por que o pull-up é obrigatório

O barramento 1-Wire é do tipo “coletor aberto”: o sensor só puxa o fio para baixo (0V). É o resistor de pull-up que mantém o fio em nível alto (3,3V/5V) quando o barramento está em repouso. Sem ele, o barramento “flutua”, o que causa leituras de −127°C ou sensores que aparecem e desaparecem.

Regra prática:

• 1 sensore e cabos curtos: 4,7 kΩ (padrão do datasheet).
• Cabos longos ou muitos sensores: reduza para 2,2 kΩ.
• O pull-up interno do ESP32 (~45 kΩ) e do Arduino (~30 kΩ) não é suficiente — o resistor externo é sempre necessário.

Instalação e conexão

Requisitos de hardware

• Microcontrolador: Arduino Uno/Mega/Nano, ESP32, ESP8266 ou similar (ou Raspberry Pi)
• Resistor de pull-up: 4,7 kΩ (obrigatório)
• Protoboard e jumpers (para o sensor TO-92 ou módulo)
• Fonte de alimentação: 3,3V ou 5V DC

Passo a passo da instalação

1. Desligue o circuito antes de qualquer conexão.
2. Conecte o VDD (vermelho) ao pino de alimentação do microcontrolador (5V no Arduino, 3,3V no ESP32/ESP8266).
3. Conecte o GND (preto) ao terra (GND).
4. Conecte o DQ (amarelo/branco) ao pino de dados escolhido.
5. Instale o resistor de 4,7 kΩ entre o fio de dados (DQ) e o VDD.
6. Energize o circuito e abra o Monitor Serial (baud em 9600) para confirmar a leitura.
7. Se a leitura retornar −127°C, a comunicação falhou: revise o pull-up e as conexões.

Conexão com microcontroladores

DS18B20	Arduino Uno	ESP32	ESP8266
VDD (Vermelho)	5V	3.3V	3.3V
GND (Preto)	GND	GND	GND
DQ (Amarelo)	D2 + pull-up 4k7	GPIO4 + pull-up 4k7	GPIO2 + pull-up 4k7

💡 ESP8266: o GPIO2 é usado apenas para dados. Não conecte o sensor nesse pino antes de o programa começar a rodar — o pino precisa estar em nível alto no boot. Se preferir, use o D4 (GPIO2) depois de gravar o firmware.

Alimentação normal vs. modo parasita

Existem duas formas de alimentar o DS18B20:

• Alimentação normal (3 fios, recomendado): VDD recebe 3,3V/5V e o sensor funciona na potência total. Use sempre que puder.
• Modo parasita (2 fios): o sensor “rouba” energia do próprio fio de dados através do pull-up. Economiza um fio, mas tem restrições: limite de +100°C, cabos curtos (máx. ~1,5 m) e não recomendado com múltiplos sensores no mesmo barramento.

Conclusão prática: prefira sempre a alimentação normal. O modo parasita só compensa em projetos muito simples, de fiação mínima e temperatura moderada.

Múltiplos sensores no mesmo barramento

Conecte vários DS18B20 em paralelo no mesmo pino de dados: todos os VDD juntos, todos os GND juntos e todos os DQ juntos, com apenas um resistor de pull-up para o barramento inteiro. O software identifica cada sensor pelo ID ROM único de 64 bits.

Limites práticos:

• Teoricamente são 2^64 endereços possíveis — na prática o limite vem da capacitância do cabo e do tempo de conversão.
• Com cabos curtos e alimentação normal, 10 a 20 sensores funcionam sem problemas com 4,7 kΩ.
• Para muitos sensores ou cabos longos, reduza o pull-up para 2,2 kΩ ou divida o barramento em grupos.

Configuração de software

Bibliotecas necessárias

• OneWire by Paul Stoffregen — gerencia o protocolo 1-Wire
• DallasTemperature by Miles Burton — leitura simplificada

Instalar via: Arduino IDE → Sketch → Incluir Biblioteca → Gerenciar Bibliotecas — busque por “DallasTemperature” e “OneWire” e pressione Instalar nas duas.

Código básico de leitura

#include <OneWire.h>                // biblioteca do protocolo 1-Wire
#include <DallasTemperature.h>      // biblioteca de leitura do sensor

#define PINO_DADOS 2                // pino digital onde o DQ está ligado

OneWire oneWire(PINO_DADOS);        // cria objeto do barramento 1-Wire
DallasTemperature sensors(&oneWire); // cria objeto do sensor usando o barramento

void setup() {
  Serial.begin(9600);               // inicia comunicação serial
  sensors.begin();                  // inicializa o sensor
}

void loop() {
  sensors.requestTemperatures();    // solicita a conversão de temperatura
  float temp = sensors.getTempCByIndex(0); // lê a temperatura do 1º sensor em °C
  Serial.print("Temperatura: ");    // imprime texto no Monitor Serial
  Serial.print(temp);               // imprime o valor da temperatura
  Serial.println(" C");             // imprime a unidade e pula linha
  delay(1000);                      // aguarda 1 segundo antes da próxima leitura
}

Configurar resolução

sensors.setResolution(12); // define a resolução: 9, 10, 11 ou 12 bits

💡 Você pode definir a resolução por sensor (pelo endereço ROM) ou para todos de uma vez — consulte setResolution(DeviceAddress, uint8_t).

Lendo múltiplos sensores

O exemplo a seguir enumera todos os sensores do barramento, imprime os endereços ROM e lê cada um individualmente:

#include <OneWire.h>                // biblioteca do protocolo 1-Wire
#include <DallasTemperature.h>      // biblioteca de leitura do sensor

#define PINO_DADOS 2                // pino digital onde o DQ está ligado

OneWire oneWire(PINO_DADOS);        // cria objeto do barramento 1-Wire
DallasTemperature sensors(&oneWire); // cria objeto do sensor usando o barramento
DeviceAddress endereco;             // variável para guardar o endereço ROM

void imprimirEndereco(DeviceAddress addr) {  // função que imprime o endereço em hexadecimal
  for (uint8_t i = 0; i < 8; i++) {          // percorre os 8 bytes do endereço
    if (addr[i] < 16) Serial.print("0");     // adiciona 0 à esquerda se for menor que 16
    Serial.print(addr[i], HEX);              // imprime o byte em hexadecimal
  }
}

void setup() {
  Serial.begin(9600);               // inicia comunicação serial
  sensors.begin();                  // inicializa o sensor
  Serial.print("Sensores encontrados: ");  // informa quantos sensores há no barramento
  Serial.println(sensors.getDeviceCount()); // imprime a quantidade de sensores

  for (uint8_t i = 0; i < sensors.getDeviceCount(); i++) {  // percorre todos os sensores
    if (sensors.getAddress(endereco, i)) {   // obtém o endereço do sensor i
      Serial.print("Endereco do sensor ");   // imprime o rótulo
      Serial.print(i);                       // imprime o índice do sensor
      Serial.print(": ");                    // separador
      imprimirEndereco(endereco);            // imprime o endereço em hex
      Serial.println();                      // pula linha
    }
  }
  sensors.setResolution(12);        // define a resolução de 12 bits para todos
}

void loop() {
  sensors.requestTemperatures();    // solicita a conversão de temperatura de todos
  for (uint8_t i = 0; i < sensors.getDeviceCount(); i++) {  // percorre todos os sensores
    Serial.print("Sensor ");        // imprime o rótulo
    Serial.print(i);                // imprime o índice do sensor
    Serial.print(": ");             // separador
    Serial.print(sensors.getTempCByIndex(i));  // imprime a temperatura do sensor i
    Serial.println(" C");           // imprime a unidade e pula linha
  }
  delay(2000);                      // aguarda 2 segundos entre leituras
}

Integração com Raspberry Pi

O kernel Linux tem suporte nativo a 1-Wire — basta habilitar a interface e ler os sensores como arquivos:

# Ative a interface 1-Wire (GPIO4, o físico pino 7 na rasp):
sudo raspi-config   # Interface Options > 1-Wire

# Depois de reiniciar, veja os sensores detectados:
ls /sys/bus/w1/devices/          # lista os sensores encontrados
# Ex.: 28-00000a1b2c3d (28- = família DS18B20)

# Leitura bruta (t=23500 significa 23,5°C):
cat /sys/bus/w1/devices/28-00000a1b2c3d/w1_slave   # exibe a linha com o valor medido

Use o mesmo pull-up de 4,7 kΩ entre DQ e VDD (3,3V da Raspberry Pi). Em Python, a leitura fica simples:

import glob, time                 # bibliotecas para buscar arquivos e pausar

for device in glob.glob("/sys/bus/w1/devices/28-*"):   # percorre cada sensor DS18B20
    with open(device + "/w1_slave") as f:               # abre o arquivo de leitura do sensor
        linhas = f.read().splitlines()                 # lê e separa as linhas do arquivo
        if linhas[0].endswith("YES"):                  # verifica se a leitura é válida
            temp = float(linhas[1].split("=")[1]) / 1000  # extrai o valor e converte para °C
            print(f"{temp:.2f} °C")                    # imprime a temperatura com 2 casas

Exemplos de aplicação

• Termômetro com display LCD 16x2 (I2C): exiba a temperatura em tempo real com a biblioteca LiquidCrystal_I2C — basta imprimir o valor de getTempCByIndex(0) no display.
• Termostato com relé: acione um relé automaticamente ao atingir o setpoint configurado, com histerese para evitar religar/desligar o tempo todo.
• Monitoramento IoT — ESP32 + MQTT: envie leituras a um broker MQTT e consuma com dashboards (Node-RED, Grafana, Home Assistant).
• Datalogger com cartão SD: registre leituras em intervalos para análise histórica em estufas, câmaras frias, fermentadoras ou laboratórios.

Termostato com relé (Arduino)

#include <OneWire.h>                // biblioteca do protocolo 1-Wire
#include <DallasTemperature.h>      // biblioteca de leitura do sensor

#define PINO_DADOS 2                // pino digital onde o DQ está ligado
#define PINO_RELE  8                // pino do relé
#define SETPOINT   25.0             // temperatura-alvo em °C
#define HISTERESE  1.0              // faixa de tolerância em °C

OneWire oneWire(PINO_DADOS);        // cria objeto do barramento 1-Wire
DallasTemperature sensors(&oneWire); // cria objeto do sensor usando o barramento

void setup() {
  pinMode(PINO_RELE, OUTPUT);       // define o pino do relé como saída
  digitalWrite(PINO_RELE, LOW);     // relé desligado ao iniciar
  sensors.begin();                  // inicializa o sensor
}

void loop() {
  sensors.requestTemperatures();    // solicita a conversão de temperatura
  float temp = sensors.getTempCByIndex(0);  // lê a temperatura do 1º sensor em °C

  if (temp <= SETPOINT - HISTERESE) digitalWrite(PINO_RELE, HIGH);  // frio demais: liga o relé
  if (temp >= SETPOINT + HISTERESE) digitalWrite(PINO_RELE, LOW);   // quente demais: desliga o relé

  delay(1000);                      // aguarda 1 segundo entre medições
}

💡 A histerese de ±1°C evita que o relé “batata” (ligue e desligue rapidamente) quando a temperatura fica oscilando no limite. Ajuste SETPOINT e HISTERESE conforme a aplicação.

Monitoramento IoT com ESP32 + MQTT

#include <WiFi.h>                  // biblioteca de conexão WiFi do ESP32
#include <PubSubClient.h>          // biblioteca do protocolo MQTT
#include <OneWire.h>               // biblioteca do protocolo 1-Wire
#include <DallasTemperature.h>     // biblioteca de leitura do sensor

#define PINO_DADOS 4               // pino onde o DQ está ligado

const char* ssid  = "SEU_WIFI";    // nome da rede WiFi
const char* senha = "SUA_SENHA";   // senha da rede WiFi
const char* broker = "IP_DO_SEU_BROKER";  // endereço do broker MQTT

WiFiClient wifiCliente;            // cliente TCP para a conexão WiFi
PubSubClient mqtt(wifiCliente);    // cliente MQTT sobre o WiFi
OneWire oneWire(PINO_DADOS);       // cria objeto do barramento 1-Wire
DallasTemperature sensors(&oneWire); // cria objeto do sensor usando o barramento

void setup() {
  Serial.begin(115200);            // inicia comunicação serial
  sensors.begin();                 // inicializa o sensor
  WiFi.begin(ssid, senha);         // inicia a conexão WiFi
  while (WiFi.status() != WL_CONNECTED) {  // aguarda conectar à rede
    delay(500);                    // espera meio segundo
    Serial.print(".");             // imprime ponto de progresso
  }
  Serial.println("WiFi conectado");  // confirma a conexão
  mqtt.setServer(broker, 1883);    // define o broker e a porta padrão
}

void loop() {
  if (!mqtt.connected()) mqtt.connect("esp32-ds18b20-01");  // reconecta se cair
  mqtt.loop();                     // mantém o cliente MQTT ativo

  sensors.requestTemperatures();   // solicita a conversão de temperatura
  float temp = sensors.getTempCByIndex(0);  // lê a temperatura em °C
  mqtt.publish("robobuilders/ds18b20/temperatura", String(temp).c_str());  // publica no tópico

  delay(10000);  // 1 leitura a cada 10 segundos
}

💡 Na RoboBuilders você encontra módulos DS18B20 e placas ESP32 prontas para projetos de monitoramento remoto. Para dashboards, combine o broker MQTT com Node-RED ou Home Assistant.

Conclusão

Este manual abordou de forma completa o sensor de temperatura digital DS18B20, desde os conceitos básicos até aplicações avançadas:

• O que é e como funciona: sensor digital com protocolo 1-Wire, endereço único de 64 bits, precisão de ±0,5°C sem necessidade de calibração.
• Variantes disponíveis: componente TO-92 avulso, módulo pronto para Arduino (RB2078, 32×12 mm) e sonda à prova d’água em aço inox (RB0005, cabo de 1 m ou 5 m).
• Pinagem e instalação: esquemas de ligação para Arduino, ESP32 e ESP8266, explicação do resistor pull-up de 4,7 kΩ e modo parasita.
• Configuração de software: instalação das bibliotecas OneWire e DallasTemperature, leitura básica, ajuste de resolução (9 a 12 bits) e endereçamento de múltiplos sensores pelo ROM.
• Exemplos práticos: código para múltiplos sensores, termostato com relé e histerese, monitoramento IoT com ESP32 + MQTT, e integração com Raspberry Pi (Shell e Python).
• Solução de problemas (FAQ): diagnóstico das leituras −127°C, 85°C, instabilidade, sensores não identificados, CRC, fantasmas e limites de quantidade no barramento.

Com o resistor de pull-up adequado, alimentação estável e as bibliotecas OneWire + DallasTemperature, o DS18B20 entrega leituras confiáveis — de um termômetro simples a redes IoT com dezenas de sensores no mesmo fio.

Solução de problemas

Olá! Sou o assistente técnico da RoboBuilders. Descreva seu problema com o Sensor de Temperatura DS18B20: Manual Técnico Completo e eu ajudarei a encontrar a solução.

Enviar

O assistente usa IA e pode errar. Confirme informações críticas no datasheet oficial do fabricante.