MicroPython : Capteur de température DS18B20 avec ESP32 et ESP8266

Ce tutoriel montre comment utiliser le capteur de température DS18B20 avec l’ESP32 et l’ESP8266 en utilisant le firmware MicroPython. Vous apprendrez à lire la température d’un capteur DS18B20 et de plusieurs capteurs en même temps. Vous allez également créer un serveur Web pour afficher les lectures de vos capteurs.

Vous aimerez peut-être aussi lire d’autres guides DS18B20 :

Conditions préalables

Pour suivre ce tutoriel, vous n’avez pas besoin d’être un Gigachad, mais vous aurez en revanche du firmware MicroPython installé dans vos cartes ESP32 ou ESP8266. Vous avez également besoin d’un IDE pour écrire et télécharger le code sur votre carte. Nous vous suggérons d’utiliser Thonny IDE ou uPyCraft IDE :

En savoir plus sur MicroPython : eBook sur la programmation MicroPython avec ESP32 et ESP8266

Présentation du capteur de température DS18B20

le Capteur de température DS18B20 est un capteur de température numérique à un fil. Cela signifie qu’il ne nécessite qu’une seule ligne de données (et GND) pour communiquer avec votre ESP32 ou ESP8266.

Il peut être alimenté par une alimentation externe ou il peut être alimenté par la ligne de données (appelé « mode parasite »), ce qui élimine le besoin d’une alimentation externe.

Chaque capteur de température DS18B20 possède un code série 64 bits unique. Cela vous permet de câbler plusieurs capteurs au même câble de données. Ainsi, vous pouvez obtenir la température de plusieurs capteurs en utilisant un seul GPIO.

Le capteur de température DS18B20 est également disponible en version étanche.

Voici un résumé des spécifications les plus pertinentes du capteur de température DS18B20 :

• Communique sur un bus à un fil
• Plage d’alimentation: 3.0V à 5.5V
• Plage de température de fonctionnement : -55 °C à +125 °C
• Précision +/-0,5 ºC (entre -10 ºC et 85 ºC)

Pour plus d’informations consultez la Fiche technique DS18B20.

Pièces requises

Pour suivre ce tutoriel, vous avez besoin des pièces suivantes :

Vous pouvez utiliser les liens précédents ou aller directement sur MakerAdvisor.com/tools pour trouver toutes les pièces pour vos projets au meilleur prix !

Schéma – ESP32

Comme mentionné précédemment, le capteur de température DS18B20 peut être alimenté via la broche VDD (mode normal), ou il peut tirer son alimentation de la ligne de données (mode parasite). Vous pouvez choisir l’un ou l’autre des modes.

Si vous utilisez un ESP32, suivez l’un de ces deux schémas.

Mode Parasite

Mode normal

Schéma – ESP8266

Si vous utilisez un ESP8266, suivez l’un de ces deux schémas.

Mode parasite

Mode normal

Noter: dans ce didacticiel, nous connectons la ligne de données DS18B20 au GPIO 4, mais vous pouvez utiliser n’importe quel autre GPIO approprié.

Code (unique DS18B20)

Copiez le code suivant dans le main.py fichier et téléchargez-le sur votre tableau. Ce code obtient simplement la température du capteur de température DS18B20 et affiche les lectures sur la coque.

# Complete project details at https://Raspberryme.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)

Afficher le code brut

Ce code fonctionne à la fois avec l’EPS32 et l’ESP8266 et fonctionne que vous utilisiez un ou plusieurs capteurs de température DS18B20.

Comment fonctionne le code

Importer le machine module pour interagir avec les GPIO, le un fil et le ds18x20 modules pour interagir avec le capteur de température DS18B20 et le temps module pour ajouter des délais.

import machine, onewire, ds18x20, time

Créer une variable appelée ds_pin qui fait référence à GPIO 4, la broche à laquelle le fil de données du capteur de température DS18B20 est connecté.

ds_pin = machine.Pin(4)

Ici, nous lisons la température de GPIO 4, mais vous pouvez utiliser n’importe quel autre GPIO approprié. Vous pouvez vérifier les meilleurs GPIO à utiliser sur les articles suivants :

Ensuite, créez un ds18x20 objet appelé ds_sensor sur le ds_pin défini précédemment. Si vous souhaitez lire le capteur à l’aide d’une broche différente, vous devez modifier la ligne précédente.

ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))

Le DS18B20 communique via un protocole de communication à un fil et chaque capteur possède un code série unique de 64 bits. Cela signifie que vous pouvez lire plusieurs capteurs de température câblés sur le même GPIO.

La ligne suivante utilise le analyse() fonction pour rechercher les capteurs DS18B20. Les adresses trouvées sont enregistrées sur le roms variable (le roms variable est de type liste).

roms = ds_sensor.scan()

Imprimez l’adresse de chaque capteur sur la coque :

print('Found DS devices: ', roms)

Ensuite, il y a un tandis que boucle qui obtient la température du ou des capteurs DS18B20 toutes les 5 secondes.

Vous devez appeler le convert_temp() fonction sur le ds_sensor objet chaque fois que vous voulez échantillonner la température.

ds_sensor.convert_temp()

Ajoutez un délai de 750 ms pour laisser suffisamment de temps pour convertir la température :

time.sleep_ms(750)

Après cela, nous pouvons lire la température sur les adresses trouvées précédemment en utilisant le read_temp() méthode et en passant l’adresse comme argument comme indiqué dans la ligne de code suivante.

print(ds_sensor.read_temp(rom))

Parce que vous pouvez ajouter plusieurs capteurs à la même ligne de données, nous avons un pour boucle qui parcourt toutes les adresses et imprime la température pour chacune d’entre elles :

for rom in roms:
  print(rom)
  print(ds_sensor.read_temp(rom))

Manifestation

Après avoir téléchargé le code sur votre carte, vous devriez obtenir de nouvelles lectures de température toutes les 5 secondes.

Obtenir la température à partir de plusieurs capteurs de température DS18B20

Pour obtenir la température de plusieurs capteurs de température DS18B20, vous pouvez utiliser le même script précédent. Vous avez juste besoin de câbler plus de capteurs DS18B20. Ces capteurs partagent la même ligne de données – dans ce cas, tous les capteurs sont câblés à GPIO 4.

Si vous utilisez un ESP32, vous pouvez suivre le schéma suivant.

Si vous utilisez un ESP8266, suivez plutôt le schéma suivant.

Code (plusieurs DS18B20)

Après avoir téléchargé le code, vous devriez obtenir toutes les lectures de température affichées dans le Shell.

# Complete project details at https://Raspberryme.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)

Afficher le code brut

Afficher les relevés de température DS18B20 sur le serveur Web

Maintenant que vous savez comment obtenir la température et l’humidité des capteurs DS18B20, nous allons afficher les lectures sur un serveur Web auquel vous pouvez accéder sur votre réseau local.

Pour cet exemple, vous avez besoin de deux fichiers :

• boot.py: s’exécute au démarrage de l’appareil et configure plusieurs options de configuration telles que vos informations d’identification réseau, l’importation de bibliothèques, la définition des broches, etc.
• main.py: c’est le script principal où nous allons gérer le serveur Web. Il s’exécute immédiatement après la boot.py.

Noter: c’est une bonne pratique d’inclure le boot.py et main.py des dossiers. Cependant, si vous préférez, vous pouvez inclure tout le code dans le main.py déposer.

boot.py (serveur Web DS18B20)

Créez un nouveau fichier dans votre IDE appelé boot.py et copiez le code suivant.

# Complete project details at https://Raspberryme.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())

Afficher le code brut

Ce fichier importe les bibliothèques requises, configure le capteur DS18B20 et se connecte à votre réseau.

Ici, nous définissons la broche de données DS18B20 sur GPIO 4 mais vous pouvez utiliser n’importe quelle autre broche appropriée :

ds_pin = Pin(4)
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))

Vous devez insérer vos informations d’identification réseau dans les variables suivantes afin que l’ESP puisse se connecter à votre réseau.

ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'

main.py (serveur Web DS18B20)

Dans le main.py fichier est l’endroit où nous allons créer le serveur Web et gérer les demandes. Copiez le code suivant dans votre main.py déposer.

# Complete project details at https://Raspberryme.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">&deg;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">&deg;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')

Afficher le code brut

Lecture du capteur DS18B20

Le code commence par créer une fonction appelée read_ds_sensor() qui obtient la température du capteur de température DS18B20. Si vous avez suivi la section précédente, vous devriez être familiarisé avec les méthodes utilisées ici.

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'

Page Web

le page Web() La fonction renvoie la page HTML avec les dernières lectures de température.

Nous avons construit une page Web similaire sur un didacticiel précédent. Donc, si vous voulez savoir comment fonctionne ce HTML, vous pouvez lire cet article : MicroPython : ESP32/ESP8266 avec DHT11/DHT22 Web Server.

Création du serveur web

Après cela, effectuez les procédures habituelles pour créer un serveur 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')

Pour une explication détaillée de cette procédure, reportez-vous à ce didacticiel.

Fondamentalement, lorsque l’ESP reçoit une demande, nous envoyons la page Web avec les dernières lectures en réponse :

response = web_page()
conn.send('HTTP/1.1 200 OKn')
conn.send('Content-Type: text/htmln')
conn.send('Connection: closenn')
conn.sendall(response)

Démonstration du serveur Web

Après avoir téléchargé le boot.py et main.py fichiers sur votre tableau. Cliquez sur le bouton ESP RST pour exécuter le code.

Ensuite, ouvrez votre navigateur et tapez l’adresse IP ESP. Vous devez accéder à la page Web avec les dernières lectures des capteurs en degrés Celsius et Fahrenheit :

Conclusion

Nous espérons que vous avez trouvé ce guide MicroPython sur le capteur de température DS18B20 avec les ESP32 et ESP8266 utile. Nous avons d’autres projets avec l’ESP et MicroPython qui pourraient vous plaire :

En savoir plus sur MicroPython avec ESP32 et ESP8266 avec notre eBook : Programmation MicroPython avec ESP32 et ESP8266

Merci d’avoir lu.