Go Down

Topic: [resolu] Aide à la comprehension de "search". (Read 5941 times) previous topic - next topic

manumanu

Jan 05, 2015, 01:31 pm Last Edit: Jan 08, 2015, 01:31 pm by manumanu
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))

Code: [Select]
if ( !capteurA.search(adresseLA))                                                         {                                                         
   Serial.println("===============Dernier capteur de mesures.==============");
   Serial.println(" ");
    capteurA.reset_search();
    delay(1000);
    return;
}


En vous remerciant de votre attention.
"Apprends moi ce que tu sais je t'apprendrais ce que je sais en nous serons intelligent"

icare

Bonjour,
si la condition
Code: [Select]
capteurA.search(adresseLA)
 est fausse, il fait :
Code: [Select]
Serial.println("===============Dernier capteur de mesures.==============");
Serial.println(" ");
capteurA.reset_search();
delay(1000);
 return;

Pour plus d'infos, il faut :
1) une boule de cristal ou
2) ton code
2B OR NOT(2B) = FF
Arduino 1.0.5 à 1.8.5 + gEdit + Ubuntu 18.04 LTS

fdufnews

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: http://www.pjrc.com/teensy/td_libs_OneWire.html

manumanu

Merci à vous.
Je vais essayer d'envoyer le code entier.
oui c'est un OneWire

Donc je ne comprend pas la façon dont il travail avec les variables qui sont des adresses capteurs renseigner dans un tableau "adresse".

Donc si j'ai bien compris ICARE "search" vas comparer l'objet "capteurA" avec le tableau "adresseLA" ?

Encore une question à quoi sert ce symbole "!" dans la ligne?

Ps: pouvez vous m'indiquer comment réinscrire mon code => je n'ai plus l'icône pour le faire quant je répond ??
"Apprends moi ce que tu sais je t'apprendrais ce que je sais en nous serons intelligent"

icare

Re,
Encore une question à quoi sert ce symbole "!" dans la ligne?
Il suffit de regarder dans Learning -> Reference
2B OR NOT(2B) = FF
Arduino 1.0.5 à 1.8.5 + gEdit + Ubuntu 18.04 LTS

manumanu

Voici mon programme.
en partie car trop long pour le forum!

Code: [Select]
//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(" ");
}
"Apprends moi ce que tu sais je t'apprendrais ce que je sais en nous serons intelligent"

manumanu

Merci
j'ai consulter le lien => j'y pensait pas!
j'ai trouver la même par "Mon club elec" = traduit en français c'est super.

D'accord pour "!" c'est équivalant de "différent de"

if ( !capteurA.search(adresseLA)) dans ce cas pourquoi l'ecrire comme ca et pas de cette facon
if (capteurA != adresseLA); et utiliser search ?
"Apprends moi ce que tu sais je t'apprendrais ce que je sais en nous serons intelligent"

fdufnews

! 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.

Code: [Select]
if (!capteurA.search(adresseLA)){}
exécute le code dans les accolades si search ne trouve plus de capteur sur le bus.

manumanu

Voici la partie du programme dans la quelle est intégré cette ligne.
Code: [Select]
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" */


"Apprends moi ce que tu sais je t'apprendrais ce que je sais en nous serons intelligent"

manumanu

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?
"Apprends moi ce que tu sais je t'apprendrais ce que je sais en nous serons intelligent"

manumanu

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
"Apprends moi ce que tu sais je t'apprendrais ce que je sais en nous serons intelligent"

fdufnews

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.

fdufnews

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.

manumanu

#13
Jan 05, 2015, 05:42 pm Last Edit: Jan 05, 2015, 05:44 pm by manumanu
C'est un-peu plus claire!!

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.
"Apprends moi ce que tu sais je t'apprendrais ce que je sais en nous serons intelligent"

Artouste

...

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
Code: [Select]

#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;
  }

}




Go Up