Le DS18B20 est un capteur de température à un fil très précis qui peut être utilisé pour construire un thermomètre de précision. Il est facile à utiliser et peut être connecté à un affichage série USB pour afficher les données de température. Ce guide explique comment construire un thermomètre de précision basé sur le capteur de température DS18B20 et comment le connecter à un affichage série USB pour afficher les données de température.
Thermomètre de précision basé sur un capteur de température One-wire de type DS18B20 (affichage série USB)
1. Présentation
Ce programme réalise un thermomètre de précision avec affichage du résultat dans la fenêtre Terminal série, à l’aide d’un capteur de température One-wire de type DS18B20. Une mesure est effectuée toutes les secondes.
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 :
- Technologie One Wire (ou « 1-wire »)
- Capteur de température « One-Wire » série DS1820
- Librairie One Wire pour capteur température type DS18B20
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,
- un seul capteur 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 2 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=2; //declaration constante de broche
Déclaration des variables globales
- Déclaration des variables globales du programmes :
-
- Déclaration des variables globales utilisées pour la communication One Wire
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
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
-
- Initialisation du capteur One-Wire DS18B20
// --- initialisation du capteur DS18B20 ------ capteurInit(); // appel de la fonction d'initialisation du capteur - au début seulement // prise en compte du premier capteur trouvé // incluant affichage messages de détection du capteur dans moniteur série
9. Au niveau de la boucle principale, la fonction loop ( ) :
- On réalise une mesure de la température à l’aide de la fonction capteurMesureTemp()(voir ci-dessous) et on affiche le résultat avec 2 virgules :
ma_tempetf=capteurMesureTemp(); // appel de la fonction de mesure - renvoie une valeur float
Serial.print ("Temperature = ");
Serial.print (ma_tempetf,2);
Serial.println (" Degres Celsius. ");
- 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. Autres Fonctions du programme :
- Une fonction rassemble toute la procédure d’initialisation du capteur DS18B20. C’est un petit peu long… mais on a rien sans rien…
void capteurInit(void) // fonction qui ne reçoit rien et ne renvoie rien
{
// XXXXXXXXXXXXXXXXXXXXXX Détection du capteur présent sur la broche XXXXXXXXXXXXXXXXXXXXXXX
Serial.println("**** Detection du capteur **** ");
while (capteur.search(adresse)== false) // tant qu'aucun nouveau capteur est détecté
{
// la fonction search renvoie la valeur FAUX si aucun élément 1-wire est trouvé.
Serial.println("Aucun capteur 1-wire present sur la broche ! "); // affiche message + saut de ligne
delay (1000); // pause 1 seconde
}
//la suite est exécutée seulement si un capteur est détecté
// la fonction search renvoie la valeur VRAI si un élément 1-wire est trouvé.
// Stocke son code d'adresse 16 bits dans le tableau adresse[8]
// adresse envoyé à la fonction correspond à l'adresse de début du tableau adresse[8] déclaré ...
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 du capteur present : Capteur temperature DS18B20.");
}
else
{
Serial.println ("Le capteur present n'est pas un capteur de 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 !");
}
//------- message final détection ----
Serial.println("----- fin de la recherche du capteur ----");
Serial.println("");
}
//----------- fin de la fonction d'initialisation du capteur ----------
- Une seconde fonction rassemble toute la procédure de mesure de la température à l’aide du capteur DS18B20 :
//-------------- fonction de mesure de la température ---------------
float capteurMesureTemp(void) { //fonction qui renvoie résultat float et ne reçoit rien
//-------- variable locale de la fonction ----------
int tempet=0; // variable pour resultat brute de la mesure
float tempetf=0.0; // variable pour resultat à virgule de la mesure
// XXXXXXXXXXXXXXXXXXXXXX Lancement d'une mesure et lecture du résultat XXXXXXXXXXXXXXXXXXXXXXX
// Serial.println("**** Acquisition d'une mesure de la temperature **** ");
// avant chaque nouvelle instruction, il faut :
// * initialiser le bus 1-wire
// * sélectionner le capteur détecté
// * envoyer l'instruction
//--------- lancer une mesure --------
capteur.reset(); // initialise le bus 1-wire avant la communication avec un capteur donné
capteur.select(adresse); // sélectionne le capteur ayant l'adresse 64 bits contenue dans le tableau envoyé à la fonction
capteur.write(lancerMesure,1); // lance la mesure et alimente le capteur par la broche de donnée
//-------- pause d'une seconde -----
delay(1000); // au moins 750 ms
// il faudrait mettre une instruction capteur.depower ici, mais le reset va le faire
//---------- passer en mode LECTURE -------------
capteur.reset(); // initialise le bus 1-wire avant la communication avec un capteur donné
capteur.select(adresse); // sélectionne le capteur ayant l'adresse 64 bits contenue dans le tableau envoyé à la fonction
capteur.write(modeLecture,1); // passe en mode lecture de la RAM du capteur
// ----------- lire les 9 octets de la RAM (appelé Scratchpad) ----
for ( int i = 0; i < 9; i++) { // 9 octets de RAM stockés dans 9 octets
data[i] = capteur.read(); // lecture de l'octet de rang i stocké dans tableau data
}
//----- caclul de la température mesurée (enfin!) ---------
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 mode 12 bits, la résolution est de 0.0625°C - cf datasheet DS18B20
tempetf=float(tempet)*6.25;
tempetf=tempetf/100.0;
return (tempetf);
}
// --------------- fin de la fonction de mesure de la température ----------
11. Mise en oeuvre du programme
11.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
11.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 :
11.3 Fonctionnement
- Dans le moniteur série, un message initial indique que le capteur est bien détecté et que son adresse est valide. Ensuite, la valeur de la température s’affiche de façon répétée.
12. Le programme complet en langage Arduino :
A copier/coller directement dans l’éditeur Arduino
// --- Programme Arduino ---
// Copyright X. HINAULT - Créé le 11/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 ? ---
/* réalise un thermomètre de précision avec affichage
du résultat dans la fenêtre Terminal série,
à l'aide d'un capteur de température One-wire de type DS18B20.
Une mesure est effectuée toute les secondes. */
// --- 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 2 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 ---
//---- code des instructions du capteur
const int modeLecture=0xBE;
const int lancerMesure=0x44;
// --- constantes des broches ---
const int broche_OneWire=2; //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
float ma_tempetf=0.0;
// --- 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
// --- initialisation du capteur DS18B20 ------
capteurInit(); // appel de la fonction d'initialisation du capteur - au début seulement
// prise en compte du premier capteur trouvé
} // 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()
ma_tempetf=capteurMesureTemp(); // appel de la fonction de mesure - renvoie une valeur float
Serial.print ("Temperature = ");
Serial.print (ma_tempetf,2);
Serial.println (" Degres Celsius. ");
} // fin de la fonction loop() - le programme recommence au début de la fonction loop sans fin
// ********************************************************************************
//*************** Autres Fonctions du programme *************
//************************** fonction d'initialisation du capteur ****************
void capteurInit(void) // fonction qui ne reçoit rien et ne renvoie rien
{
// XXXXXXXXXXXXXXXXXXXXXX Détection du capteur présent sur la broche XXXXXXXXXXXXXXXXXXXXXXX
Serial.println("**** Detection du capteur **** ");
while (capteur.search(adresse)== false) // tant qu'aucun nouveau capteur est détecté
{
// la fonction search renvoie la valeur FAUX si aucun élément 1-wire est trouvé.
Serial.println("Aucun capteur 1-wire present sur la broche ! "); // affiche message + saut de ligne
delay (1000); // pause 1 seconde
}
//la suite est exécutée seulement si un capteur est détecté
// la fonction search renvoie la valeur VRAI si un élément 1-wire est trouvé.
// Stocke son code d'adresse 16 bits dans le tableau adresse[8]
// adresse envoyé à la fonction correspond à l'adresse de début du tableau adresse[8] déclaré ...
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 du capteur present : Capteur temperature DS18B20.");
}
else
{
Serial.println ("Le capteur present n'est pas un capteur de 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 !");
}
//------- message final détection ----
Serial.println("----- fin de la recherche du capteur ----");
Serial.println("");
}
//----------- fin de la fonction d'initialisation du capteur ----------
//-------------- fonction de mesure de la température ---------------
float capteurMesureTemp(void) { //fonction qui renvoie résultat float et ne reçoit rien
//-------- variable locale de la fonction ----------
int tempet=0; // variable pour resultat brute de la mesure
float tempetf=0.0; // variable pour resultat à virgule de la mesure
// XXXXXXXXXXXXXXXXXXXXXX Lancement d'une mesure et lecture du résultat XXXXXXXXXXXXXXXXXXXXXXX
// Serial.println("**** Acquisition d'une mesure de la temperature **** ");
// avant chaque nouvelle instruction, il faut :
// * initialiser le bus 1-wire
// * sélectionner le capteur détecté
// * envoyer l'instruction
//--------- lancer une mesure --------
capteur.reset(); // initialise le bus 1-wire avant la communication avec un capteur donné
capteur.select(adresse); // sélectionne le capteur ayant l'adresse 64 bits contenue dans le tableau envoyé à la fonction
capteur.write(lancerMesure,1); // lance la mesure et alimente le capteur par la broche de donnée
//-------- pause d'une seconde -----
delay(1000); // au moins 750 ms
// il faudrait mettre une instruction capteur.depower ici, mais le reset va le faire
//---------- passer en mode LECTURE -------------
capteur.reset(); // initialise le bus 1-wire avant la communication avec un capteur donné
capteur.select(adresse); // sélectionne le capteur ayant l'adresse 64 bits contenue dans le tableau envoyé à la fonction
capteur.write(modeLecture,1); // passe en mode lecture de la RAM du capteur
// ----------- lire les 9 octets de la RAM (appelé Scratchpad) ----
for ( int i = 0; i < 9; i++) { // 9 octets de RAM stockés dans 9 octets
data[i] = capteur.read(); // lecture de l'octet de rang i stocké dans tableau data
}
//----- caclul de la température mesurée (enfin!) ---------
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 mode 12 bits, la résolution est de 0.0625°C - cf datasheet DS18B20
tempetf=float(tempet)*6.25;
tempetf=tempetf/100.0;
return (tempetf);
}
// --------------- fin de la fonction de mesure de la température ----------
// --- Fin programme ---
