Sensor de temperatura DS18B20 com Arduino, ESP32 e Pico

O DS18B20 é um sensor de temperatura digital e uma das formas mais precisas e flexíveis de medir temperatura com Arduino. Ele mede de −55 °C a +125 °C, tem precisão de ±0,5 °C entre −10 °C e +85 °C e envia o resultado como um número digital, não como uma tensão analógica, então a leitura não se degrada nem em cabos longos. O maior trunfo dele é a comunicação 1-Wire: você pode ligar dezenas de DS18B20 em um único pino de dados e ler cada um separadamente pelo seu endereço exclusivo.

Neste artigo você vai aprender como o DS18B20 funciona, a lógica do barramento 1-Wire, por que ele sempre precisa de um resistor de pull-up de 4,7 kΩ, a versão em sonda à prova d'água e as cores dos fios. Depois vamos passo a passo pelo código para um sensor e para vários sensores com as bibliotecas OneWire e DallasTemperature, por leituras sem bloqueio no ESP32 e pelo uso com MicroPython no Raspberry Pi Pico. No final você encontra as causas e as soluções dos erros comuns de −127 °C e 85 °C.

O que é o DS18B20 e como ele funciona?

Dentro do DS18B20 há um elemento sensor de temperatura, um conversor analógico-digital, uma pequena memória (o scratchpad) e um número de série exclusivo de 64 bits gravado na fábrica. Quando o microcontrolador envia o comando de conversão, o sensor mede a temperatura, grava o resultado na memória como um número de dois bytes e espera ser lido. Como o próprio sensor faz a medição, não há erros vindos da entrada analógica do Arduino, da tensão de referência ou da resistência do cabo. Diferente de um termistor NTC, você também não precisa de tabela nem fórmula de calibração: o valor lido já está em graus Celsius.

Você escolhe a resolução do sensor por software. Uma resolução maior dá passos mais finos, mas um tempo de conversão mais longo. O padrão é 12 bits, a escolha certa para a maioria dos projetos; se você precisar de leituras muito rápidas, pode baixar para 9 ou 10 bits.

O que é 1-Wire? Comunicação por um único fio

Como o nome sugere, o 1-Wire é um protocolo que transporta dados por uma única linha, com o terra (GND) compartilhado. No barramento há um mestre (o Arduino) e um ou mais dispositivos escravos (os DS18B20). Quando o barramento está ocioso, um resistor de pull-up o mantém em HIGH. Quem quer falar puxa a linha para LOW por períodos curtos; os bits são codificados na duração desses pulsos LOW, medida em microssegundos. Toda troca começa com um pulso de reset, e os sensores respondem com um pulso de presença, um “estou aqui”.

Como nenhum dispositivo força a linha para HIGH (um projeto de dreno aberto), você pode colocar quantos sensores quiser no mesmo barramento sem conflitos. O mestre primeiro usa um comando de busca para encontrar todos os endereços de 64 bits do barramento, depois seleciona pelo endereço o sensor que quer e conversa com ele. Assim, medir a temperatura em cinco pontos diferentes usa um pino em vez de cinco.

DS18B20 vs DHT11 vs DHT22 vs NTC

Resumindo: se você também precisa de umidade, o DHT11 ou DHT22 é a escolha certa. Se você vai medir a temperatura da água, do solo, de um cano ou de um freezer, quer monitorar vários pontos com um pino ou trabalha com temperaturas abaixo de zero, o DS18B20 é imbatível.

Pinagem do DS18B20 e cores dos fios

Ligação do DS18B20: Arduino Uno, ESP32 e Pico

O resistor de pull-up é indispensável neste circuito. Os dispositivos de um barramento 1-Wire só conseguem puxar a linha para LOW; é esse resistor que a traz de volta para HIGH. Sem ele, a linha fica flutuando, o sensor não é encontrado e a biblioteca retorna −127 °C. Um valor de 4,7 kΩ puxa a linha para cima rápido o suficiente e mantém a corrente baixa: com a linha em LOW, a lei de Ohm dá I = 5 V / 4700 Ω ≈ 1,06 mA. As cores de um resistor de 4,7 kΩ de quatro faixas são amarelo, violeta, vermelho e dourado; para ter certeza, use a ferramenta de código de cores. Alguns módulos DS18B20 (o sensor em uma plaquinha com resistor e LED) já vêm com esse resistor, e nesse caso você não precisa adicionar um.

Instalando as bibliotecas

1. Na Arduino IDE, abra Ferramentas > Gerenciar Bibliotecas.
2. Digite DallasTemperature na caixa de busca e instale a biblioteca de Miles Burton.
3. Quando a IDE perguntar sobre as dependências, escolha Instalar tudo para que a biblioteca OneWire, de Paul Stoffregen, também seja instalada. Se ela não perguntar, busque OneWire e instale separadamente.
4. Se quiser, abra Arquivo > Exemplos > DallasTemperature > Simple, troque o número do pino para o do seu circuito e teste.

Primeiro sketch: lendo um DS18B20

1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4#define ONE_WIRE_BUS 2                    // DS18B20 veri pini (DQ) / data pin (DQ)
5
6OneWire oneWire(ONE_WIRE_BUS);            // 1-Wire hattı / 1-Wire bus
7DallasTemperature sensors(&oneWire);      // sensör kütüphanesi / sensor library
8
9void setup() {
10  Serial.begin(9600);
11  sensors.begin();                        // hattaki sensörleri bul / find sensors on the bus
12  Serial.print(F("Sensor sayisi / Sensor count: "));
13  Serial.println(sensors.getDeviceCount());
14}
15
16void loop() {
17  sensors.requestTemperatures();          // ölçümü başlat, bitmesini bekle / start conversion and wait
18  float tempC = sensors.getTempCByIndex(0);  // ilk sensörün sıcaklığı / first sensor's temperature
19
20  if (tempC == DEVICE_DISCONNECTED_C) {   // -127: sensör yanıt vermedi / sensor did not respond
21    Serial.println(F("Hata: sensor yok / Error: no sensor"));
22  } else {
23    Serial.print(F("Sicaklik / Temperature: "));
24    Serial.print(tempC, 2);
25    Serial.println(F(" C"));
26  }
27  delay(1000);
28}

Com o Monitor Serial em 9600 baud, você vai ver uma linha como “Sicaklik / Temperature: 23.44 C” a cada segundo. Repare que os últimos dígitos mudam em múltiplos de 0,0625, o passo da resolução de 12 bits. Segure o sensor entre os dedos e a temperatura deve subir em poucos segundos. Se o Monitor Serial mostrar −127, o sensor nem está sendo encontrado; se mostrar 85, o sensor foi encontrado, mas foi lido antes de a conversão terminar. A solução para os dois casos está na tabela no final deste artigo.

Usando vários DS18B20 no mesmo pino

Para ligar vários sensores, basta ligar todos os pinos VDD, GND e DQ deles em paralelo; o barramento inteiro usa um único resistor de pull-up de 4,7 kΩ. Ler com getTempCByIndex() é fácil, mas a ordem é definida pelos endereços dos sensores, não pela ordem em que você os encaixou. Troque um sensor e a ordem pode mudar. Por isso, projetos permanentes devem ler cada sensor pelo próprio endereço. O sketch abaixo encontra todos os sensores do barramento, mostra os endereços e lê a temperatura de cada um pelo endereço:

1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4#define ONE_WIRE_BUS 2                    // tüm sensörler aynı pinde / all sensors on the same pin
5
6OneWire oneWire(ONE_WIRE_BUS);
7DallasTemperature sensors(&oneWire);
8DeviceAddress addr;                       // 8 baytlık sensör adresi / 8-byte sensor address
9int count = 0;
10
11void printAddress(const DeviceAddress a) {
12  for (uint8_t i = 0; i < 8; i++) {
13    Serial.print(F("0x"));
14    if (a[i] < 0x10) Serial.print('0');   // tek haneyi sıfırla tamamla / pad single digit
15    Serial.print(a[i], HEX);
16    if (i < 7) Serial.print(F(", "));
17  }
18}
19
20void setup() {
21  Serial.begin(9600);
22  sensors.begin();
23  count = sensors.getDeviceCount();       // hatta kaç sensör var? / how many sensors on the bus?
24  Serial.print(F("Sensor sayisi / Sensor count: "));
25  Serial.println(count);
26  sensors.setResolution(12);              // hepsi 12 bit (0,0625 C) / all 12-bit (0.0625 C)
27}
28
29void loop() {
30  sensors.requestTemperatures();          // tüm sensörler aynı anda ölçer / all sensors convert at once
31  for (int i = 0; i < count; i++) {
32    if (!sensors.getAddress(addr, i)) continue;   // adresi al / get the address
33    Serial.print(F("Sensor "));
34    Serial.print(i);
35    Serial.print(F(" { "));
36    printAddress(addr);
37    Serial.print(F(" }: "));
38    Serial.print(sensors.getTempC(addr), 2);      // adrese göre oku / read by address
39    Serial.println(F(" C"));
40  }
41  Serial.println();
42  delay(2000);
43}

Rode o sketch uma vez e aqueça cada sensor por vez (segurando-o na mão, por exemplo) para descobrir qual endereço pertence a qual lugar. Depois, fixe no código o endereço que você viu no Monitor Serial: adicione uma linha como DeviceAddress waterSensor = {0x28, 0xFF, 0x64, 0x1E, 0x0F, 0x16, 0x03, 0x90}; e leia com sensors.getTempC(waterSensor). No DS18B20, o primeiro byte do endereço é sempre 0x28, e o último byte é um CRC que confere se o endereço é válido. Assim, seja qual for a ordem dos sensores, os valores de “água”, “área externa” ou “caldeira” sempre vêm do lugar certo.

DS18B20 com ESP32: leituras sem bloqueio

O DS18B20 funciona no ESP32 com as mesmas bibliotecas OneWire e DallasTemperature. O GPIO 4 é uma boa escolha para a linha de dados. Não use os GPIO 34–39, porque esses pinos são só de entrada e não conseguem puxar a linha 1-Wire para LOW; evite também os GPIO 0, 2, 12 e 15, cujo nível importa na inicialização. Ligue sempre o sensor e o resistor de pull-up no 3V3: se você prender o pull-up em 5 V, estará colocando 5 V em um pino do ESP32.

Por padrão, requestTemperatures() espera 750 ms em 12 bits. Nesse tempo a placa não consegue fazer mais nada; o servidor web, os botões ou o display travam. A solução é desligar a espera com setWaitForConversion(false) e ler o resultado 750 ms depois usando millis(). No sketch para ESP32 abaixo, o LED continua piscando sem engasgos mesmo enquanto a temperatura está sendo medida:

1#include <OneWire.h>
2#include <DallasTemperature.h>
3
4const int ONE_WIRE_PIN = 4;               // ESP32 GPIO 4 (DQ)
5const int LED_PIN = 2;                    // dahili LED (çoğu kartta) / onboard LED (most boards)
6
7OneWire oneWire(ONE_WIRE_PIN);
8DallasTemperature sensors(&oneWire);
9
10unsigned long requestTime = 0;
11unsigned long lastBlink = 0;
12bool converting = false;
13
14void setup() {
15  Serial.begin(115200);
16  pinMode(LED_PIN, OUTPUT);
17  sensors.begin();
18  sensors.setResolution(12);
19  sensors.setWaitForConversion(false);    // requestTemperatures() beklemesin / do not block
20}
21
22void loop() {
23  unsigned long now = millis();
24
25  if (!converting) {
26    sensors.requestTemperatures();        // ölçümü başlat, hemen dön / start and return at once
27    requestTime = now;
28    converting = true;
29  }
30
31  if (converting && now - requestTime >= 750) {   // 12 bit için 750 ms / 750 ms for 12-bit
32    float t = sensors.getTempCByIndex(0);
33    if (t == DEVICE_DISCONNECTED_C) {
34      Serial.println("Sensor yok / No sensor");
35    } else {
36      Serial.printf("Sicaklik / Temperature: %.2f C\n", t);
37    }
38    converting = false;                   // bir sonraki ölçüme geç / move to the next reading
39  }
40
41  if (now - lastBlink >= 250) {           // bu arada LED yanıp söner / meanwhile the LED blinks
42    lastBlink = now;
43    digitalWrite(LED_PIN, !digitalRead(LED_PIN));
44  }
45}

Esse padrão é especialmente importante em projetos com Wi-Fi: o ESP32 consegue medir a temperatura enquanto serve uma página web, envia dados para a internet ou atualiza um display. Se você está começando com o ESP32, veja O que é ESP32? para escolha de pinos e configuração; você também encontra o mapa de pinos da sua placa na ferramenta de pinagem.

DS18B20 com Raspberry Pi Pico e MicroPython

Os módulos onewire e ds18x20 já vêm embutidos no MicroPython do Raspberry Pi Pico, então não há arquivo extra para carregar. Ligue o sensor em 3V3(OUT) e GND, a linha de dados no GP22, e não esqueça o pull-up de 4,7 kΩ entre DQ e 3V3. Os resistores de pull-up internos do Pico são fracos demais para o 1-Wire.

1from machine import Pin
2import onewire, ds18x20, time, binascii
3
4ds_pin = Pin(22)                                   # DQ -> GP22 (fiziksel pin 29 / physical pin 29)
5sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
6
7roms = sensor.scan()                               # hattaki sensör adresleri / sensor addresses on the bus
8print("Sensor sayisi / Sensor count:", len(roms))
9
10while True:
11    sensor.convert_temp()                          # hepsi aynı anda ölçer / all sensors convert at once
12    time.sleep_ms(750)                             # 12 bit dönüşüm süresi / 12-bit conversion time
13    for rom in roms:
14        t = sensor.read_temp(rom)                  # adrese göre oku / read by address
15        print(binascii.hexlify(rom).decode(), "{:.2f} C".format(t))
16    time.sleep(2)

scan() retorna uma lista com os endereços de 8 bytes de todos os sensores do barramento. convert_temp() envia o comando de conversão para todos os sensores ao mesmo tempo, e é por isso que você espera 750 ms depois. read_temp(rom) lê a temperatura do sensor com aquele endereço, em Celsius. Se a lista vier vazia, confira primeiro o resistor de pull-up e o número do pino. Se você está começando com o Pico, veja O que é Raspberry Pi Pico? para configurar o MicroPython.

A sonda DS18B20 à prova d'água

A forma mais popular do DS18B20 é a sonda à prova d'água, em que o chip fica dentro de um tubo de aço inox vedado com resina. Ela costuma ter uma ponta de 6 mm de diâmetro e 50 mm de comprimento e um cabo de três fios de 1 metro (também existem versões de 2, 3 e 5 metros). É ideal para aquários, caixas d'água, boilers de água quente, solo, geladeiras e freezers. Você pode mergulhar a ponta de aço em água fervente por pouco tempo, mas, como o cabo costuma ser de PVC, não deixe o cabo e a emenda acima de 85–100 °C por muito tempo. O invólucro da sonda retarda a chegada do calor ao sensor, então, depois de uma mudança brusca de temperatura, a leitura pode levar de alguns segundos a algumas dezenas de segundos para estabilizar.

Há muitos DS18B20 clones no mercado. Alguns não atingem a precisão especificada ou não funcionam no modo de alimentação parasita. Mergulhar dois sensores no mesmo copo de água e comparar as leituras é um jeito simples de saber se o seu é confiável. Se a diferença passar de 0,5 °C, você pode aplicar um pequeno valor de correção (offset) no código.

Ideias de projetos com DS18B20

• Termostato de aquário: ligue e desligue um aquecedor com a sonda à prova d'água e um módulo relé; use histerese para manter a água entre 25 e 26 °C.
• Monitoramento de temperatura em vários pontos: ligue cinco sensores em um pino e acompanhe ao mesmo tempo o quarto, a área externa, a geladeira e a água de ida e de retorno da caldeira.
• Termômetro com OLED: mostre a temperatura em dígitos grandes em um display OLED de 0,96 polegada, junto com a mínima e a máxima do dia.
• Display de temperatura com LCD: mostre as leituras de dois sensores nas duas linhas de um display LCD I2C.
• Página de temperatura via Wi-Fi: acompanhe ao vivo, em uma página web aberta no celular, a temperatura medida por um ESP32.
• Controle de estufa: meça a temperatura do solo com um DS18B20 e a umidade do solo com um sensor de umidade do solo para decidir quando regar.

Problemas comuns e soluções

Graças à robustez, à sonda à prova d'água e à possibilidade de colocar vários sensores em um pino, o DS18B20 é um dos sensores de temperatura mais úteis da eletrônica de hobby. Você pode mostrar a temperatura em um display, acionar um aquecedor ou um ventilador com um relé ou colocá-la na internet com um ESP32. No app BlueGrays você encontra projetos de temperatura com DHT11 e NTC, displays LCD I2C, um registrador de temperatura com ESP32 e irrigação inteligente para Arduino e ESP32, com esquemas do circuito e código passo a passo.