next topic »

[on:]

Bonjour à tous,

Voilà j'ai un petit problème concernant la réalisation d'un thermomètre basé sur un DS18S20 (Dallas).
Je souhaite afficher la température sur un afficheur LCD I2C, mais rien à faire.

Alors si un bout de code existe, n'hésitez pas.

Merci pour votre aide.

Mike

[Reply #1 on:]

Bonjour,

J'ai publié un article sur le sujet ce matin, quelques minutes avant ton post
http://skyduino.wordpress.com/2012/04/26/arduino-capteur-de-temperature-ds18b20/

Pour la parti affichage tu peut te reporter aux exemples du playground arduino.

[Reply #2 on:]

mais rien à faire.

Avec si peux de renseignements, on va pas pouvoir te dire grand chose, il nous en faudra plus.
Qu'as-tu déjà fais, quel arduino, quel branchement as-tu effectuer, de quel lcd il s'agit, qu'a tu tester comme code, etc  ???

Alors si un bout de code existe, n'hésitez pas.

Avec des bouts de code rien ne garanti que ce soit fonctionnel avec si peux d'infos.
D'ailleurs pour le ds18b20 sur arduino c'est pas ce qui manque sur le net, donc un minimum de recherche t'aurais déjà permis de trouver différents schémas et "bouts" de codes ...
Maintenant si c'est pour t'aider ou orienté avec ses bouts de code ou autre difficultés pas de problème on t'aideras au temps qu'on peux. 

[Reply #3 on:]

Bonjour,

J'ai publié un article sur le sujet ce matin, quelques minutes avant ton post
http://skyduino.wordpress.com/2012/04/26/arduino-capteur-de-temperature-ds18b20/

Pour la parti affichage tu peut te reporter aux exemples du playground arduino.

bonjour
attention à bien faire aussi la différence entre un DS18B20 et un DS18S20 

[Reply #4 on:]

non pour la partie capteur, j'ai bien utiliser les codes que l'on trouve un peu partout,pour les DS18S20 en non DS18B20, par contre là ou je plante c'est sur la partie traitement de la variable température afin de l'afficher sur un LCD I2C (ELCD-204BLB) visible sur le site de Lextronic.

Merci pour votre aide.

[Reply #5 on:]

attention à bien faire aussi la différence entre un DS18B20 et un DS18S20 

J'avait pas vu le S
Ya vraiment une différence dans la méthode de communication (à pars l'adresse 1Wire ) ?

[Reply #6 on:]

attention à bien faire aussi la différence entre un DS18B20 et un DS18S20 

J'avait pas vu le S
Ya vraiment une différence dans la méthode de communication (à pars l'adresse 1Wire ) ?

non le protcole est identique, mais de memoire il y des subtilités de decodage de la T°
les DS18B20 sont natif en 12 bits, mais gerable entre 9 et 12
les DS18S20 sont seulement en 9 bits

et toujours de memoire les DS1920 sont des des DS18S20 en format Ibutton et mon petit doigt me dis que tu devrais en trouver un dans tes tiroirs 

[Reply #7 on:]

non le protcole est identique, mais de memoire il y des subtilités de decodage de la T°
les DS18B20 sont natif en 12 bits, mais gerable entre 9 et 12
les DS18S20 sont seulement en 9 bits

Humm, nuance subtile effectivement.

et toujours de memoire les DS1920 sont des des DS18S20 en format Ibutton et mon petit doigt me dis que tu devrais en trouver un dans tes tiroirs 

Ton petit doigt a vu juste
J'ai prévu de faire des articles sur les ibutton que tu m'as passé, et aussi de faire des breakout avec les datalogger dallas en boitier DIP.
Mis pour le moment je manque cruellement de temps libre avec l'IUT ...

[Reply #8 on:]

Mis pour le moment je manque cruellement de temps libre avec l'IUT ...

Concentre toi sur le principal, l'accessoire suivra ensuite 

[Reply #9 on:]

voici un bout de mon code avec un DS18B20 et un deuligne. Ce programme possede une option qui consiste à programmer une temperature à l'aide du "joystick" du deuligne et de pouvoir "reguler" ( sans prétention) une temperature affichée. Bonne bidouille !

Code:

// --- Programme Arduino ---

//**************** 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
#include "Wire.h"
#include <Deuligne.h>
Deuligne lcd;
// --- Déclaration des constantes ---

//---- code des instructions du capteur
const int modeLecture=0xBE;
const int lancerMesure=0x44;
int escape=0;
  int h=25;
// --- 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
 // set up the LCD's number of columns and rows:
  lcd.init();
  // Print a message to the LCD.
  
// 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 (" deg C ");
//lcd.print("Temperature:");
 lcd.clear ();
 lcd.print ("Temp: ");
 lcd.print(ma_tempetf,2);
 lcd.print (" deg ");
 // lcd.setCursor(0, 1);
 //if (ma_tempetf < 27) ;
 //else lcd.print(" + ");
 
 lcd.setCursor(2,1);
 //lcd.print ("Temp 27.0");
escape=lcd.get_key();
    delay(10); // for debounce
    if (escape==2)
          --h;
      if (escape==1)
          h++;
          lcd.print (h);
          lcd.setCursor(5,1);
          lcd.print("consigne");
   if (ma_tempetf > h) ;
 else lcd.print(" + ");      
if (ma_tempetf <h );
else lcd.print(" - ");
lcd.setCursor(0, 1);



} // 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);
 lcd.display();

}

// --------------- fin de la fonction de mesure de la température ----------

// --- Fin programme ---

[Reply #10 on:]

Un code d'exemple où il y a plus de lignes de commentaires que de ligne de code.
Chapeau !
çà c'est de l'exemple instructif.

74 ? T'es de la Yaute ?

[Reply #11 on:]

Un code d'exemple où il y a plus de lignes de commentaires que de ligne de code.
Chapeau !
çà c'est de l'exemple instructif.

74 ? T'es de la Yaute ?

pas tout à fait mais de Grenoble !

Ce code m'avais plus à l'époque car il est tres explicite. Je l'ai modifié à ma sauce mais l'essentiel est là.

Par contre au lieu de piloter des transistors pour une commande quelconque ( ventilo ou chauffage ) on affiche + ou - sur le LCD à coté de la temperature de consigne pour nous indiquer si on est au dessus ou au dessous de la consigne.


edit : Il semble que le DS18S20 se code sur 9 bits il convient d'adapter ce code pour ce capteur.

[Reply #12 on:]

J'ai jeté un cop d'oeil à la doc et il y a 2 registres :

un octet "low" qui contient la "mantisse"
un octet "high" qui contient le bit de signe étendu sur 8 bits

Je ne sais pas comment lire sur du 1-Wire, j'ai jamais essayé, mais si on arrive a lire low et high alors

Code:

byte high = ???;
byte low = ???;
int temp_i = (high << 8) | low;
float temp = (float)temps_i * 0.5;

[Reply #13 on:]

Je ne sais pas comment lire sur du 1-Wire

http://www.laboelectronique.be/captemp.html
Faudra que je me commande un ds un jours et peux être étendre aux autres ?

[Reply #14 on:]

J'ai jeté un cop d'oeil à la doc et il y a 2 registres :

un octet "low" qui contient la "mantisse"
un octet "high" qui contient le bit de signe étendu sur 8 bits

Je ne sais pas comment lire sur du 1-Wire, j'ai jamais essayé, mais si on arrive a lire low et high alors

Code:

byte high = ???;
byte low = ???;
int temp_i = (high << 8) | low;
float temp = (float)temps_i * 0.5;

bonjour
pour les DS18X20
le code dessous est une bonne base
et si tu veux t'amuser avec du 1-W c'est simple (ton adresse en MP  )

Code:

#include <OneWire.h>

// OneWire DS18S20, DS18B20, DS1822 Temperature Example
//
// http://www.pjrc.com/teensy/td_libs_OneWire.html
//
// The DallasTemperature library can do all this work for you!
// http://milesburton.com/Dallas_Temperature_Control_Library

OneWire  ds(4);  // on pin 10

void setup(void) {
  Serial.begin(9600);
}

void loop(void) {
  byte i;
  byte present = 0;
  byte type_s;
  byte data[12];
  byte addr[8];
  float celsius, fahrenheit;
 
  if ( !ds.search(addr)) {
    Serial.println("No more addresses.");
    Serial.println();
    Serial.println();
    Serial.println();
   
    ds.reset_search();
    delay(250);
    return;
  }
 
  Serial.print("ROM =");
  for( i = 0; i < 8; i++) {
    Serial.write(' ');
    Serial.print(addr[i], HEX);
  }

  if (OneWire::crc8(addr, 7) != addr[7]) {
      Serial.println("CRC is not valid!");
      return;
  }
  Serial.println();
 
  // the first ROM byte indicates which chip
  switch (addr[0]) {
    case 0x10:
      Serial.println("  Chip = DS18S20");  // or old DS1820
      type_s = 1;
      break;
    case 0x28:
      Serial.println("  Chip = DS18B20");
      type_s = 0;
      break;
    case 0x22:
      Serial.println("  Chip = DS1822");
      type_s = 0;
      break;
    default:
      Serial.println("Device is not a DS18x20 family device.");
      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

  Serial.print("  Data = ");
  Serial.print(present,HEX);
  Serial.print(" ");
  for ( i = 0; i < 9; i++) {           // we need 9 bytes
    data[i] = ds.read();
    Serial.print(data[i], HEX);
    Serial.print(" ");
  }
  Serial.print(" CRC=");
  Serial.print(OneWire::crc8(data, 8), HEX);
  Serial.println();

  // convert the data to actual temperature

  unsigned int raw = (data[1] << 8) | data[0];
  if (type_s) {
    raw = raw << 3; // 9 bit resolution default
    if (data[7] == 0x10) {
      // count remain gives full 12 bit resolution
      raw = (raw & 0xFFF0) + 12 - data[6];
    }
  } else {
    byte cfg = (data[4] & 0x60);
    if (cfg == 0x00) raw = raw << 3;  // 9 bit resolution, 93.75 ms
    else if (cfg == 0x20) raw = raw << 2; // 10 bit res, 187.5 ms
    else if (cfg == 0x40) raw = raw << 1; // 11 bit res, 375 ms
    // default is 12 bit resolution, 750 ms conversion time
  }
  celsius = (float)raw / 16.0;
  fahrenheit = celsius * 1.8 + 32.0;
  Serial.print("  Temperature = ");
  Serial.print(celsius);
  Serial.print(" Celsius, ");
  Serial.print(fahrenheit);
  Serial.println(" Fahrenheit");
  Serial.println("-------------------");
  Serial.println();
}