Bonjour;
Je travail actuellement sur la programmation d'un enregistreur de températures.
J'ai pris en copie des programme exemples que j'ai remanier en m’efforçant de décrypter leurs fonctionnement via le site "Mon club elec" => traduction des instructions.
Mais voila je ne trouve rien sur l'instruction "SEARCH".
Que fait cette ligne if ( !capteurA.search(adresseLA))
if ( !capteurA.search(adresseLA)) {
Serial.println("===============Dernier capteur de mesures.==============");
Serial.println(" ");
capteurA.reset_search();
delay(1000);
return;
}
Je suppose que c'est un capteur onewire.
Cette fonction énumère les capteur présents sur le bus et retourne TRUE ainsi que son identifiant si un capteur est présent ou FALSE s'il n'y a plus de capteur sur le bus.
La doc ici: OneWire Arduino Library, connecting 1-wire devices (DS18S20, etc) to Teensy
Voici mon programme.
en partie car trop long pour le forum!
//MODIF > ligne 000 rechercher la ligne avec "ctrl+F"
/* Test de la détection des capteurs de TEMPERATURES de type One-wire de type DS18x20 présents sur une broche de la carte Arduino (X est la caracteristique du model*/
/* Utilise la connexion série vers le PC (USB)+ Utilise un ou plusieurs capteurs One Wire */
/* Connexion série entre la carte Arduino et les composants => utilise les broches 10 et 9 + Connecter sur la broche 9 et la broche 10 une resistance de charge 4.7Kohme*/
// -------------------------------------- Inclusion des librairies utilisées -----------------------------------------------------------------------------------
#include <OneWire.h> // librairie pour capteur OneWire
#include<LiquidCrystal.h> // librairie pour expoitation d'ecran a cristaux liquides
// --------------------------------------- Déclaration des constantes ---------------------------------------------------------------------------------------------
const int broche_OneWireA=9;
const int broche_OneWireB=10; //Declaration constante de broche 10
LiquidCrystal lcd(12,11,5,4,3,2); //Declaration des broches LCD.
//--------------------------------------- code d'instruction du capteur ----------------------------------------------------------------------------------------
const int modeLecture=0xBE; //Code hexa transmis par la sonde (Datasheat)
const int lancerMesure=0x44; //Code hexa transmis par la sonde (Datasheat)
// -------------------------------------- Déclaration des variables de tableaux globales ------------------------------------------------------------------------------------
byte dataA[12]; // Tableau de 12 octets pour lecture des 9 registres de RAM et des 3 registres d'EEPROM du capteur One Wire
byte adresseA[8]; // Tableau de 8 octets pour stockage du code d'adresse 64 bits du composant One Wire
byte dataB[12]; // Tableau de 12 octets pour lecture des 9 registres de RAM et des 3 registres d'EEPROM du capteur One Wire
byte adresseB[8]; // Tableau de 8 octets pour stockage du code d'adresse 64 bits du composant One Wire
//--------------------------------------- Declaration des variables globales fonctionnel ------------------------------------------------------------------------------
int comptA=0; // variable de comptage du nombre de capteurs sur le bus One Wire
int comptB=0;
//int mesureBrut=0; // variable pour resultat de la mesure brut = Desactivé L 220.
float offsetA = -1.0; // Crée une variable "offset" ajustement sur une valeur de reference.
float offsetB = -1.0;
// -------------------------------------- Déclaration des objets utiles pour les fonctionnalités utilisées ----------------------------------------------------
OneWire capteurA(broche_OneWireA); // crée un objet One Wire sur la broche voulue
OneWire capteurB(broche_OneWireB);
void setup(){
Serial.begin(9600); // initialise connexion série à 115200 bauds (vitesse de trans.)
Serial.println("*********************PROGRAMME***********************");
/*lcd.clear();
lcd.begin(16,2);
lcd.setCursor(1,0);
lcd.print("INITIALISATION");
lcd.setCursor(5,1);
lcd.print("BONJOUR");
//lcd.autoscroll();
delay(3000);*/
//--------------------------------------------- détection des capteurs présents sur le bus One Wire----------------------------------------------------------------
Serial.println("*** Liste des elements presents sur le bus VOIE A ***");
//Serial.println(" ");
while (capteurA.search(adresseA)== 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é ... */
comptA=comptA+1; // incrémente la variable de comptage du nombre de capteurs / exécuté pour chaque capteur détecté
Serial.print ("Numero ");
Serial.print (comptA);
Serial.print (": capteur 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 (adresseA[i]<16) Serial.print('0'); // pour affichage des O poids fort au format hexadécimal
Serial.print(adresseA[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 de capteur temperature : DS18B20."); // Désactivé car utile seulement en TEST
if (adresseA[0]==0x10) Serial.println ("Type de capteur : DS18S20.");
//if (adresse[0]==0x22) Serial.println ("Type de capteur temperature : DS1820."); // Desactivé car utile seulement en TEST
//--------------------------------------- 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]) // ==DESACTIVE "buggs" =>CRC 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 ("Code CRC: VALIDE !");
}
else
{
Serial.println ("Code CRC: NON VALIDE !");
}*/
//-----------------------------------------Retour d'informations en fin de "scan" -------------------------------------------------------------
} // fin boucle while et test de la présence de capteurs
if (comptA==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(comptA); // affiche nombre de capteurs détectés
Serial.println(" capteur(s) detecte(s) sur ce bus VOIE A"); // affiche message + saut de ligne
//Serial.println(" ");
Serial.println("********** Recherche terminee - fin de liste ********* "); // affiche message + saut de ligne
Serial.println("****************************************************** ");
Serial.println(" ");
}
! c'est ce n'est pas "différent de"
! c'est la négation (au sens logique)
capteurA.search(adresseLA) retourne TRUE si la fonction trouve un capteur et FALSE si elle ne trouve rien
Le ! devant capteurA.search(adresseLA) complémente la valeur retournée
!capteurA.search(adresseLA) est TRUE s'il n'y a plus de capteur sur le bus.
if (!capteurA.search(adresseLA)){}
exécute le code dans les accolades si search ne trouve plus de capteur sur le bus.
Voici la partie du programme dans la quelle est intégré cette ligne.
void loop(void){
//-----------------------------------------------------------Declaration des Variables local---------------------------------------------------------------------------------------
byte dataLA[12]; // Tableau de 12 octets pour lecture des 9 registres de RAM et des 3 registres d'EEPROM du capteur One Wire
byte dataLB[12];
byte i;
byte adresseLA[8]; //Declaration du tableau "adresse"
byte adresseLB[8];
//---------------------------------------------------------------Debut de la fonction programmé-------------------------------------------------------------------------------------
if ( !capteurA.search(adresseLA)) // Remplacer "addr" par "adresse"
{
Serial.println("===============Dernier capteur de mesures.==============");
Serial.println(" ");
capteurA.reset_search();
delay(1000);
return;
}
Serial.print("Capteur A =");
for( i = 0; i < 8; i++)
{
Serial.write(' ');
Serial.print(adresseA[i], HEX);
}
/* avant chaque nouvelle instruction, il faut :
* initialiser le bus 1-wire
* sélectionner le capteur détecté
* envoyer l'instruction*/
//--------------------------------------------------------------- lancer une mesure ------------------------------------------------------------------------------------------------
capteurA.reset(); // initialise le bus 1-wire avant la communication avec un capteur donné
capteurA.select(adresseLA); // sélectionne le capteur ayant l'adresse 64 bits contenue dans le tableau envoyé à la fonction
capteurA.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 ----------------------------------------------------------------------------------------------------
capteurA.reset(); // initialise le bus 1-wire avant la communication avec un capteur donné
capteurA.select(adresseLA); // sélectionne le capteur ayant l'adresse 64 bits contenue dans le tableau envoyé à la fonction
capteurA.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
dataLA[i] = capteurA.read(); // lecture de l'octet de rang i stocké dans tableau data
}
//-------------------------------------------------- test de validité des valeurs reçues par contrôle du code CRC --------------------------------------------------------------------------
/*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 (capteurA.crc8( dataLA, 8) == dataLA[8]) // Vérification validité code CRC des valeurs reçues
{
Serial.println (" Code CRC: VALIDE !");
}
else
{
Serial.println ("Code CRC: NON VALIDE !");
}
//--------------------------------------------------Conversion de la valeur brut = solution deux a l'étude => validé----------------------------------------------------------------------------
int16_t brutA= (dataLA[1] << 8) | dataLA[0]; //creation de l'objet "brut" de retour valeur.
brutA = brutA << 3; // 9 bit resolution default
float celciusA = ((float)brutA / 16.0)+offsetA;
//-----------------------------------------------------------------------Affichage des données--------------------------------------------------------------------------------------------------
//Serial.print ("Mesure brute =");
//Serial.println (mesureBute);
//Serial.println (" "); // Desactivé car utile seulement en TEST.
Serial.print ("T= ");
Serial.print (celciusA);
Serial.println (" Degres Celsius.");
Serial.print(""); // Desactivé car utile seulement en TEST.
//Serial.println(); // Desactivé car utile seulement en TEST.
/*lcd.clear();
lcd.setCursor(2,0);
lcd.print("TEMPERATURE");
lcd.setCursor(5,1);
lcd.print(celcius);
lcd.print("C");*/
delay(1000); //Arret de mesure sur 6min 36*10e40==01-Annulation de Wihle.
//while(1);
/* -------------------------------------------------------------- affichage du contenu des différents octets / Désactivé car utile seulement en TEST --------------------------------------------
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);*/
//------------------------------------------------------------- caclul de la température mesurée -----------------------------------------------------------------------------------------------
/*------------------------------- extraction du résultat de la mesure à partir des registres de la RAM Gain de place +octets---DESACTIVE 220.-----------------------------------------------------
data[1]=data[1] & B10000111; // Met à 0 les bits de signes inutiles;
mesureBrut=data[1]; // Bits de poids fort / Remplacment de la variable "tempet" par la variable "mesureBrut";
mesureBrut=mesureBrut<<8;
mesureBrut=mesureBrut+data[0]; // bits de poids faible.
mesureBrut=mesureBrut<<3; // Pris en compte des bits utiles en pour le capteur "DS18S20".
float temperature = (float)mesureBrut / 16.0; // Modificaton de la conversion (*6.25) => (/16.0) + crée variable "temperature" */
Je salut ta patience fdufnews.
Donc si je comprend bien.
Cette commande recherche une adresse dans la tables "adresseLA" qui serrais différente de "adresseA" et me retourne comme réponse vrais ou faut.
En gros elles compare les deux tables pour voir si elles sont identique?
Globalement si j'ai pas faut.
search prend chaque variable de "adresseA" et les compare avec chaque adresse de "adresseLA" si l'une d'elle n’apparait pas dans "adresseA" il me revoie = false
search() assure la découverte des périphériques sur le bus OneWire.
A chaque appel de search() la fonction cherche si un nouveau capteur est présent.
A chaque nouveau périphérique découvert le tableau adresseLA est rempli avec l'identifiant du périphérique trouvé et la fonction retourne TRUE.
Si tous les périphériques ont été trouvés la fonction retourne FALSE.
Normalement, search() n'est utilisé qu'à l'initialisation (pendant le setup() par exemple).
Le programme construit alors une table des capteurs qui est ensuite utilisée par la fonction select() pour adresser un capteur particulier.
Faire un search() à chaque fois que tu veux faire une mesure est une importante perte de temps car la découverte des périphériques sur le bus OneWire est assez longue.
Donc c'est search qui interroge les capteurs et qui renvoie leurs adresses et les charge dans la table que l'on pré-définis.
Donc ma ligne ne fait que contrôler si un autre capteur et ajouté après l'initialisation.
Comme vous le faite remarquer j'effectue déjà cette opération dans le SETUP sauf qu'il n'y a pas de " ! " -il m'embrouille celui la-
Je vais revoir cette partie de programme.
En gros avec ce genre de capteur si je n'effectue pas "search" j'ai aucune idée de leurs adresse et ne peut pas les interroger voir dialoguer avec eux.(un outil d'identification)
search est une instruction de "OneWire" ??
Merci je commence a comprendre et pas mal de chose se débloque.
Je remet même en doute ma compréhension des tables.
En gros avec ce genre de capteur si je n'effectue pas "search" j'ai aucune idée de leurs adresse et ne peut pas les interroger voir dialoguer avec eux.(un outil d'identification)
search est une instruction de "OneWire" ??
bonjour
pour faire simple , chaque composant 1W dispose d'une adresse unique
pour pouvoir utiliser plusieurs composants 1W sur la meme ligne* , il faut l'adresser , ce qui implique à un moment de connaitre chacune des adresses.
il existe plusieurs methodes de programmation
typiquement pour le cas des DS18B20 :
1- un scan systematique du bus à chaque demande de T°
2- un scan au reset avec mise en memoire des adresses trouvées
3- un adressage en dur apres utilisation d'un scanner externe
chaque methode à ses avantages et ses inconvenients
Le meilleur compromis etant à mon sens la solution N° 2
si il n'y a qu'un capteur sur le bus , la recherche d'adresse n'est pas necessaire (instruction skip rom)
exemple de scanner
#include <OneWire.h>
// Onewire lib is here http://www.pjrc.com/teensy/td_libs_OneWire.html
OneWire ds(8); // on pin 8 here, don't forget 4.7K resistor between +5V and DQ pin
void setup(void) {
Serial.begin(9600);
}
void loop(void) {
byte i;
byte present = 0;
byte data[12];
byte addr[8];
if ( !ds.search(addr)) {
Serial.println("--------------");
Serial.println(".");
Serial.println(".");
Serial.println("END OF SCAN.");
Serial.println(".");
Serial.println();
ds.reset_search();
delay(2500);
return;
}
Serial.println("--------------");
Serial.print(" ROM =");
for( i = 0; i < 8; i++) {
Serial.write(' ');
if ( addr[i]<16) {
Serial.print("0");
}
Serial.print(addr[i], HEX);
}
if (OneWire::crc8(addr, 7) != addr[7]) {
Serial.println("CRC is not valid!");
return;
}
Serial.println();
Serial.print("CHIP FAMILY ");
Serial.print(addr[0],HEX);
// the first ROM byte indicates which chip
Serial.print(" = ");
switch (addr[0]) {
case 0x01:
Serial.println(" DS1990 DS2401"); //
break;
case 0x02:
Serial.println(" DS1991"); //
break;
case 0x04:
Serial.println(" DS1994"); //
break;
case 0x05:
Serial.println(" DS2405"); //
break;
case 0x06:
Serial.println(" DS1992"); //
break;
case 0x08:
Serial.println(" DS1993"); //
break;
case 0x0B:
Serial.println(" DS1985");
break;
case 0x10:
Serial.println(" DS1820 DS18S20 DS1920");
break;
case 0x12:
Serial.println(" DS2406");
break;
case 0x21:
Serial.println(" DS1921");
break;
case 0x22:
Serial.println(" DS1822");
break;
case 0x24:
Serial.println(" DS1904");
break;
case 0x28:
Serial.println(" DS18B20");
break;
case 0x29:
Serial.println(" DS2408");
break;
case 0x36:
Serial.println(" DS2740");
break;
case 0x3B:
Serial.println(" DS1825");
break;
case 0x41:
Serial.println(" DS1923");
break;
default:
Serial.println(" is not listed.");
return;
}
}
Je pense avoir compris => le DS18x20 est un capteur intelligent qui dialogue et qui a donc besoins d'une structure d'échange et search me permet d'initialiser pour organiser tout cela.
Pour l'adresse on peut voir ça comme une adresse "MAC" si je peut dire.
Je vais donc utiliser la seconde méthode pour l'utilisation de mes capteurs.
Je vais chercher le moyen de les identifier par leurs adresse sur une seul broche. (pas facile je vais encor ramer un moment !!)
Comme vous avez pu le constaté j'ai pu les dissocier que par des broche distinctes et avec un buggs de fonctionnement.
Mes capteurs sont des DS18S20 )> Si ça vous intéresse j'ai une traduction du datasheat mais je ne trouve pas le moyen de la joindre.
manumanu:
Je pense avoir compris => le DS18x20 est un capteur intelligent qui dialogue et qui a donc besoins d'une structure d'échange et search me permet d'initialiser pour organiser tout cela.
Pour l'adresse on peut voir ça comme une adresse "MAC" si je peut dire.
Je vais donc utiliser la seconde méthode pour l'utilisation de mes capteurs.
Je vais chercher le moyen de les identifier par leurs adresse sur une seul broche. (pas facile je vais encor ramer un moment !!)
Comme vous avez pu le constaté j'ai pu les dissocier que par des broche distinctes et avec un buggs de fonctionnement.
Mes capteurs sont des DS18S20 )> Si ça vous intéresse j'ai une traduction du datasheat mais je ne trouve pas le moyen de la joindre.
le bus 1W est prevu pour accepter un nombre importants de dispositifs
le "scanner" 1W exposé plus haut permet de recuperer sans probleme les adresses presentées
le seul composant externe requis est une resistance de 4.7K (typique)
de plus les DS18x20 peuvent etre alimentés en mode "parasitic power"
ce qui consiste simplement à relier VCC et GND comme sur le schema lire ça
Merci!
je les ais effectivement branchés en mode parasite en suivant le datasheat.
Ce capteur très perfo. en présentation n'est pas de tout repos pour la mise en place.
Je suis revenu en arrière sur mon programme.
L'accès au données de la puces sont assez simple par les instructions mais leurs exploitations dans le programme demande de la méthode => je réfléchis a un moyen de transformer leurs adresse en nom comme ex T°intérieur pour les identifier. => je vais devoir potassé et si ça vas pas je ferais appel a vous pour m' aiguiller.
je manquerais pas de faire des retours de tout ça.
ps Comment on fait pour passer un topic en résolu?
manumanu:
L'accès au données de la puces sont assez simple par les instructions mais leurs exploitations dans le programme demande de la méthode => je réfléchis a un moyen de transformer leurs adresse en nom comme ex T°intérieur pour les identifier. => je vais devoir potassé et si ça vas pas je ferais appel a vous pour m' aiguiller.
je manquerais pas de faire des retours de tout ça.
ps Comment on fait pour passer un topic en résolu?
avant de passer en résolu , attend déjà d'avoir trouvé/verifié la meilleure methode pour relier un capteur 1W à "un nom"
decouvre déjà les 1W et tu va vite découvrir que ce point n'est pas aussi trivial "que ça"
ça fait partie des choix de methode. 8)
Pourquoi avoir pris des DS18S20 plutot que des DS18B20 ?
Une reponse dun genre : "parce que j'en ai une caisse pleine ! " etant une reponse parfaitement admise/ compréhensible
Voila ou j'en suis en revenant en arrière sur une seul broche.
C'est le résultat du serial monitor.
PROGRAMME**
*** Liste des elements presents sur le bus VOIE A ***
Numero 1: capteur avec code: 10 C0 11 C4 02 08 00 DB
Type de capteur : DS18S20.
Numero 2: capteur avec code: 10 F8 C9 C2 02 08 00 FE
Type de capteur : DS18S20.
Numero 3: capteur avec code: 10 6C 4D C3 02 08 00 C8
Type de capteur : DS18S20.
3 capteur(s) detecte(s) sur ce bus VOIE A
********** Recherche terminee - fin de liste *********
!!)
comme sur le schema
