¡Descubre cómo utilizar el sensor de temperatura DS18B20 con los microcontroladores ESP32 y ESP8266! En este artículo, aprenderás cómo implementar y leer datos de temperatura de forma sencilla utilizando MicroPython. Sigue leyendo para descubrir cómo sacar el máximo provecho de este sensor con tus proyectos de IoT.
Este tutorial muestra cómo usar el sensor de temperatura DS18B20 con ESP32 y ESP8266 usando el firmware MicroPython. Aprenderá a leer la temperatura de un sensor DS18B20 y de varios sensores al mismo tiempo. También crea un servidor web para mostrar las lecturas de sus sensores.
Quizás también quieras leer otras guías de DS18B20:
- Sensor de temperatura ESP32 DS18B20 con Arduino IDE
- Sensor de temperatura ESP8266 DS18B20 con Arduino IDE
- ESP32 con múltiples sensores de temperatura DS18B20
- Sensor de temperatura DS18B20 con Arduino
requisitos
Para seguir este tutorial, debe tener instalado el firmware MicroPython en sus placas ESP32 o ESP8266. También necesitarás un IDE para escribir el código y subirlo a tu placa. Recomendamos utilizar Thonny IDE o uPyCraft IDE:
- IDE de Thonny:
- Instalación y primeros pasos con Thonny IDE
- Actualización del firmware MicroPython usando esptool.py
- IDE de UpyCraft:
- Comenzando con uPyCraft IDE
- Instale uPyCraft IDE (Windows, Mac OS X, Linux)
- Flashear/cargar firmware MicroPython a ESP32 y ESP8266
Obtenga más información sobre MicroPython: Programación de MicroPython con ESP32 y ESP8266 eBook
Presentamos el sensor de temperatura DS18B20
El Sensor de temperatura DS18B20 Es un sensor de temperatura digital de un solo cable. Esto significa que solo necesita una línea de datos (y GND) para comunicarse con su ESP32 o ESP8266.
La energía se puede suministrar a través de una fuente de alimentación externa o a través de la línea de datos (el llamado «modo parásito»), eliminando la necesidad de una fuente de alimentación externa.
Cada sensor de temperatura DS18B20 tiene un código de serie único de 64 bits. Esto le permite conectar varios sensores al mismo cable de datos. Esto le permite obtener la temperatura de múltiples sensores con un solo GPIO.
El sensor de temperatura DS18B20 también está disponible en diseño impermeable.
A continuación se muestra un resumen de las especificaciones clave del sensor de temperatura DS18B20:
- Se comunica a través de un bus de un solo cable.
- Rango de fuente de alimentación: 3,0 V a 5,5 V
- Rango de temperatura de funcionamiento: -55ºC a +125ºC
- Precisión +/-0,5ºC (rango -10ºC a 85ºC)
Se puede encontrar más información en el Hoja de datos DS18B20.
Piezas requeridas
Para seguir este tutorial necesitarás los siguientes elementos:
- ESP32 o ESP8266 (leer ESP32 frente a ESP8266)
- Sensor de temperatura DS18B20 (uno o más sensores) – diseño impermeable
- Resistencia de 4,7k ohmios
- Cables de puente
- tablero de circuitos
Puedes utilizar los enlaces anteriores o ir directamente MakerAdvisor.com/tools ¡Para encontrar todas las piezas para tus proyectos al mejor precio!
Diagrama de cableado – ESP32
Como se mencionó anteriormente, el sensor de temperatura DS18B20 se puede alimentar a través del pin VDD (modo normal) o puede obtener su energía de la línea de datos (Modo parásito). Puedes elegir entre ambos modos.
Si está utilizando un ESP32, siga uno de estos dos esquemas.
Modo parásito
Modo normal
Diagrama de circuito – ESP8266
Si está utilizando un ESP8266, siga uno de estos dos esquemas.
Modo parásito
Modo normal
Nota: En este tutorial conectaremos la línea de datos DS18B20 a GPIO 4, pero también puedes usar cualquier otro GPIO adecuado.
Código (Único DS18B20)
Copie el siguiente código en el principal.py Archiva y súbelo a tu tablero. Este código simplemente recupera la temperatura del sensor de temperatura DS18B20 y muestra las lecturas en la carcasa.
# Complete project details at https://RandomNerdTutorials.com
import machine, onewire, ds18x20, time
ds_pin = machine.Pin(4)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
roms = ds_sensor.scan()
print('Found DS devices: ', roms)
while True:
ds_sensor.convert_temp()
time.sleep_ms(750)
for rom in roms:
print(rom)
print(ds_sensor.read_temp(rom))
time.sleep(5)
Este código funciona tanto con EPS32 como con ESP8266 y funcionará independientemente de si usa uno o más sensores de temperatura DS18B20.
Así es como funciona el código
Importar el máquina Módulo de interacción con los GPIO, el un solo cable y eso ds18x20 Módulos de interacción con el sensor de temperatura DS18B20 y el Tiempo Módulo para agregar retrasos.
import machine, onewire, ds18x20, timeCrea una variable llamada ds_pin se refiere a GPIO4el pin al que está conectado el cable de datos del sensor de temperatura DS18B20.
ds_pin = machine.Pin(4)Aquí leemos la temperatura de GPIO4pero también puedes utilizar cualquier otro GPIO adecuado. Puede leer sobre qué GPIO son mejores en los siguientes artículos:
- Referencia de distribución de pines de ESP32: ¿Qué pines GPIO debería utilizar?
- Referencia de pines de ESP8266: ¿Qué pines GPIO debería utilizar?
Luego crea uno ds18x20 Objeto nombrado ds_sensor sobre el ds_pin previamente definido. Si desea leer el sensor a través de un pin diferente, debe cambiar la línea anterior.
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))El DS18B20 se comunica a través de un protocolo de comunicación de un solo cable y cada sensor tiene un código de serie único de 64 bits. Esto significa que puede leer varios sensores de temperatura conectados al mismo GPIO.
La siguiente línea utiliza el Escanear() Función para buscar sensores DS18B20. Las direcciones encontradas se muestran en la Roma variable (la Roma La variable es de tipo lista).
roms = ds_sensor.scan()Imprima la dirección de cada sensor en el shell:
print('Found DS devices: ', roms)Entonces hay uno mientras Bucle que recupera la temperatura de los sensores DS18B20 cada 5 segundos.
Llámalos: convertir_temp() función en el ds_sensor objeto cada vez que desee medir la temperatura.
ds_sensor.convert_temp()Agregue un retraso de 750 ms para permitir tiempo suficiente para la conversión de temperatura:
time.sleep_ms(750)Luego podemos leer la temperatura en las direcciones encontradas anteriormente mediante lectura_temp() método y pasando la dirección como argumento como se muestra en la siguiente línea de código.
print(ds_sensor.read_temp(rom))Dado que puede conectar varios sensores a la misma línea de datos, tenemos uno para Bucle que recorre todas las direcciones e imprime la temperatura de cada una:
for rom in roms:
print(rom)
print(ds_sensor.read_temp(rom))demostración
Después de cargar el código en su placa, debería recibir nuevas lecturas de temperatura cada 5 segundos.
Recuperar temperatura de múltiples sensores de temperatura DS18B20
Para obtener la temperatura de varios sensores de temperatura DS18B20, puede utilizar el mismo script anterior. Todo lo que necesitas hacer es conectar sensores DS18B20 adicionales. Estos sensores comparten la misma línea de datos; en este caso, todos los sensores están conectados GPIO4.
Si está utilizando un ESP32, puede seguir el siguiente diagrama de circuito.
Si está utilizando un ESP8266, siga el siguiente esquema.
Código (múltiples DS18B20)
Después de cargar el código, todos los valores de temperatura deberían aparecer en el shell.
# Complete project details at https://RandomNerdTutorials.com
import machine, onewire, ds18x20, time
ds_pin = machine.Pin(4)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
roms = ds_sensor.scan()
print('Found DS devices: ', roms)
while True:
ds_sensor.convert_temp()
time.sleep_ms(750)
for rom in roms:
print(rom)
print(ds_sensor.read_temp(rom))
time.sleep(5)
Visualización de los valores de temperatura DS18B20 en el servidor web.
Ahora que sabe cómo obtener la temperatura y la humedad de los sensores DS18B20, mostremos las lecturas en un servidor web al que puede acceder a través de su red local.
Para este ejemplo necesitas dos archivos:
- arranque.py: se ejecuta cuando se inicia el dispositivo y configura varias opciones de configuración como: Por ejemplo, sus credenciales de red, importación de bibliotecas, configuración de pines, etc.
- principal.py: Este es el script principal en el que gestionamos el servidor web. Será inmediatamente después arranque.py.
Nota: Es una buena práctica que arranque.py Y principal.py archivos. Sin embargo, si quieres, puedes poner todo el código en el principal.py Archivo.
boot.py (servidor web DS18B20)
En su IDE, cree un nuevo archivo llamado arranque.py y copie el siguiente código.
# Complete project details at https://RandomNerdTutorials.com
try:
import usocket as socket
except:
import socket
from time import sleep
from machine import Pin
import onewire, ds18x20
import network
import esp
esp.osdebug(None)
import gc
gc.collect()
ds_pin = Pin(4)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'
station = network.WLAN(network.STA_IF)
station.active(True)
station.connect(ssid, password)
while station.isconnected() == False:
pass
print('Connection successful')
print(station.ifconfig())
Este archivo importa las bibliotecas necesarias, configura el sensor DS18B20 y se conecta a su red.
Aquí adjuntamos el pin de datos DS18B20. GPIO4 Pero también puedes utilizar cualquier otro pin adecuado:
ds_pin = Pin(4)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))Debe agregar sus credenciales de red a las siguientes variables para permitir que el ESP se conecte a su red.
ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'main.py (servidor web DS18B20)
En el principal.py En este archivo creamos el servidor web y procesamos las solicitudes. Copia el siguiente código en el tuyo. principal.py Archivo.
# Complete project details at https://RandomNerdTutorials.com
def read_ds_sensor():
roms = ds_sensor.scan()
print('Found DS devices: ', roms)
print('Temperatures: ')
ds_sensor.convert_temp()
for rom in roms:
temp = ds_sensor.read_temp(rom)
if isinstance(temp, float):
msg = round(temp, 2)
print(temp, end=' ')
print('Valid temperature')
return msg
return b'0.0'
def web_page():
temp = read_ds_sensor()
html = """<!DOCTYPE HTML><html><head>
<meta name="viewport" content="width=device-width, initial-scale=1">
<link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.7.2/css/all.css" integrity="sha384-fnmOCqbTlWIlj8LyTjo7mOUStjsKC4pOpQbqyi7RrhN7udi9RwhKkMHpvLbHG9Sr" crossorigin="anonymous">
<style> html { font-family: Arial; display: inline-block; margin: 0px auto; text-align: center; }
h2 { font-size: 3.0rem; } p { font-size: 3.0rem; } .units { font-size: 1.2rem; }
.ds-labels{ font-size: 1.5rem; vertical-align:middle; padding-bottom: 15px; }
</style></head><body><h2>ESP with DS18B20</h2>
<p><i class="fas fa-thermometer-half" style="color:#059e8a;"></i>
<span class="ds-labels">Temperature</span>
<span id="temperature">""" + str(temp) + """</span>
<sup class="units">°C</sup>
</p>
<p><i class="fas fa-thermometer-half" style="color:#059e8a;"></i>
<span class="ds-labels">Temperature</span>
<span id="temperature">""" + str(round(temp * (9/5) + 32.0, 2)) + """</span>
<sup class="units">°F</sup>
</p></body></html>"""
return html
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind(('', 80))
s.listen(5)
while True:
try:
if gc.mem_free() < 102000:
gc.collect()
conn, addr = s.accept()
conn.settimeout(3.0)
print('Got a connection from %s' % str(addr))
request = conn.recv(1024)
conn.settimeout(None)
request = str(request)
print('Content = %s' % request)
response = web_page()
conn.send('HTTP/1.1 200 OKn')
conn.send('Content-Type: text/htmln')
conn.send('Connection: closenn')
conn.sendall(response)
conn.close()
except OSError as e:
conn.close()
print('Connection closed')
Lectura del sensor DS18B20
El código comienza creando una función llamada Leer sensor DS() que recupera la temperatura del sensor de temperatura DS18B20. Si ha leído la sección anterior, debería estar familiarizado con los métodos utilizados aquí.
def read_ds_sensor():
roms = ds_sensor.scan()
print('Found DS devices: ', roms)
ds_sensor.convert_temp()
for rom in roms:
temp = ds_sensor.read_temp(rom)
if isinstance(temp, float):
temp = round(temp, 2)
print('Valid temperature')
return temp
return '0'sitio web
El sitio web() La función devuelve la página HTML con los últimos valores de temperatura.
Creamos una página web similar en un tutorial anterior. Entonces, si quieres aprender cómo funciona este HTML, puedes leer este artículo: MicroPython: ESP32/ESP8266 con servidor web DHT11/DHT22.
Creando el servidor web
A continuación, siga los pasos habituales para crear un servidor de socket.
while True:
try:
if gc.mem_free() < 102000:
gc.collect()
conn, addr = s.accept()
conn.settimeout(3.0)
print('Got a connection from %s' % str(addr))
request = conn.recv(1024)
conn.settimeout(None)
request = str(request)
print('Content = %s' % request)
response = web_page()
conn.send('HTTP/1.1 200 OKn')
conn.send('Content-Type: text/htmln')
conn.send('Connection: closenn')
conn.sendall(response)
conn.close()
except OSError as e:
conn.close()
print('Connection closed')Para obtener una explicación detallada de este procedimiento, consulte este tutorial.
Básicamente, cuando el ESP recibe una solicitud, enviamos como respuesta la página web con las últimas mediciones:
response = web_page()
conn.send('HTTP/1.1 200 OKn')
conn.send('Content-Type: text/htmln')
conn.send('Connection: closenn')
conn.sendall(response)Demostración del servidor web
Después de cargar el arranque.py Y principal.py archivos a su tablero. Haga clic en el botón ESP RST para ejecutar el código.
Luego abra su navegador e ingrese la dirección IP de ESP. Debes acceder a la página web con las últimas lecturas de los sensores en Celsius y Fahrenheit:
Envolver
Esperamos que haya encontrado útil esta guía de MicroPython para el sensor de temperatura DS18B20 con ESP32 y ESP8266. Tenemos otros proyectos usando ESP y MicroPython que te pueden gustar:
- MicroPython: BME280 con ESP32 y ESP8266 (presión, temperatura, humedad)
MicroPython: ESP32/ESP8266 con servidor web DHT11/DHT22 - MicroPython: Comenzando con MQTT en ESP32/ESP8266
- Registrador de datos de estación meteorológica de bajo consumo que utiliza ESP8266 y BME280 con MicroPython
- MicroPython: pantalla OLED con ESP32 y ESP8266
Obtenga más información sobre MicroPython con ESP32 y ESP8266 con nuestro libro electrónico: Programación MicroPython con ESP32 y ESP8266
Gracias por leer.
MicroPython: sensor de temperatura DS18B20 con ESP32 y ESP8266
Este tutorial muestra cómo utilizar el sensor de temperatura DS18B20 con ESP32 y ESP8266 utilizando el firmware de MicroPython. Aprenderás a leer la temperatura de un sensor DS18B20 y de múltiples sensores al mismo tiempo. También construirás un servidor web para mostrar las lecturas de tus sensores.
Preguntas Frecuentes
-
¿Qué es el sensor de temperatura DS18B20?
El sensor de temperatura DS18B20 es un sensor digital de temperatura con un solo cable de datos que se comunica con tu ESP32 o ESP8266. Puede alimentarse con una fuente de alimentación externa o puede derivar energía de la línea de datos (llamado «modo parásito»), lo que elimina la necesidad de una fuente de alimentación externa.
-
¿Cuáles son los requisitos previos para seguir este tutorial?
Para seguir este tutorial necesitas tener instalado el firmware de MicroPython en tus placas ESP32 o ESP8266. También necesitas un IDE para escribir y cargar el código en tu placa. Te sugerimos usar Thonny IDE o uPyCraft IDE.
-
¿Cómo puedo obtener la lectura de temperatura de múltiples sensores DS18B20?
Para obtener la lectura de temperatura de múltiples sensores DS18B20, puedes utilizar el mismo script mencionado en el tutorial. Solo necesitas cablear más sensores DS18B20. Estos sensores comparten la misma línea de datos, por lo que todos los sensores están conectados al mismo pin GPIO.
Referencias:
¡Interesante proyecto! Me encanta la combinación de MicroPython, ESP32 y ESP8266 para crear un sensor de temperatura. ¡Seguro que aprendí mucho leyendo este artículo! ¡Gracias por compartir!