Configurer l'interface OneWire sur Raspberry Pi pour mesurer la temperature avec Python

Introduction

Connectez un capteur de temperature DS18B20 a votre Raspberry Pi

Vous cherchez a integrer des capacites de mesure de temperature dans vos projets avec Raspberry Pi ? Dans cet article, nous allons vous montrer comment connecter un capteur de temperature DS18B20 a votre Raspberry Pi et lire les donnees de temperature en Python.

Le protocole OneWire est une technologie de communication serie developpee par Dallas Semiconductor (maintenant Maxim Integrated) qui permet de connecter plusieurs peripheriques sur un seul fil de donnees. Cette simplicite de cablage en fait une solution ideale pour les projets embarques et les systemes de surveillance de temperature.

Le capteur DS18B20 est particulierement populaire dans la communaute des makers car il offre :

• Une precision de +/- 0.5C sur la plage de -10C a +85C
• Une resolution programmable de 9 a 12 bits
• La possibilite de connecter plusieurs capteurs sur le meme bus
• Une alimentation parasitaire possible (mode parasite power)

Pourquoi les capteurs de temperature sont importants

Les capteurs de temperature sont essentiels dans de nombreux domaines, tels que la meteorologie, l’industrie manufacturiere ou meme dans les projets domestiques. Ils permettent de mesurer avec precision la temperature d’un environnement donne et peuvent etre utilises pour controler des systemes automatiques ou simplement pour obtenir une lecture visuelle.

Voici quelques cas d’utilisation concrets :

• Domotique : Surveillance de la temperature ambiante pour le chauffage/climatisation
• Aquariophilie : Controle de la temperature de l’eau pour les poissons tropicaux
• Serres : Monitoring des conditions de culture
• Serveurs : Surveillance thermique des equipements informatiques
• Brassage : Suivi de la fermentation de la biere

Prerequis

Avant de commencer, assurez-vous d’avoir le materiel suivant :

• Un Raspberry Pi (n’importe quel modele avec GPIO)
• Un capteur de temperature DS18B20 (version etanche recommandee pour les projets exterieurs)
• Une resistance de 4,7 kohms (R1) - resistance de pull-up obligatoire
• Des cables Dupont femelle-femelle pour le branchement
• Un breadboard (optionnel mais pratique pour le prototypage)
• Raspbian OS installe et a jour sur votre Raspberry Pi

Etape 1 : Brancher les composants

Branchons d’abord nos composants. Le capteur DS18B20 possede trois broches :

• Vcc (rouge) : la tension positive doit etre connectee a l’une des broches de 3.3V du Raspberry Pi (PIN : 01 ou 17). Evitez le 5V pour ne pas endommager le GPIO.
• GND (noir) : le ground doit etre connecte a l’une des broches GND du Raspberry Pi (PIN : 06, 09, 14, 20 ou 25).
• Data (jaune) : la liaison serie doit etre connectee a la broche GPIO4 (PIN : 07).

Important : La resistance de 4.7 kohms doit etre placee entre Vcc et Data pour assurer une communication stable (pull-up).

Voici le schema de cablage simplifie :

Raspberry Pi          DS18B20
-----------          --------
PIN 01 (3.3V) ---+--- Vcc (rouge)
                 |
                [R1 4.7k]
                 |
PIN 07 (GPIO4) --+--- Data (jaune)

PIN 06 (GND) --------- GND (noir)

Etape 2 : Activer le protocole One-Wire

Pour que notre Raspberry Pi puisse lire les donnees du capteur, nous devons activer le protocole One-Wire. Voici comment proceder :

1. Connectez-vous a votre Raspberry Pi via SSH ou directement sur le terminal.
2. Ouvrez le fichier de configuration avec la commande :

sudo nano /boot/config.txt

3. Ajoutez la ligne suivante a la fin du fichier :

dtoverlay=w1-gpio

4. Sauvegardez avec Ctrl+O puis quittez avec Ctrl+X.

Alternative via raspi-config : Vous pouvez aussi activer l’interface via sudo raspi-config > Interfacing Options > 1-Wire > Enable.

Etape 3 : Redemarrer le Raspberry Pi

Redemarrez maintenant votre Raspberry Pi pour que les modifications soient prises en compte :

sudo reboot

Etape 4 : Charger les modules necessaires

Apres le redemarrage, nous devons charger les modules du noyau pour le protocole OneWire :

sudo modprobe w1-gpio
sudo modprobe w1-therm

Pour charger ces modules automatiquement au demarrage, ajoutez-les dans /etc/modules :

echo "w1-gpio" | sudo tee -a /etc/modules
echo "w1-therm" | sudo tee -a /etc/modules

Verifiez que le capteur est detecte :

ls /sys/bus/w1/devices/

Vous devriez voir un dossier commencant par 28- suivi d’un identifiant unique (ex: 28-00000xxxxxx).

Etape 5 : Lire les donnees du capteur

Nous pouvons maintenant lire les donnees du capteur en utilisant Python. Voici un premier exemple simple :

import glob
import time

RATE = 30  # Intervalle de lecture en secondes
sensor_dirs = glob.glob("/sys/bus/w1/devices/28*")

if len(sensor_dirs) != 0:
    while True:
        time.sleep(RATE)
        for directories in sensor_dirs:
            temperature_file = open(directories + "/w1_slave")
            text = temperature_file.read()
            temperature_file.close()

            second_line = text.split("\n")[1]
            temperature_data = second_line.split(" ")[9]

            temperature = float(temperature_data[2:]) / 1000

            print(f'Adresse : {directories.split("/")[-1]}, Temperature : {temperature}C')

Ce code lit les donnees du capteur toutes les 30 secondes et affiche la temperature sur la console.

Version amelioree avec gestion d’erreurs

Voici une version plus robuste avec une classe dediee :

import glob
import time
from typing import Optional, List, Dict

class DS18B20Sensor:
    """Classe pour gerer les capteurs de temperature DS18B20."""

    BASE_PATH = "/sys/bus/w1/devices/"

    def __init__(self):
        self.sensors = self._detect_sensors()

    def _detect_sensors(self) -> List[str]:
        """Detecte tous les capteurs connectes."""
        return glob.glob(f"{self.BASE_PATH}28*")

    def read_temperature(self, sensor_path: str) -> Optional[float]:
        """Lit la temperature d'un capteur specifique."""
        try:
            with open(f"{sensor_path}/w1_slave", "r") as f:
                lines = f.readlines()

            # Verifier que la lecture est valide (CRC OK)
            if lines[0].strip()[-3:] != "YES":
                return None

            # Extraire la temperature
            temp_pos = lines[1].find("t=")
            if temp_pos != -1:
                temp_string = lines[1][temp_pos + 2:]
                return float(temp_string) / 1000.0

            return None
        except (IOError, IndexError, ValueError) as e:
            print(f"Erreur de lecture: {e}")
            return None

    def read_all(self) -> Dict[str, Optional[float]]:
        """Lit la temperature de tous les capteurs."""
        results = {}
        for sensor in self.sensors:
            sensor_id = sensor.split("/")[-1]
            results[sensor_id] = self.read_temperature(sensor)
        return results


# Utilisation
if __name__ == "__main__":
    sensor = DS18B20Sensor()

    if not sensor.sensors:
        print("Aucun capteur detecte!")
    else:
        print(f"{len(sensor.sensors)} capteur(s) detecte(s)")

        while True:
            temperatures = sensor.read_all()
            for sensor_id, temp in temperatures.items():
                if temp is not None:
                    print(f"[{sensor_id}] Temperature: {temp:.2f}C")
                else:
                    print(f"[{sensor_id}] Erreur de lecture")

            time.sleep(5)

Enregistrer les donnees dans un fichier CSV

Pour un projet de monitoring, vous voudrez probablement sauvegarder les donnees :

import csv
from datetime import datetime

def log_temperature_to_csv(sensor: DS18B20Sensor, filename: str = "temperatures.csv"):
    """Enregistre les temperatures dans un fichier CSV."""
    with open(filename, "a", newline="") as csvfile:
        writer = csv.writer(csvfile)
        timestamp = datetime.now().isoformat()

        for sensor_id, temp in sensor.read_all().items():
            if temp is not None:
                writer.writerow([timestamp, sensor_id, temp])

Bonnes Pratiques

Voici les recommandations essentielles pour reussir votre projet :

1. Utilisez toujours la resistance de pull-up

La resistance de 4.7 kohms entre Vcc et Data est obligatoire. Sans elle, la communication sera instable ou impossible. Pour des cables longs (plus de 5 metres), reduisez la valeur a 2.2 kohms.

2. Preferez le 3.3V au 5V

Bien que le DS18B20 supporte les deux tensions, utilisez le 3.3V pour proteger les GPIO du Raspberry Pi qui ne tolerent pas le 5V.

3. Verifiez toujours le CRC

Le fichier w1_slave contient un checksum CRC. Verifiez que la premiere ligne se termine par “YES” avant d’exploiter la temperature :

if lines[0].strip().endswith("YES"):
    # Lecture valide
    pass

4. Implementez une gestion d’erreurs robuste

Les capteurs peuvent occasionnellement renvoyer des valeurs aberrantes (85C souvent). Filtrez ces valeurs :

def is_valid_temperature(temp: float) -> bool:
    """Verifie si la temperature est dans une plage raisonnable."""
    return -55 <= temp <= 125 and temp != 85.0

5. Utilisez des identifiants uniques

Chaque capteur DS18B20 possede un identifiant unique. Stockez ces IDs pour identifier vos capteurs de maniere fiable :

SENSORS = {
    "28-00000a1b2c3d": "Salon",
    "28-00000e4f5g6h": "Chambre",
    "28-00000i7j8k9l": "Exterieur"
}

Pieges Courants

Evitez ces erreurs frequentes qui peuvent vous faire perdre du temps :

1. Oublier de redemarrer apres modification de config.txt

La modification de /boot/config.txt necessite un redemarrage complet. Un simple sudo modprobe ne suffit pas pour la premiere configuration.

2. Inverser les fils Vcc et GND

Cette erreur peut endommager definitivement votre capteur. Le DS18B20 chauffe rapidement si les fils sont inverses. Verifiez deux fois avant de brancher l’alimentation.

3. Utiliser un cable trop long sans adaptation

Pour des cables de plus de 10 metres, vous devrez :

• Reduire la resistance de pull-up (1-2 kohms)
• Utiliser un cable blinde
• Eventuellement reduire la resolution du capteur

4. Ignorer les lectures invalides

Ne faites jamais confiance aveuglement aux valeurs lues. Implementez toujours :

• Verification du CRC
• Filtrage des valeurs aberrantes (85C, -127C)
• Moyennage sur plusieurs lectures

def read_with_retry(sensor, max_retries: int = 3) -> Optional[float]:
    """Lit la temperature avec plusieurs tentatives."""
    for _ in range(max_retries):
        temp = sensor.read_temperature()
        if temp is not None and is_valid_temperature(temp):
            return temp
        time.sleep(0.5)
    return None

Conclusion

Dans cet article, nous avons vu comment connecter un capteur de temperature DS18B20 a votre Raspberry Pi et lire les donnees en Python. Vous avez appris :

• Le cablage correct du capteur avec la resistance de pull-up
• L’activation du protocole OneWire sur Raspbian
• La lecture des temperatures en Python avec gestion d’erreurs
• Les bonnes pratiques pour un projet fiable
• Les pieges courants a eviter

Le DS18B20 est un excellent choix pour debuter avec les capteurs sur Raspberry Pi grace a sa simplicite et sa fiabilite. Une fois ce projet maitrise, vous pourrez l’etendre avec :

• Une interface web pour visualiser les temperatures
• Des alertes par email quand la temperature depasse un seuil
• Un stockage dans une base de donnees (InfluxDB, SQLite)
• Des graphiques avec Grafana ou Matplotlib

Prochaines etapes

Pour aller plus loin avec votre projet de monitoring :

• Multi-capteurs : Connectez plusieurs DS18B20 sur le meme bus OneWire pour surveiller differentes zones
• Interface web : Utilisez Flask ou FastAPI pour creer un dashboard accessible a distance
• Alertes : Configurez des notifications Telegram ou email en cas de temperature anormale
• Historique : Stockez les donnees dans InfluxDB et visualisez avec Grafana
• Automatisation : Declenchez des actions (ventilateur, chauffage) en fonction des temperatures mesurees

N’hesitez pas a nous contacter si vous avez des questions ou si vous souhaitez partager vos projets !