Codes pour deux DS18b20 arduino uno

Bonjour,

Je viens à vous pour savoir si quelqu'un ne possèderait pas un programme arduino pour deux capteurs DS18b20 connectés sur 2 pins différentes. J'ai un programme qui marche pour un seul capteur et j'essaye de le modifier pour avoir les deux capteurs qui s'affichent mais sans succès alors je poste ce message.

Ds l'attente de vos réponses, merci !

Pour les ds18B20 et donc le bus 1wire de Dallas, le plus simple c'est de les mettre sur la même pin, par logiciel il interrogera l'un ou l'autre.

Sinon tu peux mettre ton bout de programme entre code /code ça sera plus facile.

A+ Teiva

Ca c’est le programme pour un capteur de branché,

#include <OneWire.h> 

const int broche_OneWire=10; 

const int modeLecture=0xBE;
const int lancerMesure=0x44;


byte data[12]; 
byte adresse[8]; 
int tempet=0; 
float tempetf=0.0; 


OneWire  capteur(broche_OneWire);  


void setup()   { 


Serial.begin(9600); 




Serial.println("**** Detection du capteur **** ");

while (capteur.search(adresse)== false) 
{

  

  Serial.println("Aucun capteur 1-wire present sur la broche ! "); 
  delay (1000); 
}








  Serial.print ("1 capteur 1-wire present avec code adresse 64 bits : ");


  
   for(int i = 0; i < 8; i++) { 

    if (adresse[i]<16) Serial.print('0'); 
    Serial.print(adresse[i], HEX); 
    Serial.print(" ");
  }

  Serial.println();

  
  if (adresse[0]==0x28)
  {
    Serial.println ("Type du capteur present : Capteur temperature DS18B20.");
  }
  else
  {
    Serial.println ("Le capteur present n'est pas un capteur de temperature DS18B20.");
  }


 
  if (capteur.crc8( adresse, 7) == adresse[7]) 
  {
    Serial.println ("Verification du code CRC de l'adresse 64 bits de ce capteur : VALIDE !");
  }
  else
  {
    Serial.println ("Verification du code CRC de l'adresse 64 bits de ce capteur : NON VALIDE !");    
  }

  //------- message final détection ----
  Serial.println("----- fin de la recherche du capteur ----");
  Serial.println("");

  



} 


void loop(){ 



  Serial.println("**** Acquisition d'une mesure de la temperature **** ");

  


  capteur.reset(); 
  capteur.select(adresse); 
  capteur.write(lancerMesure,1); 

delay(1000);     
  capteur.reset(); 
  capteur.select(adresse); 
  capteur.write(modeLecture,1); 



for ( int i = 0; i < 9; i++) {           
    data[i] = capteur.read();             
  }


Serial.println("");
Serial.println("---- lecture de la RAM du capteur ---- ");
Serial.print("Octet 0 (Resultat poids faible)="), Serial.println(data[0],BIN);
Serial.print("Octet 1 (Resultat poids fort)="), Serial.println(data[1],BIN);
Serial.print("Octet 2 (Alarme haute)="), Serial.println(data[2],BIN);
Serial.print("Octet 3 (Alarme basse)="), Serial.println(data[3],BIN);
Serial.print("Octet 4 (Registre de configuration)="), Serial.println(data[4],BIN);
Serial.print("Octet 5 (Reserve)="), Serial.println(data[5],BIN);
Serial.print("Octet 6 (Reserve)="), Serial.println(data[6],BIN);
Serial.print("Octet 7 (Reserve)="), Serial.println(data[7],BIN);
Serial.print("Octet 8 (code CRC mesure)="), Serial.println(data[8],BIN);


//----- test de validité des valeurs reçues par contrôle du code CRC  ----

Serial.println("");
Serial.println("---- test de controle de validite des donnees recues ---- ");

  // le dernier (9ème) octet de la RAM est un code de contrôle CRC
  // à l'aide de la fonction crc8 on peut vérifier si ce code est valide
  if (capteur.crc8( data, 8) == data[8]) // vérification validité code CRC des valeurs reçues
  {
    Serial.println ("Verification du code CRC de ce resultat : VALIDE !");
  }
  else
  {
    Serial.println ("Verification du code CRC de ce resultat  : NON VALIDE !");    
  }

//----- caclul de la température mesurée (enfin!) ---------
Serial.println("");
Serial.println("---- calcul de la temperature ---- ");

//---- extraction du résultat de la mesure à partir des registres de la RAM ---
data[1]=data[1] & B10000111; // met à 0 les bits de signes inutiles
tempet=data[1]; // bits de poids fort
tempet=tempet<<8;
tempet=tempet+data[0]; // bits de poids faible

Serial.print ("Mesure brute =");
Serial.println (tempet);

// --- en mode 12 bits, la résolution est de 0.0625°C - cf datasheet DS18B20
tempetf=float(tempet)*6.25;
tempetf=tempetf/100.0;

Serial.print ("Mesure Finale =");
Serial.print (tempetf,2);
Serial.println (" Degres Celsius. ");


//while(1); // stoppe loop

} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************

//*************** Autres Fonctions du programme *************

// --- Fin programme ---

A première vu tu dois faire :

OneWire capteur1( broche1 ); OneWire capteur2( broche2 );

Ensuite ton programme doit travailler un coup sur l'un un coup sur l'autre.

Tu vois que si tu les met sur la même broche ça sera plus simple, car c'est déjà prévu (adresses différentes) ...

A+ Teiva

Le problème, si je connecte les deux capteurs sur la même pin, le programme m'en reconnait qu'un seul et ne laisse pas le choix de choisir l'un ou l'autre ! c'est çà que je ne comprends pas dans votre réponse

Bonjour,

Voici un exemple bien documenté tiré du site de X. HINAULT qui permet la détection de capteurs 18B20.

// --- Programme Arduino ---
// Copyright X. HINAULT - Créé le 10/04/2010
// www.mon-club-elec.fr 

//  Code sous licence GNU GPL : 
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License,
//  or any later version.
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
//  

// --- Que fait ce programme ? ---
/* test simple de la détection des capteurs
de température One-wire de type DS18B20
présents sur une broche de la carte Arduino
*/

// --- Fonctionnalités utilisées ---
// Utilise la connexion série vers le PC 
// Utilise un ou plusieurs capteurs One Wire 

// --- Circuit à réaliser ---
// Connexion série entre la carte Arduino et le PC (utilise les broches 0 et 1)  
// Connecter  sur la broche 9 la broche de données du capteur One Wire

//**************** Entête déclarative *******
// A ce niveau sont déclarées les librairies, les constantes, les variables...

// --- Inclusion des librairies utilisées ---

#include <OneWire.h> // librairie pour capteur OneWire

// --- Déclaration des constantes ---

// --- constantes des broches ---

const int broche_OneWire=10; //declaration constante de broche 

// --- Déclaration des variables globales ---
byte data[12]; // Tableau de 12 octets pour lecture des 9 registres de RAM et des 3 registres d'EEPROM du capteur One Wire
byte adresse[8]; // Tableau de 8 octets pour stockage du code d'adresse 64 bits du composant One Wire

int compt=0; // variable de comptage du nombre de capteurs sur le bus One Wire

// --- Déclaration des objets utiles pour les fonctionnalités utilisées ---
OneWire  capteur(broche_OneWire);  // crée un objet One Wire sur la broche voulue


//**************** FONCTION SETUP = Code d'initialisation *****
// La fonction setup() est exécutée en premier et 1 seule fois, au démarrage du programme

void setup()   { // debut de la fonction setup()

// --- ici instructions à exécuter au démarrage --- 

Serial.begin(115200); // initialise connexion série à 115200 bauds
// IMPORTANT : régler le terminal côté PC avec la même valeur de transmission 


//---- détection des capteurs présents sur le bus One Wire

Serial.println("*** Liste des elements presents sur le bus 1-wire *** ");

while (capteur.search(adresse)== true) // tant qu'un nouveau capteur est détecté
{
  // la fonction search renvoie la valeur VRAI si un élément 1-wire est trouvé. Stocke son adresse dans le tableau adresse
  // adresse correspond à l'adresse de début du tableau adresse[8] déclaré ... 

  // ce code est exécuté pour chaque capteur détecté
  compt=compt+1; // incrémente la variable de comptage du nombre de compteurs
  Serial.print ("Numero ");
  Serial.print (compt);
  Serial.print (": 1 capteur 1-wire present avec code adresse 64 bits : ");

  //--- affichage des 64 bits d'adresse au format hexadécimal
   for(int i = 0; i < 8; i++) { // l'adresse renvoyée par la fonction search est stockée sur 8 octets

    if (adresse[i]<16) Serial.print('0'); // pour affichage des O poids fort au format hexadécimal
    Serial.print(adresse[i], HEX); // affiche 1 à 1 les 8 octets du tableau adresse au format hexadécimal
    Serial.print(" ");
  }

  Serial.println(); 

  //---- test du type de capteur ---- 
  // le type du capteur est donné par le 1er octet du code adresse 64 bits
  // Valeur 0x28 pour capteur type DS18B20, 0x10 pour type DS18S20, 0x22 pour type DS1820
  if (adresse[0]==0x28) Serial.println ("Type : Capteur temperature DS18B20.");


  //----- contrôle du code CRC ----
  // le dernier octet de l'adresse 64bits est un code de contrôle CRC 
  // à l'aide de la fonction crc8 on peut vérifier si ce code est valide
  if (capteur.crc8( adresse, 7) == adresse[7]) // vérification validité code CRC de l'adresse 64 bits
  // le code CRC de l'adresse 64 bits est le 8ème octet de l'adresse (index 7 du tableau)
  {
    Serial.println ("Verification du code CRC de l'adresse 64 bits de ce capteur : VALIDE !"); 
  }
  else
  {
    Serial.println ("Verification du code CRC de l'adresse 64 bits de ce capteur : NON VALIDE !");     
  }

  Serial.println("------------"); 

} // fin boucle while test présence capteur

if (compt==0) // si aucun capteur n'a été détecté
{
  Serial.println("Aucun capteur present sur le bus 1-wire"); // affiche message + saut de ligne
}
else // si au moins 1 capteur a été détecté
{
  Serial.print(compt); // affiche nombre de capteurs détectés
  Serial.println (" capteur(s) detecte(s) sur ce bus 1-wire");   // affiche message + saut de ligne
  Serial.println ("**** Recherche terminee - fin de liste **** "); // affiche message + saut de ligne

}

} // fin de la fonction setup()
// ********************************************************************************

//*************** FONCTION LOOP = Boucle sans fin = coeur du programme *************
// la fonction loop() s'exécute sans fin en boucle aussi longtemps que l'Arduino est sous tension

void loop(){ // debut de la fonction loop()

// --- ici instructions à exécuter par le programme principal --- 

} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************

//*************** Autres Fonctions du programme *************

// --- Fin programme ---

Il ne reste plus qu’à calculer et afficher la température.
D’autres exemples sont fournis sur cet excellent site.
Salutations.

Salut,

ci-dessous un exemple fonctionnel de gestion de multiple DS18b20 que j’avais déjà publié sur l’ancien forum.
Le code est configuré pour un fonctionnement en mode parasite (2 fils). Si tu utilises le mode normal, les performances seront améliorées (tps de réponse plus court), mais il faudra modifier quelques paramètres (voir dans les commentaires).
Configure NBRE_CAPTEUR en fonction du nombre DS18b20
Configure les instances de temperature (adresse du DS18b20, la pin sur lequel il est connecté, et un petit nom)
Tu peux bien sur affecter plusieurs fois la même pin…

#include <stdio.h>
#include <string.h>
#include <OneWire.h>

#define NBRE_CAPTEUR 1 // nombre de capteur sur l'arduino

// *********** declararation des variables gestion des capteurs de temperature  *******************
typedef struct Temperature Temperature;
struct Temperature
{
	float valeur;					// temperature en Celsius, 1 chiffre apres la virgule
	byte addr[8];					// identifiant capteur
	int pin;					// numero de pin a utiliser
	char mnemo[32];					// mnemonique de la variable
};

Temperature temperature[NBRE_CAPTEUR];		//creation des instances

// *********** fin declararation des variables gestion des capteurs de temperature  *******************


void setup(){
  
      	Serial.begin(9600);				// initialisation de la liaison serie


// *********** initialisation des variables gestion des capteurs de temperature  *******************


	temperature[0].addr[0]= 0x10;	// identifiant capteur
	temperature[0].addr[1]=	0x5;
	temperature[0].addr[2]=	0x81;
	temperature[0].addr[3]=	0x94;
	temperature[0].addr[4]=	0x1;
	temperature[0].addr[5]=	0x8;
	temperature[0].addr[6]=	0x0;
	temperature[0].addr[7]=	0x24;
	temperature[0].pin=4;
	temperature[0].valeur=0;			// temperature en °C, 1 chiffre apres la virgule
        strcpy(temperature[0].mnemo,"temp_salon");	// ex: salon


  
}


void loop(){
  
  
gestion_temperature();

delay(5000);

}


void gestion_temperature()
{

/********************************************************************************
	Cette fonction permet d'interroger tous les capteurs de temperature OneWire
	qui ont ete declare dans "temperature[i]"
********************************************************************************/

	byte i=0;

	for(i=0; i<NBRE_CAPTEUR; i++){

 		Serial.print(temperature[i].mnemo);
		Serial.print(" => ");
		temperature[i].valeur =getStuff(temperature[i].addr,temperature[i].pin);
		Serial.print(temperature[i].valeur);
		Serial.println(" C ");
		delay(100);

	}

}


float getStuff(byte addr[8], int pin) // indiquer le n? de pin ? utiliser
{

/********************************************************************************
	Cette fonction permet d'interroger le capteur de temperature OneWire
	qui a ?t? d?clar? dans "temperature[i]"
********************************************************************************/

  OneWire  ds(pin);  // creation d'un objet OneWire avec le bon n? de pin

	byte i;
	byte present = 0;
	byte data[12];

	float real_temp;
	float temp_count;
	float read_temp;

 // Fonction recherche d?sactiv?e car non utilis?e
 /*if ( !ds.search(addr)) {
      Serial.print("No more addresses.\n");
      ds.reset_search();
 }


	Serial.print("R=");
	for( i = 0; i < 8; i++) {
		Serial.print(addr[i], HEX);
		Serial.print(" ");
	}

	if ( OneWire::crc8( addr, 7) != addr[7]) {
		Serial.print("CRC is not valid!\n");
		return 998;
	}
  
	if ( addr[0] != 0x10) {
		Serial.print("Device is not a DS18S20 family device.\n");
		return 999;
	}
*/
	ds.reset();
	ds.select(addr);
	ds.write(0x44,1); // start conversion, with parasite power off at the end (1=parasite mode)
  
	delay(1000);     // delay de 1s si mode parasite. 100ms en mode normal
  // we might do a ds.depower() here, but the reset will take care of it.
  
	present = ds.reset();
	ds.select(addr);    
	ds.write(0xBE);         // Read Scratchpad


    for ( i = 0; i < 9; i++) {           // we need 9 bytes
		data[i] = ds.read();
	}

	read_temp=((data[1]<<8) | data[0]) >> 1 ;            // Divide the temperature by 2
	temp_count=float(data[7] - data[6])/(float)data[7];  // Convert to real temperature
	real_temp = ((float)read_temp-0.25)+temp_count;

	// arrondi 1 chiffre apres la virgule
	int temp = real_temp*10;
	real_temp = (float)temp/10;

	// Serial.println();
  
  return real_temp;
}

Si tu ne connais pas l’adresse de tes DS18b20, décommente provisoirement les lignes, ou plus simple, utilises le code sample.c fournis avec la lib OneWire pour déterminer toutes les adresses.

Gromain
Gromain

Bonjour, merci beaucoup pour toutes ces infos, par ctre un soucis que je rencontre c'est que je ne possède pas les librairies string et stdio sur arduino et j'ai la version 022. Est ce que ces librairies se trouvent quelque part?

Salut,

<stdio.h> et <string.h> sont des bibliothèques standard du C, elles sont donc incluent dans l’IDE arduino.
Je ne pense pas que tu auras de problème de compilation à ce niveau là.

Gromain

D'accord donc ca ne vient pas de la mon problème, je m'y repenche pour savoir d'ou vient le problème alors !

merci,

Quel est ton problème ? c'est à la compilation ? une fois chargé ? Si c'est à la compilation, tu peux toujours coller ici un extrait des erreurs que tu as.

Gromain

A la compilation, je n’ai pas d’erreur, c’est juste à l’affichage que j’ai 0° et -1.20°. J’ai affecté le numéro de pin :

int pin[10]; Est ce que c’est comme cela qu’il faut l’affecter ?

J’ai défini le NBRE_CAPTEUR 2

#include <stdio.h>
#include <string.h>
#include <OneWire.h>

#define NBRE_CAPTEUR 2 // nombre de capteur sur l'arduino

// *********** declararation des variables gestion des capteurs de temperature  *******************
typedef struct Temperature Temperature;
struct Temperature
{
	float valeur;					// temperature en Celsius, 1 chiffre apres la virgule
	byte addr[8];					// identifiant capteur
	int pin[10];					// numero de pin a utiliser
	char mnemo[32];					// mnemonique de la variable
};

Temperature temperature[NBRE_CAPTEUR];		//creation des instances

// *********** fin declararation des variables gestion des capteurs de temperature  *******************


void setup(){
  
      	Serial.begin(9600);				// initialisation de la liaison serie


// *********** initialisation des variables gestion des capteurs de temperature  *******************


	temperature[0].addr[0]= 0x10;	// identifiant capteur
	temperature[0].addr[1]=	0x5;
	temperature[0].addr[2]=	0x81;
	temperature[0].addr[3]=	0x94;
	temperature[0].addr[4]=	0x1;
	temperature[0].addr[5]=	0x8;
	temperature[0].addr[6]=	0x0;
	temperature[0].addr[7]=	0x24;
	temperature[0].pin;
	temperature[0].valeur=0;			// temperature en °C, 1 chiffre apres la virgule
        strcpy(temperature[0].mnemo,"temp_salon");	// ex: salon


  
}


void loop(){
  
  
gestion_temperature();

delay(5000);

}


void gestion_temperature()
{

/********************************************************************************
	Cette fonction permet d'interroger tous les capteurs de temperature OneWire
	qui ont ete declare dans "temperature[i]"
********************************************************************************/

	byte i=0;

	for(i=0; i<NBRE_CAPTEUR; i++){

 		Serial.print(temperature[i].mnemo);
		Serial.print(" => ");
		temperature[i].valeur =getStuff(temperature[i].addr,temperature[i].pin[10]);
		Serial.print(temperature[i].valeur);
		Serial.println(" C ");
		delay(100);

	}

}


float getStuff(byte addr[8], int pin) // indiquer le n? de pin ? utiliser
{

/********************************************************************************
	Cette fonction permet d'interroger le capteur de temperature OneWire
	qui a ?t? d?clar? dans "temperature[i]"
********************************************************************************/

  OneWire  ds(pin);  // creation d'un objet OneWire avec le bon n? de pin

	byte i;
	byte present = 0;
	byte data[12];

	float real_temp;
	float temp_count;
	float read_temp;

 // Fonction recherche d?sactiv?e car non utilis?e
 /*if ( !ds.search(addr)) {
      Serial.print("No more addresses.\n");
      ds.reset_search();
 }


	Serial.print("R=");
	for( i = 0; i < 8; i++) {
		Serial.print(addr[i], HEX);
		Serial.print(" ");
	}

	if ( OneWire::crc8( addr, 7) != addr[7]) {
		Serial.print("CRC is not valid!\n");
		return 998;
	}
  
	if ( addr[0] != 0x10) {
		Serial.print("Device is not a DS18S20 family device.\n");
		return 999;
	}
*/
	ds.reset();
	ds.select(addr);
	ds.write(0x44,1); // start conversion, with parasite power off at the end (1=parasite mode)
  
	delay(1000);     // delay de 1s si mode parasite. 100ms en mode normal
  // we might do a ds.depower() here, but the reset will take care of it.
  
	present = ds.reset();
	ds.select(addr);    
	ds.write(0xBE);         // Read Scratchpad


    for ( i = 0; i < 9; i++) {           // we need 9 bytes
		data[i] = ds.read();
	}

	read_temp=((data[1]<<8) | data[0]) >> 1 ;            // Divide the temperature by 2
	temp_count=float(data[7] - data[6])/(float)data[7];  // Convert to real temperature
	real_temp = ((float)read_temp-0.25)+temp_count;

	// arrondi 1 chiffre apres la virgule
	int temp = real_temp*10;
	real_temp = (float)temp/10;

	// Serial.println();
  
  return real_temp;
}

J’ai récupéré les adresses des capteurs dans Sample.c

Don rectification, j’ai ceci maintenant :

#include <stdio.h>
#include <string.h>
#include <OneWire.h>

#define NBRE_CAPTEUR 2 // nombre de capteur sur l'arduino

// *********** declararation des variables gestion des capteurs de temperature  *******************
typedef struct Temperature Temperature;
struct Temperature
{
	float valeur;					// temperature en Celsius, 1 chiffre apres la virgule
	byte addr[8];					// identifiant capteur
	int pin;					// numero de pin a utiliser
	char mnemo[32];					// mnemonique de la variable
};

Temperature temperature[NBRE_CAPTEUR];		//creation des instances

// *********** fin declararation des variables gestion des capteurs de temperature  *******************


void setup(){
  
      	Serial.begin(9600);				// initialisation de la liaison serie


// *********** initialisation des variables gestion des capteurs de temperature  *******************


	temperature[0].addr[0]= 0x28;	// capteur rouge
	temperature[0].addr[1]=	0x9D;
	temperature[0].addr[2]=	0x4C;
	temperature[0].addr[3]=	0xDB;
	temperature[0].addr[4]=	0x2;
	temperature[0].addr[5]=	0x0;
	temperature[0].addr[6]=	0x0;
	temperature[0].addr[7]=	0xF7;
	temperature[0].pin=10;
	temperature[0].valeur=0;			// temperature en °C, 1 chiffre apres la virgule
        strcpy(temperature[0].mnemo,"temp_rouge");	// ex: salon

        temperature[1].addr[0]= 0x28;	// capteur rouge
        temperature[1].addr[1]=	0x37;
	temperature[1].addr[2]=	0x54;
	temperature[1].addr[3]=	0xDD;
	temperature[1].addr[4]=	0x2;
	temperature[1].addr[5]=	0x0;
	temperature[1].addr[6]=	0x0;
	temperature[1].addr[7]=	0x26;
	temperature[1].pin=10;
	temperature[1].valeur=1;			// temperature en °C, 1 chiffre apres la virgule
        strcpy(temperature[1].mnemo,"temp_jaune");	// ex: salon

  

}

void loop(){
  
  
gestion_temperature();

delay(1000);

}


void gestion_temperature()
{

/********************************************************************************
	Cette fonction permet d'interroger tous les capteurs de temperature OneWire
	qui ont ete declare dans "temperature[i]"
********************************************************************************/

	byte i=0;

	for(i=0; i<NBRE_CAPTEUR; i++){

 		Serial.print(temperature[i].mnemo);
		Serial.print(" => ");
		temperature[i].valeur =getStuff(temperature[i].addr,temperature[i].pin);
		Serial.print(temperature[i].valeur);
		Serial.println(" C ");
		delay(100);

	}

}


float getStuff(byte addr[8], int pin) // indiquer le n? de pin ? utiliser
{

/********************************************************************************
	Cette fonction permet d'interroger le capteur de temperature OneWire
	qui a ?t? d?clar? dans "temperature[i]"
********************************************************************************/

  OneWire  ds(pin);  // creation d'un objet OneWire avec le bon n? de pin

	byte i;
	byte present = 0;
	byte data[12];

	float real_temp;
	float temp_count;
	float read_temp;

 // Fonction recherche d?sactiv?e car non utilis?e
 /*if ( !ds.search(addr)) {
      Serial.print("No more addresses.\n");
      ds.reset_search();
 }


	Serial.print("R=");
	for( i = 0; i < 8; i++) {
		Serial.print(addr[i], HEX);
		Serial.print(" ");
	}

	if ( OneWire::crc8( addr, 7) != addr[7]) {
		Serial.print("CRC is not valid!\n");
		return 998;
	}
  
	if ( addr[0] != 0x10) {
		Serial.print("Device is not a DS18S20 family device.\n");
		return 999;
	}
*/
	ds.reset();
	ds.select(addr);
	ds.write(0x44,1); // start conversion, with parasite power off at the end (1=parasite mode)
  
	delay(1000);     // delay de 1s si mode parasite. 100ms en mode normal
  // we might do a ds.depower() here, but the reset will take care of it.
  
	present = ds.reset();
	ds.select(addr);    
	ds.write(0xBE);         // Read Scratchpad


    for ( i = 0; i < 9; i++) {           // we need 9 bytes
		data[i] = ds.read();
	}

	read_temp=((data[1]<<8) | data[0]) >> 1 ;            // Divide the temperature by 2
	temp_count=float(data[7] - data[6])/(float)data[7];  // Convert to real temperature
	real_temp = ((float)read_temp-0.25)+temp_count;

	// arrondi 1 chiffre apres la virgule
	int temp = real_temp*10;
	real_temp = (float)temp/100;

	// Serial.println();
  
  return real_temp;
}

Il me reconnait le 1er capteur, mais le deuxième il me le met à -0.12°C

Bon merci beaucoup pour les infos Gromain ! j'ai trouvé la solution du coup ! Encore merci :)

merci de la partager

C'est le code juste au dessus, je m'étais trompé dans l'adresse du capteur juste, sinon le code est correct.

merci pour ce code. :wink:
mais j’ai l’impression que la température affichée est sous estimé (de 3 ou 4 degrés).
c’est possible ?
alors qu’avec ce code, j’ai la bonne température :

#include <OneWire.h>

/* DS18S20 Celcius degrees */


#define TEMP_LSB 0
#define TEMP_MSB 1
//#define CONFIG_REG 4

OneWire  ds(2);  // on pin 10

void setup(void) {

  Serial.begin(9600);
}

void loop(void) {

  byte i;
  byte data[12];
  byte addr[8];
  byte present = 0;

  int set_bit;
  int resolution_floor = 1;   //for setting resolution 0 = High-resolution , 3 = Low resolution
  int msb,lsb,T;
  int temp_c_int;
  int test_bit;

  float expon;
  float temp_c_frac;
  float temp_c;
  float temp_f;

  if ( !ds.search(addr)) {
	Serial.print("No more addresses.\n");
	ds.reset_search();
	return;
  }

  Serial.print("R=");
  for( i = 0; i < 8; i++) {
    Serial.print(addr[i], HEX);
    Serial.print(" ");
  }

  if ( OneWire::crc8( addr, 7) != addr[7]) {
	Serial.print("CRC is not valid!\n");
	return;
  }

  if ( addr[0] != 0x28) {
	Serial.print("Device is not a DS18B20 family device.\n");
	return;
  }

  ds.reset();
  ds.select(addr);
  ds.write(0x44,1);	   // start conversion, with parasite power on at the end

  delay(1000);     // maybe 750ms is enough, maybe not
  // we might do a ds.depower() here, but the reset will take care of it.
  present = ds.reset();
  ds.select(addr);
  ds.write(0xBE);	   // Read Scratchpad

for ( i = 0; i < 12; i++) {	     // we need 9 bytes
    data[i] = ds.read();
}

   /* compute the degrees in celcius / integer part */

  /* The measured temp is spread across two bytes of the returned data.
   *  The integer part of the temp value is spread across the least 3 significant
   *  bits of the most significant byte (MSB) and the most significant 4 of
   *  the LSB.  Here we shift those 7 bits into their proper place in our
   *  result byte.
   *
   * note: could do this with 2 bit-shift / mask operations, alternatively
   */
    temp_c_int = 0;
    set_bit = 6;
for (test_bit = 2; test_bit >= 0; test_bit--) {
    temp_c_int |= ( ((data[TEMP_MSB] & (1 << test_bit)) >> test_bit) << set_bit );
    set_bit--;
}
for (test_bit = 7; test_bit >= 4; test_bit--) {
    temp_c_int |= ( ((data[TEMP_LSB] & (1 << test_bit)) >> test_bit) << set_bit );
    set_bit--;
}

  /* compute the fractional part */

  /*  first figure out what resolution we're measuring in - varies between 1 and 4 bits
   *    after the decimal (based on the contents of the CONFIG_REG byte):
   *	  bit 6 == 0 && bit 5 == 0 --> 9-bit resolution (ignore 3 least sig bits)
   *	  bit 6 == 0 && bit 5 == 1 --> 10-bit resolution (ignore 2 least sig bits)
   *	  bit 6 == 1 && bit 5 == 0 --> 11-bit resolution (ignore 1 least sig bits)
   *	  bit 6 == 1 && bit 5 == 1 --> 12-bit resolution

if ((data[CONFIG_REG] & (1 << 5)) > 0) {
  if ((data[CONFIG_REG] & (1 << 4)) > 0) {	// bits 6 and 5 are set
	resolution_floor = 3;
    } else {						  // bit 6 is set, 5 is clear
	resolution_floor = 2;
    }
    } else {
    if ((data[CONFIG_REG] & (1 << 4)) > 0) {	// bits 6 is clear, 5 is set
	resolution_floor = 1;
    } else {						  // bit 6 and 5 are clear
	resolution_floor = 0;
    }
}    */

  temp_c_frac = 0;
for (test_bit = 3; test_bit >= resolution_floor; test_bit--) {
    if ((data[TEMP_LSB] & (1 << test_bit)) > 0) {
	expon = test_bit - 4; // will be negative
	temp_c_frac += pow(2,expon);
    }
}

  /* put it all together */
  temp_c = (float)temp_c_int + temp_c_frac;

if ((data[TEMP_MSB] & (1 << 7)) > 0) {   // the temp is negative
    temp_c *= -1;
}


  Serial.print("   Temp en C= ");
  Serial.print(temp_c_int,DEC);
  Serial.print(".");
  Serial.print(temp_c_frac * 10000,DEC);
  Serial.println();
}

et je n’arrive pas a mettre 1 seul chiffre après la virgule.
merci par avance.

Bonjour, je me permet un petit up

la bibliothèque de X. HINAULT est très sympa, mais des que les températures négatives arrivent elle fonctionne bcp moins bien !

en fait le bug se cache dans ce coin la

data[1]=data[1] & B10000111; // met à 0 les bits de signes inutiles
tempet=data[1]; // bits de poids fort
tempet=tempet<<8;
tempet=tempet+data[0]; // bits de poids faible

En fait le bit de signe n’est pas si inutile que ça !!!
J’utilise une façon plus bourrine pour récupérer la dite température, en une seule ligne.

tempet=(data[1]<<8)|data[0];

Sachant que je fait des courbes sur mon mac a partir des données de mon arduino, j’ai cherché le pourquoi de mes tracés bizarre un certain temps !

En espérant que ce patch aidera d’autres.

Eventuellement contacte X.Hinault afin de lui en faire mention ;)

J’ai trouvé des tas de trucs passionnants sur son site, mais pas de rubrique “contact” :frowning:

Je crois qu’il se cache derrière le pseudo d’un des intervenants de ce site (vu la FAQ, la traduction d’une bonne partie de la doc Arduino et pleins de liens),
j’ose espérer qu’il trouvera cette bouteille a la mer.