View  Edit  Attributes  History  Attach  Print  Search

ACCUEIL | ARDUINO > S'INSTALLER > DEBUTER > APPROFONDIR | PROCESSING | MECATRONIQUE | MATERIEL | OUTILS | TESTS | Plus...|
Python > Shell > ATELIERS Python + Qt > PyQt apps > PyQt+Arduino | Mes Robots | RepRap | Mes lib'Arduino | Mes shields Arduino | Mes distros | Les Mini-PC |
ATELIERS ARDUINO| VIDEOS | COMPRENDRE | REFERENCES | CODER | TECHNIQUE | GNU/LINUX | LIENS | Rien à voir |

Détection des capteurs de température DS18B20 "One-Wire" (-55°/+125° sur 12 bits) connectés à la carte Arduino

ARDUINO - ONEWIRE - EXPERT - CAPTEURSCOMPLEXES
Par X. HINAULT - Créé le 10/04/2010

1.  Présentation

Ce programme est un test simple de détection des capteurs de température One-wire de type DS18B20 présents sur une broche de la carte Arduino.

Ce programme utilise les fonctionnalités suivantes :

  • la connexion série vers le PC
  • un ou plusieurs capteurs One Wire

Pour plus détails voir notamment :

2.  Matériel Nécessaire

2.1  L'espace de développement Arduino

  • ... pour éditer, compiler le programme et programmer la carte Arduino.

2.2  Le matériel suivant pour réaliser le montage associé

  • une plaque d'essai pour montage sans soudures,
  • des straps,
  • plusieurs capteurs de température One Wire type DS18B20 :

Trouvé ici (2 Euros) : http://www.watterott.com/en/DS18B20
Présenté ici : Capteur de température "One-Wire" série DS1820

3.  Instructions de montage

  • Connexion série entre la carte Arduino et le PC (utilise les broches 0 et 1)
  • Connecter sur la broche 10 la broche de données du capteur One Wire

4.  Le schéma théorique du montage


Le schéma théorique du montage

5.  Le circuit du montage


Le schéma du montage à réaliser

6.  Explication du programme

6.1  Structure globale du programme

Ce programme simple comprend :

  • une entête déclarative
  • une partie « configuration » qui ne sera exécutée qu'une fois (fonction setup( ) )
  • une partie constituée d'une boucle sans fin que le programme répètera à l'infini ( fonction loop( ) ) : c'est le coeur du programme.

6.2  Déroulement du programme

Le programme se déroule de la façon suivante :

  • Après avoir pris en compte les instructions de la partie déclarative,
  • puis après avoir exécuté la partie configuration ( fonction setup( ) ),
  • le programme bouclera sans fin ( fonction loop ( ) ), exécutant de façon répétée le code compris dans la boucle sans fin.

Le déroulement du programme

7.  Au niveau de la partie déclarative :

Inclusion des librairies utilisées

  • On inclut les librairies des fonctionnalités utilisées :
    • Inclusion de la librairie pour les capteurs One Wire:

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

Déclaration de constantes utiles

  • On déclare les constantes utiles dans le programme :

Déclaration des constantes de broches

  • Déclaration des constantes pour les broches utilisées dans le programme :

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

Déclaration des variables globales

  • Déclaration des variables globales du programmes : on déclare une variable de comptage du nombre de capteurs détectés :

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

  • Déclaration des variables globales utilisées pour la communication One Wire
byte data[12]; //Tableau de 12 octets pour lecture des registres RAM capteur One Wire
byte adresse[8]; // Tableau de 8 octets pour stockage du code d'adresse 64 bits du composant One Wire


Déclarations des objets utiles pour les fonctionnalités utilisées

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

8.  Au niveau de la fonction d'initialisation setup( ) :

Initialisation des fonctionnalités utilisées :

  • On initialise les différentes fonctionnalités utilisées :
    • Initialisation de la communication série avec le PC
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 1-wire :

  • Test de la présence d'un capteur : à l'intérieur d'une boucle while, on teste la fonction search afin de trouver le capteur suivant sur le bus 1-wire. Si un capteur est détecté, on récupère son adresse 64 bits à partir du résultat stocké dans le tableau adresse[8] par la fonction search :

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(" ");
  }

  • Test du type de capteur détecté : ensuite on teste le 1er octet des 8 octets de l'adresse 64 bits. Si sa valeur correspond au code prédéfini d'un capteur DS18B20, on affiche sa détection.

//---- 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.");

  • Vérification de la validité de l'adresse 64 bits : à l'aide de la fonction , on réalise un test de validité de l'adresse 64 bits reçue en testant la cohérence entre la valeur du 8ème octet et la valeur renvoyée par la fonction

 //----- 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 !");     
  }

  • On termine en affichant le nombre des capteurs détectés (ou l'absence de détection si aucun présent...) :

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

}

9.  Au niveau de la boucle principale, la fonction loop ( ) :

Pas de code à ce niveau dans ce programme.

  • Le programme recommence en boucle les instructions de la fonction loop( ).

Se reporter aux commentaires présents dans le programme pour plus de détails.

10.  Mise en oeuvre du programme

10.1  Préparation du montage et programmation de la carte Arduino :

  • Commencer par réaliser le montage indiqué sur plaque d'expérimentation
  • Ensuite, programmer la carte Arduino avec ce programme (en bas de page) selon la procédure habituelle

10.2  Préparation du Terminal côté PC dans le logiciel Arduino

  • Côté PC, il faut ouvrir la fenêtre terminal de l'IDE Arduino : pour ce faire, un simple clic sur le bouton « Sérial Monitor ».
  • La fenêtre « Terminal » s'ouvre alors :
  • Il faut alors régler le débit de communication sur la même valeur que celle utilisée par le programme avec lequel nous allons programmer la carte Arduino :

10.3  Fonctionnement

  • A l'ouverture de la fenêtre du Terminal série, la liste des capteurs détectés s'affiche :

11.  Le programme complet en langage Arduino :

A copier/coller directement dans l'éditeur Arduino


// --- 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 ---