Problème pour brancher 7 sondes DS18B20 sur le même bus

mjb · January 19, 2026, 11:11am

Bonjour,

J’ai acheté 7 sondes DS18B20 ( 2x2m. ; 2x3m. ; 3x10m = 40 mètres de câble au total). Je les ai branchées en parallèle avec une bonne lecture des t°.

J’essaye de les brancher en série, j’ai relevé leurs adresses et toutes, individuellement sont reconnues dans mon programme et fonctionnent bien.

Si je branche les 7 sondes sur la même broche, ça ne fonctionne pas.

je peux brancher les 4 plus courtes ensemble.
je peux brancher les 2 plus longues ensemble.

J’en ai déduit que le dysfonctionnement était lié à un problème de longueur de câble.

Mais pour un débutant comme moi, un problème de programmation n’est pas non pus à exclure.

Voici le programme que j’utilise, pouvez-vous me dire s’il est correct et si on peut l’améliorer ?

#include <OneWire.h>
#include <DallasTemperature.h>
#include <LiquidCrystal_I2C.h>   // inclure la bibliothèque I2C
LiquidCrystal_I2C lcd(0x27, 20, 4); // adresse i2c , nombre de colonnes, nombre de lignes de l'écran

#define ONE_WIRE_BUS 7  // Broche numérique 7 pour toutes les sondes

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

DeviceAddress thermometre_1 = {0x28, 0x74, 0xC9, 0x50, 0x00, 0x00, 0x00, 0x53};
DeviceAddress thermometre_2 = {0x28, 0xE1, 0x33, 0xBB, 0x00, 0x00, 0x00, 0xCF};
DeviceAddress thermometre_3 = {0x28, 0x4F, 0x3E, 0x39, 0x00, 0x00, 0x00, 0xB2};
DeviceAddress thermometre_4 = {0x28, 0x4F, 0x78, 0x38, 0x00, 0x00, 0x00, 0x48};
DeviceAddress thermometre_5 = {0x28, 0xFC, 0x00, 0x34, 0x00, 0x00, 0x00, 0x57};
DeviceAddress thermometre_6 = {0x28, 0x2B, 0x0D, 0x88, 0x00, 0x00, 0x00, 0x79};
DeviceAddress thermometre_7 = {0x28, 0x93, 0xE6, 0x83, 0x00, 0x00, 0x00, 0xE1};

int resolution = 12;  // nombre de bits... 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 = 0.0625 °C - 750 ms.



unsigned long tempsPrecedent = 0;
float intervalle = 1000;   // durée entre deux mesures en ms (à modifier si nécessaire).....je suppose qu'il faut définir une durée entre les prises de température de chaque sonde pour que l'interface puisse avoir le tempsde reconnaitre l'adresse de chaque sonde.

void setup() {
  sensors.begin();
  sensors.setResolution(thermometre_1, resolution);
  sensors.setResolution(thermometre_2, resolution);
  sensors.setResolution(thermometre_3, resolution);
  sensors.setResolution(thermometre_4, resolution);
  sensors.setResolution(thermometre_5, resolution);
  sensors.setResolution(thermometre_6, resolution);
  sensors.setResolution(thermometre_7, resolution);


  lcd.init();   // initialisation du LCD
  lcd.backlight();   // active le rétroéclairage
}

void loop() {
  unsigned long tempsCourant = millis();  // cette variable contient le nombre de millisecondes depuis que le programme courant a démarré.

  if (tempsCourant - tempsPrecedent >= intervalle) {
    tempsPrecedent = tempsCourant;

    sensors.requestTemperatures();
    float temperature_1 = sensors.getTempC(thermometre_1);  // obtenir la température 1 en degré
    float temperature_2 = sensors.getTempC(thermometre_2);  // obtenir la température 2 en degré
    float temperature_3 = sensors.getTempC(thermometre_3);
    float temperature_4 = sensors.getTempC(thermometre_4);
    float temperature_5 = sensors.getTempC(thermometre_5);
    float temperature_6 = sensors.getTempC(thermometre_6);
    float temperature_7 = sensors.getTempC(thermometre_7);

    lcd.setCursor(0, 0);  // mettre le curseur à la première colonne, première ligne
    lcd.print("T1=");
    lcd.print(temperature_1, 1);
    lcd.print((char)223);   // symbole °
    lcd.print("C");

    lcd.setCursor(0, 1);  // mettre le curseur à la première colonne, deuxième ligne
    lcd.print("T2=");
    lcd.print(temperature_2, 1);
    lcd.print((char)223);   // symbole °
    lcd.print("C");


    lcd.setCursor(0, 2);  // mettre le curseur à la première colonne, deuxième ligne
    lcd.print("T3=");
    lcd.print(temperature_3, 1);
    lcd.print((char)223);   // symbole °
    lcd.print("C");

    lcd.setCursor(0, 3);  // mettre le curseur à la première colonne, deuxième ligne
    lcd.print("T4=");
    lcd.print(temperature_4, 1);
    lcd.print((char)223);   // symbole °
    lcd.print("C");

    delay (5000);// j'attends 5 secondes
    lcd.clear (); // j'efface le message

    lcd.setCursor(0, 0);  // mettre le curseur à la première colonne, deuxième ligne
    lcd.print("T5=");
    lcd.print(temperature_5, 1);
    lcd.print((char)223);   // symbole °
    lcd.print("C");

    lcd.setCursor(0, 1);  // mettre le curseur à la première colonne, deuxième ligne
    lcd.print("T6=");
    lcd.print(temperature_6, 1);
    lcd.print((char)223);   // symbole °
    lcd.print("C");

    lcd.setCursor(0, 2);  // mettre le curseur à la première colonne, deuxième ligne
    lcd.print("T7=");
    lcd.print(temperature_7, 1);
    lcd.print((char)223);   // symbole °
    lcd.print("C");

    delay (5000);// j'attends 5 secondes
    lcd.clear (); // j'efface le message
  }
}

J’ai lu sur une discussion que l’on pouvait régler le problème des câblages trop longs avec un bus master dédié et des câblages blindés…

Dans mon cas, peut-être vaut-il mieux revenir au branchement parallèle ???

J-M-L · January 19, 2026, 11:39am

Le code semble correct même s'il peut être "amélioré" (tout est relatif).

Les DS18B20 tolèrent généralement jusqu’à quelques dizaines de mètres de câble, mais le cumul de longueurs importantes, surtout si certaines sondes font 10 mètres, crée des pertes de signal et des réflexions qui empêchent le bus de fonctionner correctement avec toutes les sondes connectées.

Pour votre problème de câblage, testez en parallèle en séparant les sondes par longueur, comme vous l’avez déjà constaté : les 4 plus courtes sur une broche et les 2 plus longues sur une autre. (il en manque une, elle fait quelle longueur ?)

claudius01 · January 19, 2026, 12:13pm

Bonjour,

Certes ... mais comment sont alimentés les capteurs ?

Avec une alimentation externe
Ou en mode alimentation parasite

NB: Pour faciliter les recherches futures, il serait bien de modifier le titre du fil de discussion avec DS18B20 à la place de DS68 ;-)

A suivre...

mjb · January 19, 2026, 2:34pm

J’ai modifié le titre, veuillez m’excuser pour l’erreur.

La 3ème sonde mesure 3m. mais c’est une sonde de rechange qui ne me servira pas dans un premier temps.

J’ai fait l’essai décrit plus haut avec les longueurs de câbles tels que je les ai achetés. Lorsque je ferai réellement l’installation, je pense que je réduirai leur taille d’environ 20%.

Je viens de réaliser un essai de branchement en parallèle en essayant programmer un autre bus en pin 8 mais je n’y parviens pas. Comment puis-je modifier mon programme pour y parvenir ?

Pour répondre à Claudius, les capteurs sont alimentés directement avec la carte arduino à priori, en mode “parasite” j’ai relevé une consommation totale de 28mA. pour les 7 capteurs + l’écran 20*4.

Je viens de réaliser un essai en reliant ma board directement avec un adaptateur secteur, je n’ai pas d’amélioration. Avec ce branchement externe, j’ai débranché le port USB. l’alimentation secteur de la board alimente la carte en pin gnd et 5v.

La pin 7 de la carte est reliée à la board, les pin A4 et A5 sont reliées au LCD, toutes les autres pin de la carte sont libres.

Je ne sais pas s’il y a une autre méthode de branchement pour éviter les parasites ???

J-M-L · January 19, 2026, 5:01pm

quand j'avais plusieurs capteurs et bus à gérer, je m'était fait une petite classe pour cacher tout cela.

Vous pouvez voir un exemple sur wokwi

(vous modifiez les t° d'un capteur en cliquant sur le capteur dans l'interface et en bougeant le slider de sa T°)

le code / schéma

/* ============================================
  code is placed under the MIT license
  Copyright (c) 2026 J-M-L
  For the Arduino Forum : https://forum.arduino.cc/u/j-m-l

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
  ===============================================
*/

#include <OneWire.h>
#include <DallasTemperature.h>

class OneWireBus {
  public:
    byte busPin;
    OneWire oneWire;
    DallasTemperature capteurs;
    byte nbDevices;
    DeviceAddress* deviceAddresses;
    float* dernieresTemperatures;

    OneWireBus(byte pin) : busPin(pin), oneWire(pin), capteurs(&oneWire), nbDevices(0),
      deviceAddresses(nullptr), dernieresTemperatures(nullptr) {}

    ~OneWireBus() {
      if (deviceAddresses != nullptr) delete[] deviceAddresses;
      if (dernieresTemperatures != nullptr) delete[] dernieresTemperatures;
    }

    void rechercheCapteurs() {
      byte adresse[8];
      oneWire.reset_search();
      nbDevices = 0;

      while (oneWire.search(adresse)) nbDevices++;

      deviceAddresses = new DeviceAddress[nbDevices];
      if (deviceAddresses == nullptr) {
        Serial.println("Erreur : impossible d'allouer le tableau des adresses !");
        while (true) yield();
      }

      dernieresTemperatures = new float[nbDevices];
      if (dernieresTemperatures == nullptr) {
        Serial.println("Erreur : impossible d'allouer le tableau des temperatures !");
        while (true) yield();
      }
      for (byte i = 0; i < nbDevices; i++) dernieresTemperatures[i] = NAN;

      oneWire.reset_search();
      byte idx = 0;
      Serial.print("Bus sur la broche ");
      Serial.println(busPin);
      while (oneWire.search(adresse)) {
        memcpy(deviceAddresses[idx], adresse, 8);
        Serial.print("Capteur ");
        Serial.print(idx);
        Serial.print(" adresse = {");
        for (byte j = 0; j < 8; j++) {
          Serial.print("0x");
          if (adresse[j] < 16) Serial.print("0");
          Serial.print(adresse[j], HEX);
          if (j < 7) Serial.print(",");
        }
        Serial.println("}");
        idx++;
      }
    }

    void begin() {
      capteurs.begin();
      rechercheCapteurs();
      capteurs.setWaitForConversion(false);
      capteurs.requestTemperatures();
    }

    bool mettreAJourTemperatures() {
      if (!capteurs.isConversionComplete()) return false; // conversion non terminée, on sort

      for (byte i = 0; i < nbDevices; i++) {
        float t = capteurs.getTempC(deviceAddresses[i]);
        if (!isnan(t) && (isnan(dernieresTemperatures[i]) || abs(t - dernieresTemperatures[i]) >= 0.1)) {
          Serial.print("Bus ");
          Serial.print(busPin);
          Serial.print(" Capteur ");
          Serial.print(i);
          Serial.print(" = ");
          Serial.print(t, 1);
          Serial.println(" °C");
          dernieresTemperatures[i] = t;
        }
      }
      capteurs.requestTemperatures(); // relance la prochaine conversion
      return true;
    }

    // Retourne un pointeur constant vers les dernières températures et leur nombre
    const float* obtenirDernieresTemperatures(byte &nombreCapteurs) const {
      nombreCapteurs = nbDevices;
      return dernieresTemperatures;
    }
};

// Création des bus
OneWireBus lesBus[] = {7, 8};
const byte nbBus = sizeof lesBus / sizeof * lesBus;

void setup() {
  Serial.begin(115200);
  for (auto& bus : lesBus) bus.begin();
}

void loop() {
  for (auto& bus : lesBus) bus.mettreAJourTemperatures();
}

mjb · January 20, 2026, 3:42pm

Merci JML pour ce lien, j’avais essayé de dessiner la configuration série sur wokwi et d’y associer mon programme mais ça ne fonctionnait pas. Je ne parvenais pas à attribuer les adresses de mes sondes aux sondes qui figuraient sur le dessin. Dans votre cas, je suppose que c’est OneWire qui attribue automatiquement des adresses qui ne sont pas réellement celles des sondes ???

J’ai téléversé ce programme sur mon installation réelle et ça fonctionne parfaitement.

J’ai réfléchi à la manière de commander le clignotement d’une led en fonction de la température de la sonde 1 par exemple et je n’y suis pas parvenu.

Parallèlement, j’ai coupé mes fils aux dimensions qu’ils auront réellement lorsque l’installation sera réalisée et, miracle , ils fonctionnent désormais tous en série sur la même broche.

Comme je me suis formé avec mon programme, j’ai réussi à configurer facilement le déclenchement d’une led à partir d’une température définie.

J’espère pouvoir y ajouter les buzzer dès que j’aurai reçu les transistors et finaliser tout cela dans les jours qui viennent.

je vous tiens au courant.

J-M-L · January 20, 2026, 4:23pm

wokwi utilise une partie de l'adresse que l'on met dans l'attribut deviceID du module dans le fichier descriptif diagram.json pour générer l'ID final dynamiquement.

C'est pour cela que mon code scan les bus pour trouver les adresses des composants avant de le stocker.
En dehors de wokwi, vous pourriez modifier la classe pour que l'on ait un tableau statique d'adresses donné au constructeur.

OK - tant mieux alors !

mjb · January 22, 2026, 11:29am

Bonjour, et merci JML pour ces précisions.

Je rencontre de nouveau des problèmes que je ne parviens pas à résoudre.

J’ai avancé sur mon programme :

6 sondes en série, ……………………..ok
3 led qui clignotent lorsque les sondes 1,5 et 6 dépassent un seuil donné. ……..ok
4 deux buzzer reliés à un transistor lorsque la sonde 1 ou 5 ou 6 dépasse le seuil donné…….ok
J’ai eu beaucoup de mal à configurer un bouton qui durant un temps programmé, stop le son des buzzer…. j’y suis parvenu partiellement.

Voici les problèmes que je rencontre :

- le bouton n'est pas très réactif (2s.) mais c'est acceptable

- le bouton bloque la led alors que je voudrais qu'elle reste allumée.

- le bouton bloque l'écriture des températures sur le LCD alors que je voudrais qu'elles s'affichent normalement.

et un autre problème non lié au bouton, Je ne sais pas comment éviter le beep au démarrage, (3secondes) - (on risque de l'entendre lors des micro-coupures).

Cela m’arrangerait vraiment si quelqu’un pouvait améliorer mon programme pour résoudre les problèmes liés au bouton.

/**
   Mesures de températures avec 6 capteurs DS18B20 sur un même bus 1-Wire
  - Je ne parviens pas à faire fonctinner ce programme sur wokwi certainement parceque les sondes n'ont pas d'adresse
  - c'est le GPIO 7 qui est choisi avec les sondes en série sur une seule résistance.
  - la led 1 (HP) est en 11, led 5 (PC) en 12, led 6 (ECS) en 13, les buzzer en 9, le bouton en 3.
*/

#include <OneWire.h>
#include <DallasTemperature.h>
#include <LiquidCrystal_I2C.h>   // inclure la bibliothèque I2C
LiquidCrystal_I2C lcd(0x27, 20, 4); // adresse i2c , nombre de colonnes, nombre de lignes de l'écran

#define ONE_WIRE_BUS 7                                    // Broche numérique 7 pour toutes les sondes
#define led_HP 11
#define led_PC 12
#define led_ECS 13
#define buzz 9
#define btn 3

bool etatbtn ;

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);

DeviceAddress thermometre_1 = {0x28, 0x74, 0xC9, 0x50, 0x00, 0x00, 0x00, 0x53};   // 1 - Eau Haut Poêle
DeviceAddress thermometre_2 = {0x28, 0xE1, 0x33, 0xBB, 0x00, 0x00, 0x00, 0xCF};   // 2 - Eau Bas Poêle
DeviceAddress thermometre_3 = {0x28, 0x93, 0xE6, 0x83, 0x00, 0x00, 0x00, 0xE1};   // 3 - Haut Cuve Poêle
DeviceAddress thermometre_4 = {0x28, 0x2B, 0x0D, 0x88, 0x00, 0x00, 0x00, 0x79};   // 4 - Bas Cuve Poêle
DeviceAddress thermometre_5 = {0x28, 0xFC, 0x00, 0x34, 0x00, 0x00, 0x00, 0x57};   // 5 - T° PC
DeviceAddress thermometre_6 = {0x28, 0x4F, 0x78, 0x38, 0x00, 0x00, 0x00, 0x48};   // 6 - T° ECS

int resolution = 12;  // nombre de bits... 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 = 0.0625 °C - 750 ms.

//int deg_HP = 91 ;                                       // Haut Poêle 91° c'est la température de l'eau du haut du poêle bouilleur à ne pas dépasser
//int deg_pc = 48 ;                                       // Plancher Chauffant, temp max autorisée 50°
//int deg_ECS = 50 ;                                      // Eau Chaude Sanitaire, temp max autorisée
int deg_essai = 24;                                       // 24° pour faire des essais dans la maison.


//unsigned long tempsPrecedent = 0;
//float intervalle = 1000;   // durée entre deux mesures en ms (à modifier si nécessaire).....je suppose qu'il faut définir une durée entre les prises de température de chaque sonde pour que l'interface puisse avoir le tempsde reconnaitre l'adresse de chaque sonde.

void setup() {
  sensors.begin();
  sensors.setResolution(thermometre_1, resolution);
  sensors.setResolution(thermometre_2, resolution);
  sensors.setResolution(thermometre_3, resolution);
  sensors.setResolution(thermometre_4, resolution);
  sensors.setResolution(thermometre_5, resolution);
  sensors.setResolution(thermometre_6, resolution);

  lcd.init();
  lcd.backlight();   // active le rétroéclairage

  pinMode (led_HP, OUTPUT);
  pinMode (led_PC, OUTPUT);
  pinMode (led_ECS, OUTPUT);
  pinMode (buzz, OUTPUT);
  pinMode (btn, INPUT_PULLUP);

}

void loop() {
  // unsigned long tempsCourant = millis();  // cette variable contient le nombre de millisecondes depuis que le programme courant a démarré.

  // if (tempsCourant - tempsPrecedent >= intervalle) {
  //   tempsPrecedent = tempsCourant;

  etatbtn = digitalRead(btn) ;

  sensors.requestTemperatures();
  float temperature_1 = sensors.getTempC(thermometre_1);  // obtenir la température 1 en degré
  float temperature_2 = sensors.getTempC(thermometre_2);  // obtenir la température 2 en degré
  float temperature_3 = sensors.getTempC(thermometre_3);
  float temperature_4 = sensors.getTempC(thermometre_4);
  float temperature_5 = sensors.getTempC(thermometre_5);
  float temperature_6 = sensors.getTempC(thermometre_6);

  //.......................................................

  if (temperature_1 >= deg_essai)                   // si la température de la sonde 1 est supérieure à la température fixée pour les essais
  {
    digitalWrite (led_HP, 1) ;                      // la pin 11 va envoyer 5V.
    digitalWrite  (buzz, 1);                        // la pin 9 va envoyer 5V.
    delay (1000);                                   // durant 1 seconde en intermitance
    digitalWrite (led_HP, 0) ;
    digitalWrite(buzz, 0);
  }
  else                                              // sinon
  {
    digitalWrite (led_HP, 0) ;                      // la pin 11 n'envoie rien.
    digitalWrite (buzz, 0);                        // la pin 9 n'envoie rien
  }

  //........................................................

  if (temperature_5 >= deg_essai)                    // si la température de la sonde 5 est supérieure à la température fixée pour les essais
  {
    digitalWrite (led_PC, 1) ;                       // la pin 12 va envoyer 5V.
    digitalWrite  (buzz, 1);                         // la pin 9 va envoyer 5V
    delay (1000);                                    // durant 1 seconde en intermitance
    digitalWrite (led_PC, 0) ;
    digitalWrite(buzz, 0);
  }
  else                                               // sinon
  {
    digitalWrite (led_PC, 0) ;                       // rien
    digitalWrite(buzz, 0);
  }
  //............................................................

  if (temperature_6 >= deg_essai)                    // si la température de la sonde 6 est supérieure à la température fixée pour les essais
  {
    digitalWrite (led_ECS, 1) ;                      // la pin 13  va envoyer 5V.
    digitalWrite  (buzz, 1);                         // la pin 9 va envoyer 5V
    delay (1000);                                    // durant 1 seconde en intermitance
    digitalWrite (led_ECS, 0) ;
    digitalWrite(buzz, 0);
  }
  else                                               // sinon
  {
    digitalWrite (led_ECS, 0) ;                      // rien
    digitalWrite(buzz, 0);
  }
  //.......................................................

  lcd.setCursor(0, 0);  // mettre le curseur à la première colonne, première ligne
  lcd.print("T1=");
  lcd.print(temperature_1, 1);
  lcd.print((char)223);   // symbole °
  lcd.print("C");

  lcd.setCursor(0, 1);  // mettre le curseur à la première colonne, deuxième ligne
  lcd.print("T2=");
  lcd.print(temperature_2, 1);
  lcd.print((char)223);   // symbole °
  lcd.print("C");

  lcd.setCursor(0, 2);  // mettre le curseur à la première colonne, deuxième ligne
  lcd.print("T3=");
  lcd.print(temperature_3, 1);
  lcd.print((char)223);   // symbole °
  lcd.print("C");

  lcd.setCursor(0, 3);  // mettre le curseur à la première colonne, deuxième ligne
  lcd.print("T4=");
  lcd.print(temperature_4, 1);
  lcd.print((char)223);   // symbole °
  lcd.print("C");

  lcd.setCursor(12, 0);  // mettre le curseur à la première colonne, deuxième ligne
  lcd.print("T5=");
  lcd.print(temperature_5, 1);
  lcd.print((char)223);   // symbole °
  lcd.print("C");

  lcd.setCursor(12, 1);  // mettre le curseur à la première colonne, deuxième ligne
  lcd.print("T6=");
  lcd.print(temperature_6, 1);
  lcd.print((char)223);   // symbole °
  lcd.print("C");

  lcd.setCursor(12, 3);  // mettre le curseur à la première colonne, deuxième ligne
  lcd.print("Etat = ");
  lcd.print(etatbtn);

  //....................................................... condition placée en dernier pour lire l'affichage de l'étatbtn avant que le délai soit activé.

  if (etatbtn == 0)
  {
    digitalWrite(buzz, 0);
    delay (10000);                                               // l'état du  bouton reste fermé (0) durant 10 secondes
  }

  //delay (1000);
}
//}

fdufnews · January 22, 2026, 12:24pm

Cela fait plusieurs fois que je vois ce titre sans entrer dans le fil de discussion mais à chaque fois il me pique les yeux.
En électricité ou en électronique les mots série et parallèle on un sens bien défini

Ensuite, lorsqu'on parle de bus on a des topologies différentes

Donc, dans ton cas, les capteurs sont en parallèle sur un bus unique. Ce qui est d'ailleurs la topologie recommandée pour utiliser ces capteurs. Ceci dit le bus 1-Wire est mal adapté aux longues distances car on ne peut pas adapter la ligne correctement.

La topologie en étoile, c'est-à-dire les capteurs chacun sur un câble, lesquels se réunissent au niveau du circuit de commande peut fonctionner sur des courtes distances mais est plus sensible aux perturbations du fait que l'on reçoit des réflexions multiples venant des différentes branches.

Une note d'application pour les plus curieux

J-M-L · January 22, 2026, 1:07pm

Votre code est plein de délais... C'est incompatible avec une application réactive.

Il faut recoder tout cela en non bloquant... On fait cela souvent en recourant à la programmation par machine à états (cf mon tuto éventuellement)

si j'ai un peu de temps dans l'après midi et que wokwi n'est pas trop chargé je jetterai un oeil.

mjb · January 22, 2026, 4:29pm

Oui, effectivement, écrire “en série” est un abus de langage. J’ai modifié le titre.

JML, Votre Tuto intéressant, mais dense, je crains de ne pas pouvoir tout intégrer rapidement mais je vais y travailler. Il me permettra de comprendre vos modifications si vous pouvez prendre le temps de m’aider sur cette difficulté là.

J-M-L · January 22, 2026, 5:28pm

voilà un exemple à étudier, finalement il n'y avait pas vraiment besoin de machine à état.

Pour votre installation, il faudra télécharger 2 bibliothèques=

hd44780 ➜ GitHub - duinoWitchery/hd44780: Extensible hd44780 LCD library
Toggle ➜ GitHub - Dlloydev/Toggle: Arduino button debounce library for various switch types, port expanders and other 8-bit data sources. Fast and robust debounce algorithm.

la première est la bibliothèque la plus efficace pour les LCD
la seconde c'est une gestion des boutons.

Il faudra aussi remplacer les adresses dans le code par les votres

// Pour wokwi on a ces adresses
Capteur lesCapteurs[] = {
  {"EHP", {0x10, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x9B}, 0.0, true}, // 0 - Eau Haut Poêle
  {"EBP", {0x10, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x3B}, 0.0, true}, // 1 - Eau Bas Poêle
  {"HCP", {0x10, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x5B}, 0.0, true}, // 2 - Haut Cuve Poêle
  {"BCP", {0x10, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x62}, 0.0, true}, // 3 - Bas Cuve Poêle
  {"PC ",  {0x10, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x02}, 0.0, true}, // 4 - PC
  {"ECS", {0x10, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0xA2}, 0.0, true}, // 5 - ECS
};

conservez les autres éléments de la structure

le nom du capteur c'est 3 lettres - je compte la dessus pour l'affichage sur le LCD - qui se présentera comme suit :

comme dans l'autre wokwi, vous pouvez changer les valeurs d'une sonde en cliquant dessus et en faisant bouger son curseur de T°.

N'hésitez pas si vous avez des questions.

les détails

/* ============================================
  code is placed under the MIT license
  Copyright (c) 2026 J-M-L
  For the Arduino Forum : https://forum.arduino.cc/u/j-m-l

  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:

  The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.

  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  THE SOFTWARE.
  ===============================================
*/



#include <Wire.h>
#include <hd44780.h>                        // main hd44780 header
#include <hd44780ioClass/hd44780_I2Cexp.h>  // i2c expander i/o class header
#include <Toggle.h>                         // https://github.com/Dlloydev/Toggle

#include <OneWire.h>
#include <DallasTemperature.h>

const uint8_t nbCols = 20;
const uint8_t nbRows = 4;
hd44780_I2Cexp lcd;

const byte pinLedHP = 11;
const byte pinLedPC = 12;
const byte pinLedECS = 13;
const byte pinBuzzer = 9;
const byte pinBoutonSilence = 3;
const byte pinLedSilence = 2;

Toggle boutonSilence(pinBoutonSilence);

const byte pinBus = 7;
OneWire busOneWire(pinBus);
DallasTemperature capteurs(&busOneWire);
const uint8_t resolution = 9; // 9, 10, 11 ou 12 bits
uint32_t derniereLecture = 0;


struct Capteur {
  const char * nom;
  DeviceAddress adresse;
  float derniereTemperature;
  bool besoinAffichage;
};

// Pour wokwi on a ces adresses
Capteur lesCapteurs[] = {
  {"EHP", {0x10, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x9B}, 0.0, true}, // 0 - Eau Haut Poêle
  {"EBP", {0x10, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0x3B}, 0.0, true}, // 1 - Eau Bas Poêle
  {"HCP", {0x10, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0x5B}, 0.0, true}, // 2 - Haut Cuve Poêle
  {"BCP", {0x10, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x62}, 0.0, true}, // 3 - Bas Cuve Poêle
  {"PC ",  {0x10, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0x02}, 0.0, true}, // 4 - PC
  {"ECS", {0x10, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0xA2}, 0.0, true}, // 5 - ECS
};

constexpr byte nbCapteursTemperature = sizeof lesCapteurs / sizeof * lesCapteurs;

const uint32_t demiPeriodeClignotement = 250;

const float seuilHP = 50.0;
const byte indiceHP = 0;
const unsigned int frequenceBuzzHP = 800; // Hz

const float seuilPC = 50.0;
const byte indicePC = 4;
const unsigned int frequenceBuzzPC = 1000; // Hz

const float seuilECS = 50.0;
const uint8_t indiceECS = 5;
const unsigned int frequenceBuzzECS = 1200; // Hz

void animations() {
  static bool modeSilence = false;
  static uint32_t debutModeSilence = 0;
  static const uint32_t dureeModeSilence = 10000ul; // 10 secondes en ms

  boutonSilence.poll();
  if (boutonSilence.onPress()) {
    modeSilence = not modeSilence;
    digitalWrite(pinLedSilence, modeSilence ? HIGH : LOW);
    if (modeSilence) debutModeSilence = millis();
  }

  if (modeSilence && millis() - debutModeSilence >= dureeModeSilence) {
    modeSilence = false;
    digitalWrite(pinLedSilence, LOW);
  }

  if (lesCapteurs[indiceHP].derniereTemperature >= seuilHP) {
    static uint32_t lastBlink;
    if (millis() - lastBlink >= demiPeriodeClignotement) {
      digitalWrite(pinLedHP, digitalRead(pinLedHP) == HIGH ? LOW : HIGH);
      if (not modeSilence) tone(pinBuzzer, frequenceBuzzHP, demiPeriodeClignotement / 4);
      lastBlink = millis();
    }
  } else {
    digitalWrite(pinLedHP, LOW);
    noTone(pinBuzzer);
  }

  if (lesCapteurs[indicePC].derniereTemperature >= seuilPC) {
    static uint32_t lastBlink;
    if (millis() - lastBlink >= demiPeriodeClignotement) {
      digitalWrite(pinLedPC, digitalRead(pinLedPC) == HIGH ? LOW : HIGH);
      if (not modeSilence) tone(pinBuzzer, frequenceBuzzPC, demiPeriodeClignotement / 4);
      lastBlink = millis();
    }
  } else {
    digitalWrite(pinLedPC, LOW);
    noTone(pinBuzzer);
  }

  if (lesCapteurs[indiceECS].derniereTemperature >= seuilECS) {
    static uint32_t lastBlink;
    if (millis() - lastBlink >= demiPeriodeClignotement) {
      digitalWrite(pinLedECS, digitalRead(pinLedECS) == HIGH ? LOW : HIGH);
      if (not modeSilence) tone(pinBuzzer, frequenceBuzzECS, demiPeriodeClignotement / 4);
      lastBlink = millis();
    }
  } else {
    digitalWrite(pinLedECS, LOW);
    noTone(pinBuzzer);
  }
}

void rechercheCapteurs() {
  DeviceAddress adresse;
  busOneWire.reset_search();
  byte idx = 0;
  while (busOneWire.search(adresse)) {
    Serial.print("Capteur ");
    Serial.print(idx);
    Serial.print(" adresse = {");
    for (byte j = 0; j < sizeof adresse; j++) {
      Serial.print("0x");
      if (adresse[j] < 16) Serial.print("0");
      Serial.print(adresse[j], HEX);
      if (j < (sizeof adresse) - 1) Serial.print(", ");
    }
    Serial.println("}");
    idx++;
  }
}


bool mettreAJourTemperatures() {
  if (millis() - derniereLecture <= capteurs.millisToWaitForConversion(resolution)) return false; // conversion non terminée, on sort
  bool modif = false;
  for (byte i = 0; i < nbCapteursTemperature; i++) {
    float t = capteurs.getTempC(lesCapteurs[i].adresse);
    if (!isnan(t) && (isnan(lesCapteurs[i].derniereTemperature) || abs(t - lesCapteurs[i].derniereTemperature) >= 0.1)) {
      lesCapteurs[i].derniereTemperature = t;
      lesCapteurs[i].besoinAffichage = true;
      modif = true;
    }
  }
  capteurs.requestTemperatures(); // relance la prochaine conversion
  derniereLecture = millis();
  return modif;
}



void setup() {
  pinMode (pinLedHP, OUTPUT);       digitalWrite(pinLedHP, LOW);
  pinMode (pinLedPC, OUTPUT);       digitalWrite(pinLedPC, LOW);
  pinMode (pinLedECS, OUTPUT);      digitalWrite(pinLedECS, LOW);
  pinMode (pinBuzzer, OUTPUT);      digitalWrite(pinBuzzer, LOW);
  pinMode (pinLedSilence, OUTPUT);  digitalWrite(pinLedSilence, LOW);
  boutonSilence.begin(pinBoutonSilence);

  Serial.begin(115200);

  int result = lcd.begin(nbCols, nbRows);
  if (result) {
    Serial.print("LCD initialization failed: ");
    Serial.println(result);
    hd44780::fatalError(result);
  }

  lcd.setCursor(0, 0);
  lcd.print("GESTION TEMPERATURE");

  for (uint8_t n = 0; n < nbCapteursTemperature; n++) {
    lcd.setCursor((n < nbRows - 1) ? 0 : nbCols / 2, n % (nbRows - 1) + 1);
    lcd.print(lesCapteurs[n].nom);
    lcd.write(':');
  }

  capteurs.begin();
  // rechercheCapteurs();

  capteurs.setResolution(resolution);
  capteurs.setWaitForConversion(false);
  capteurs.requestTemperatures();
  derniereLecture = millis();

  Serial.println("PRET");
}

void loop() {
  if (mettreAJourTemperatures()) { // retourne vrai si au moins une t° a été mise à jour

    for (byte n = 0; n < nbCapteursTemperature; n++) {
      if (lesCapteurs[n].besoinAffichage) {
        uint8_t col = (n < nbRows - 1) ? 4 : nbCols / 2 + 4;
        uint8_t ligne = n % (nbRows - 1) + 1;
        lcd.setCursor(col, ligne );
        lcd.print("      "); // on efface l'ancienne valeur
        lcd.setCursor(col, ligne );
        lcd.print(lesCapteurs[n].derniereTemperature, 1);
        lesCapteurs[n].besoinAffichage = false;
      }
    }
  }
  animations();
}

{
  "version": 1,
  "author": "Copyright (c) 2026 J-M-L",
  "editor": "wokwi",
  "parts": [
    { "type": "wokwi-arduino-uno", "id": "uno", "top": 221.4, "left": -10.2, "attrs": {} },
    {
      "type": "board-ds18b20",
      "id": "temp4",
      "top": -180.48,
      "left": 65.47,
      "rotate": 270,
      "attrs": { "deviceID": "111111111111" }
    },
    {
      "type": "board-ds18b20",
      "id": "temp5",
      "top": -142.08,
      "left": 65.47,
      "rotate": 270,
      "attrs": { "deviceID": "222222222222" }
    },
    {
      "type": "board-ds18b20",
      "id": "temp6",
      "top": -103.68,
      "left": 65.47,
      "rotate": 270,
      "attrs": { "deviceID": "333333333333" }
    },
    {
      "type": "board-ds18b20",
      "id": "temp7",
      "top": -65.28,
      "left": 65.47,
      "rotate": 270,
      "attrs": { "deviceID": "444444444444" }
    },
    {
      "type": "board-ds18b20",
      "id": "temp8",
      "top": -26.88,
      "left": 65.47,
      "rotate": 270,
      "attrs": { "deviceID": "555555555555" }
    },
    {
      "type": "board-ds18b20",
      "id": "temp9",
      "top": 11.52,
      "left": 65.47,
      "rotate": 270,
      "attrs": { "deviceID": "666666666666" }
    },
    {
      "type": "wokwi-resistor",
      "id": "r1",
      "top": 128.75,
      "left": 76.8,
      "attrs": { "value": "4700" }
    },
    { "type": "wokwi-gnd", "id": "gnd1", "top": 57.6, "left": 133.8, "attrs": {} },
    { "type": "wokwi-vcc", "id": "vcc2", "top": -268.04, "left": 124.8, "attrs": {} },
    { "type": "wokwi-gnd", "id": "gnd3", "top": 436.8, "left": 157.8, "attrs": {} },
    { "type": "wokwi-vcc", "id": "vcc4", "top": 96.76, "left": 28.8, "attrs": {} },
    { "type": "wokwi-vcc", "id": "vcc5", "top": 279.16, "left": -57.6, "attrs": {} },
    {
      "type": "wokwi-lcd2004",
      "id": "lcd1",
      "top": 438.4,
      "left": 322.4,
      "attrs": { "pins": "i2c" }
    },
    {
      "type": "wokwi-text",
      "id": "txt1",
      "top": -163.2,
      "left": -76.8,
      "attrs": { "text": "Eau Haut Poêle" }
    },
    {
      "type": "wokwi-text",
      "id": "txt2",
      "top": -124.8,
      "left": -76.8,
      "attrs": { "text": "Eau Bas Poêle" }
    },
    {
      "type": "wokwi-text",
      "id": "txt3",
      "top": -86.4,
      "left": -76.8,
      "attrs": { "text": "Haut Cuve Poêle" }
    },
    {
      "type": "wokwi-text",
      "id": "txt4",
      "top": -48,
      "left": -76.8,
      "attrs": { "text": "Bas Cuve Poêle" }
    },
    { "type": "wokwi-text", "id": "txt5", "top": -9.6, "left": 0, "attrs": { "text": "PC" } },
    { "type": "wokwi-text", "id": "txt6", "top": 28.8, "left": -9.6, "attrs": { "text": "ECS" } },
    {
      "type": "wokwi-led",
      "id": "led1",
      "top": -29.6,
      "left": 203,
      "rotate": 270,
      "attrs": { "color": "red" }
    },
    {
      "type": "wokwi-resistor",
      "id": "r2",
      "top": -15.25,
      "left": 307.2,
      "attrs": { "value": "220" }
    },
    {
      "type": "wokwi-led",
      "id": "led2",
      "top": 8.8,
      "left": 203,
      "rotate": 270,
      "attrs": { "color": "red" }
    },
    {
      "type": "wokwi-resistor",
      "id": "r3",
      "top": 23.15,
      "left": 307.2,
      "attrs": { "value": "220" }
    },
    {
      "type": "wokwi-led",
      "id": "led3",
      "top": -173.6,
      "left": 203,
      "rotate": 270,
      "attrs": { "color": "red" }
    },
    {
      "type": "wokwi-resistor",
      "id": "r4",
      "top": -159.25,
      "left": 307.2,
      "attrs": { "value": "220" }
    },
    { "type": "wokwi-gnd", "id": "gnd2", "top": 57.6, "left": 229.8, "attrs": {} },
    {
      "type": "wokwi-buzzer",
      "id": "bz1",
      "top": 111.2,
      "left": -80,
      "rotate": 270,
      "attrs": { "volume": "0.5" }
    },
    {
      "type": "wokwi-pushbutton",
      "id": "btn1",
      "top": 307.6,
      "left": 292,
      "rotate": 90,
      "attrs": { "color": "green", "xray": "1" }
    },
    {
      "type": "wokwi-text",
      "id": "txt7",
      "top": 316.8,
      "left": 364.8,
      "attrs": { "text": "SILENCE" }
    },
    {
      "type": "wokwi-led",
      "id": "led4",
      "top": 236.4,
      "left": 272.6,
      "attrs": { "color": "yellow" }
    },
    {
      "type": "wokwi-resistor",
      "id": "r5",
      "top": 329.8,
      "left": 258.35,
      "rotate": 270,
      "attrs": { "value": "220" }
    }
  ],
  "connections": [
    [ "uno:7", "temp4:DQ", "green", [ "v0" ] ],
    [ "uno:7", "temp5:DQ", "green", [ "v0" ] ],
    [ "uno:7", "temp6:DQ", "green", [ "v0" ] ],
    [ "uno:7", "temp7:DQ", "green", [ "v0" ] ],
    [ "uno:7", "temp8:DQ", "green", [ "v0" ] ],
    [ "uno:7", "temp9:DQ", "green", [ "v0" ] ],
    [ "uno:7", "r1:2", "green", [ "v0" ] ],
    [ "temp6:VCC", "temp5:VCC", "red", [ "h28.8", "v-48" ] ],
    [ "temp5:VCC", "temp4:VCC", "red", [ "h28.8", "v-38.4" ] ],
    [ "temp7:VCC", "temp6:VCC", "red", [ "h28.8", "v-48" ] ],
    [ "temp4:GND", "gnd1:GND", "black", [ "h0" ] ],
    [ "temp5:GND", "gnd1:GND", "black", [ "h0" ] ],
    [ "temp6:GND", "gnd1:GND", "black", [ "h0" ] ],
    [ "temp7:GND", "gnd1:GND", "black", [ "h0" ] ],
    [ "temp4:VCC", "vcc2:VCC", "red", [ "h0" ] ],
    [ "uno:GND.3", "gnd3:GND", "black", [ "v0" ] ],
    [ "vcc4:VCC", "r1:1", "red", [ "v0" ] ],
    [ "uno:5V", "vcc5:VCC", "red", [ "v57.5", "h-197.8" ] ],
    [ "temp7:GND", "temp8:GND", "black", [ "h38.4", "v38.4" ] ],
    [ "temp8:GND", "temp9:GND", "black", [ "h38.4", "v38.4" ] ],
    [ "temp7:VCC", "temp8:VCC", "red", [ "h28.8", "v38.4" ] ],
    [ "temp8:VCC", "temp9:VCC", "red", [ "h28.8", "v38.4" ] ],
    [ "uno:A5", "lcd1:SCL", "green", [ "v0" ] ],
    [ "uno:A4", "lcd1:SDA", "green", [ "v0" ] ],
    [ "uno:GND.3", "lcd1:GND", "black", [ "v0" ] ],
    [ "uno:5V", "lcd1:VCC", "red", [ "v0" ] ],
    [ "led1:A", "r2:1", "green", [ "v0" ] ],
    [ "led2:A", "r3:1", "green", [ "v0" ] ],
    [ "led3:A", "r4:1", "green", [ "v0" ] ],
    [ "gnd2:GND", "led2:C", "black", [ "v0" ] ],
    [ "led2:C", "led1:C", "black", [ "h28.8", "v-38.8", "h-9.6" ] ],
    [ "led1:C", "led3:C", "black", [ "h28.8", "v-144" ] ],
    [ "uno:11", "r4:2", "green", [ "v-57.6", "h375", "v-326.4" ] ],
    [ "uno:12", "r2:2", "green", [ "v-48", "h365.3", "v-192" ] ],
    [ "uno:13", "r3:2", "green", [ "v-38.4", "h355.6", "v-163.2" ] ],
    [ "uno:3", "btn1:1.l", "green", [ "v-28.8", "h167.2" ] ],
    [ "uno:GND.3", "btn1:2.r", "black", [ "v28.7", "h148.2" ] ],
    [ "uno:GND.1", "bz1:1", "black", [ "v0" ] ],
    [ "uno:9", "bz1:2", "green", [ "v0" ] ],
    [ "r5:2", "led4:C", "green", [ "h0" ] ],
    [ "uno:2", "led4:A", "green", [ "v-19.2", "h100.1", "v57.6" ] ],
    [ "uno:GND.3", "r5:1", "black", [ "v28.7", "h119.2" ] ]
  ],
  "dependencies": {}
}

mjb · January 24, 2026, 3:46pm

Un grand merci pour ce travail, je vais l’étudier.

Je disais que votre tuto sur la machine à état était dense car ce jour là, j’avais un peu calé sur le lien explicatif de wikipedia. Par la suite, j’ai poursuivi et ce tuto est vraiment agréable à suivre. Comme ma planche à essais est occupée, je l’ai suivi avec wokwi et ça fonctionne bien. Parvenu à l’exercice trois, j’ai du m’initier à la “fonction milis”… tout cela est encoure un peu frais et plus ou moins acquis.

je vous tiens au courant et encore merci pour tous ces enseignements.

dfgh · January 24, 2026, 5:57pm

Je me disais que je connaissais cette tête.

Bonjour Briou

Amitiés, Dominique

Nota: c’est 6 ou 7 sondes dont tu as besoin?

Dans le titre, c’est 7

Dans le programme, c’est 6 à l’affichage.

mjb · January 25, 2026, 10:37am

Et pour ma part, je reconnais cette fleur qui sent bon l’entraide et qui m’a apporté un soutien précieux, il y a 8 ans pour faire fonctionner 5 moteurs pas à pas sur Arduino dans un projet de spectacle… amitiés réciproques…

dans un premier temps, ce sont 6 sondes DS18 dont j’ai besoin sur un même bus, j’ai débuté le projet avec 7 sondes et je me suis aperçu qu’il y en avait une de trop.

Par contre, dans un deuxième temps, je souhaite rajouter deux thermocouples mais pour l’insttant, j’essaye de finaliser ce projet (6 sondes).

dfgh · January 25, 2026, 11:13am

pour l’instant, je te laisse avec @JML , tu ne pouvais pas mieux tomber.

mjb · January 25, 2026, 5:33pm

Aujourd’hui, j’ai téléversé le programme de JML sur mon équipement, …tout fonctionne sauf le son du buzzer qui, sur les sondes HP et PC fait des “tic, tic, tic” lorsqu’on approche l’oreille… même en changeant la fréquence.

Paradoxalement sur la sonde ECS, ce même buzzer fonctionne. J’ai cherché, sur le programme d’où venait ce dysfonctionnement, je n’ai rien trouvé. Peut-on le configurer en “mode High” - clignotant (la broche envoie 5V par intermittence) sans choix de fréquence ?

j’ai ouvert, avec le lien donné plus haut, le programme wokwi…, le LCD affiche toutes les t° à - 127.0 et avec le curseur, on ne peut rien changer.

- Dans la réalité, les t° s’affichent bien sur mon LCD, mais la lecture est un peu instable (les chiffres changent en permanence). Peut-être qu’une fréquence moins élevée des résultats stabiliserait la lecture ?

- J’ai étudié le programme, je commençait à m’approprier le précédent et celui-ci me paraît plus complexe, j’espère que je vais pouvoir mieux le comprendre avec le temps. il y a plusieurs lignes dont je ne comprends pas le sens.

* notamment en ce qui concerne “void recherche Capteurs” est-elle indispensable ?

* Ce qui me gène le plus, c'est que j'ai perdu la main sur l’écriture du LCD qui se réalise désormais automatiquement. J’ai essayé de reprendre la main sur cette écriture mais les modifications que j’ai apportées au programme initial ne me satisfont pas… à voir.

Bref, j’ai enfin un bouton capable d’arrêter le son du buzzer sans mettre en pause le programme, des led qui clignotent sans ralentir et des sondes qui me restituent la température hyper vite.

Encore merci JML pour ce beau travail.

J-M-L · January 25, 2026, 5:38pm

c'est parce que j'ai mis un piezo que j'utilise avec la fonction tone() sous wokwi. Je pense que vous avez un buzzer actif, on met la sortie à HIGH quand on veut l'activer et à LOW quand on veut l'éteindre, on ne peut pas régler la fréquence. ➜ il faut adapter à votre équipement et faire un digitalWrite(pinBuzzer, HIGH); quand vous voulez l'activer et LOW quand il faut l'éteindre et ne plus utiliser tone()

non c'est juste pour trouver les adresses de vos équipements; Une fois que vous les avez et que vous les avez câblé en dur, ça devrait aller.

il se peut que quand on relance wokwi les adresses générées ne soient plus les mêmes peut-être...

mjb · January 25, 2026, 8:18pm

J’utilise un Capteur d'alarme à Buzzer piézo Actif [https://www.amazon.fr/dp/B07ZYVH6XM?j’ai écrit pour le capteur HP :

  if (lesCapteurs[indiceHP].derniereTemperature >= seuilHP) {

    static uint32_t lastBlink;

    if (millis() - lastBlink >= demiPeriodeClignotement) {

      digitalWrite(pinLedHP, digitalRead(pinLedHP) == HIGH ? LOW : HIGH);

      if (not modeSilence) digitalWrite(pinBuzzer, HIGH);

      lastBlink = millis();

    }

  } else {

    digitalWrite(pinLedHP, LOW);

   digitalWrite(pinBuzzer, LOW);

ça ne marche pas

plus haut, ne faut-il pas changer quelque chose dans la dernière ligne de :

const float seuilHP = 24.0;
const byte indiceHP = 0;
const unsigned int frequenceBuzzHP = 800; // Hz

???

lorsque je clic sur la sonde HP, j’ai ce code qui ne me semble est-ce le bon ? comment le remplacer ?

28 11 11 11 11 11 11

J-M-L · January 26, 2026, 9:31am

je suis sur mon iPhone et je n'ai pas trop le temps de tester.

Il faut décommenter l'appel à rechercheCapteurs(); et regarder si les adresses qu'il imprime sont celles qui sont dans la définition.

d'après ce que vous dites ça commence maintenant par 0x28 alors que quand j'avais écrit le wokwi ça commençait pas 0x10 ➜ ce doit être le souci (et le dernier octet change aussi dynamiquement).

EDIT: bon j'ai quand même regardé c'était bien cela, le tableau maintenant doit êter

// Pour wokwi on a ces adresses
Capteur lesCapteurs[] = {
  {"EHP", {0x28, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x7E}, 0.0, true}, // 0 - Eau Haut Poêle
  {"EBP", {0x28, 0x22, 0x22, 0x22, 0x22, 0x22, 0x22, 0xDE}, 0.0, true}, // 1 - Eau Bas Poêle
  {"HCP", {0x28, 0x33, 0x33, 0x33, 0x33, 0x33, 0x33, 0xBE}, 0.0, true}, // 2 - Haut Cuve Poêle
  {"BCP", {0x28, 0x44, 0x44, 0x44, 0x44, 0x44, 0x44, 0x87}, 0.0, true}, // 3 - Bas Cuve Poêle
  {"PC ",  {0x28, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55, 0xE7}, 0.0, true}, // 4 - PC
  {"ECS", {0x28, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66, 0x47}, 0.0, true}, // 5 - ECS
};

➜

pour le son la fonction tone() prend une durée et fonctionne en asynchrone donc on n'a pas besoin de se soucier de l'arrêt du son (même si j'ai mis des noTone() ). Avec un buzzer actif vous ne pouvez que l'allumer ou l'éteindre, il faut donc modifier le code pour qu'il s'éteigne quand il le faut.

Topic		Replies	Views
Probleme avec des sondes de temperature ds 18b20 Français	13	166	November 19, 2025
LED qui clignote sans raison lorsque le buzzer retentit Français	32	627	December 10, 2023
Can't get two ds18b20 sensors read on different pins Programming	142	1172	September 19, 2025
Projet pour un étudiant en électromécanique Français	36	254	December 30, 2025
One wire DS18B20 reading +85°C, then -127°C and Arduino hanging up completely Programming	203	7458	January 19, 2025

Problème pour brancher 7 sondes DS18B20 sur le même bus

Related topics