Detecter 2 temperatures NRF24l01+ sur un recepteur mais données qui se mélangent

Bonjour à vous,

Je tiens à préciser que je suis débutant, j'avance à petit pas.
Voici mon projet, j'ai une sonde pour la température extérieur avec arduino nano, ds18b20 et nrfl01+ et une autre pour l'eau (même montage) et un récepteur composé d'un arduino uno, un nrf24l01+ et un ecran I2C 20x4.
Mon problème est le suivant, le uno réceptionne bien les températures mais n'arrivent pas à les mettre au bon endroit.
La valeur float temperature1 devrait être réceptionnée en float temperature1 et s'afficher pour TempEau et float temperature devrait être réceptionnée en float temperature et s'afficher pour TempExt.
Mais là, les valeurs sont mélangées et ne sont pas attribuées aux bonnes variables.
J'ai ajouté un delay à la fin du void loop mais le résultat n'est pas top.
Je viens d'y passer quelques journées mais là je suis sec, pourriez vous m'aider?
Par avance, merci

Je vais essayer de poster mes lignes de codes, qui ne sont pas toujours bien organisées:

Recepteur uno

#include <Wire.h>
#include <LiquidCrystal_I2C.h>  
#include <VirtualWire.h> 
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#include "printf.h" 

LiquidCrystal_I2C lcd(0x27, 20, 4);  

RF24 radio(9,10);

//address through which two modules communicate.
 const byte address[][6] = {"00001", "00002","00003"};

float temperature, temperature1;
float temperaturedeg = 1;

 void setup()  
 { 
  digitalWrite(2, LOW);
 // initialise l'afficheur LCD
  lcd.begin();
 // efface l'ecran et place le curseur en 0,1
  lcd.clear();
 // allumer retroeclairage
  lcd.backlight();
 // activer l'affichage
  lcd.display(); 
  lcd.setCursor(0,0);  
  lcd.print("TempExt:"); // print a simple message  
  lcd.setCursor(0,2);  
  lcd.print("TempEau:");
  
  Serial.begin(9600);  
        radio.begin();
      radio.openReadingPipe(0, address[1]);
      radio.openReadingPipe(1, address[1]);
      radio.setPALevel(RF24_PA_MIN);
      radio.startListening();
 delay(1000);
  }  
 void loop()  
 {
   //Read the data if available in buffer
  if (radio.available())
 {
      lcd.clear();
      radio.read(&temperature, sizeof(temperature));
      lcd.setCursor(0,0);  
      lcd.print("TempExt:");
      lcd.setCursor(8,0);
      Serial.print("ext"); 
      Serial.print(temperature);  
      lcd.print(temperature, 1);
      Serial.println(temperature);
      lcd.setCursor(0,2);
      radio.read(&temperature1, sizeof(temperature1)); 
      lcd.print("TempEau:");
      lcd.setCursor(8,2);
      Serial.print("eau"); 
      Serial.print(temperature1); 
      lcd.print(temperature1, 1);
       }
     
        
 if (temperature < temperaturedeg) { //Si la température lue est inférieure à la température de consigne, on active le relais

lcd.setCursor(0,1); //on place le curseur de l'écran LCD au début de la 1ère ligne
lcd.print("Mode hors gel");

}
    
    else
{
 
lcd.setCursor(0,1); //on place le curseur de l'écran LCD au début de la 1ère ligne
lcd.print("Mode normal  ");

}
 
 delay(1000);
 }

Emetteur TempEau

#include <Wire.h>
#include <DallasTemperature.h>
#include <OneWire.h>
#include <nRF24L01.h>
#include <RF24.h>
#include <SPI.h>
#include <nRF24L01.h>
#include <printf.h>

// definition de la sonde dallas
#define ONE_WIRE_BUS 2

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
DeviceAddress Sonda1 = { 0x28, 0x1D, 0x60, 0x45, 0x92, 0x06, 0x02, 0x0E };

RF24 radio(9,10); // CE, CSN
    //const byte address[6] = "00001";
    const byte address[][6] = {"00001", "00002","00003"};

// definition de la constante temp pour envoi
float temperature1;


void setup(){
   Serial.begin(9600);
      radio.begin();
      radio.openWritingPipe(address[1]);
      radio.setPALevel(RF24_PA_MIN);
      radio.stopListening();
  delay(1000);
  }

void loop(){

sensors.requestTemperatures();

  Serial.print("TempEau  : ");
  Serial.print(" ");
  Serial.print(sensors.getTempC(Sonda1));
  Serial.println(" ");
    
if (temperature1<-124.00){

Serial.print("Erreur mesure");
sensors.requestTemperatures();

}
else
{

float temperature1 = sensors.getTempCByIndex(0);
radio.write(&temperature1, sizeof(temperature1));
delay(10);
}
}

Emetteur TempExt

#include <Wire.h>
#include <DallasTemperature.h>
#include <OneWire.h>
#include <RF24.h>
#include <SPI.h>
#include <nRF24L01.h>
#include <printf.h>

// definition de la sonde dallas
#define ONE_WIRE_BUS 2

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
DeviceAddress Sonda0 = { 0x28, 0x53, 0x4F, 0x45, 0x92, 0x13, 0x02, 0xEC };

RF24 radio(9,10); // CE, CSN
    //const byte address[6] = "00001";
    const byte address[][6] = {"00001", "00002","00003"};

// definition de la constante temp pour envoi
float temperature=sensors.getTempC(Sonda0);



void setup(){
   Serial.begin(9600);
      radio.begin();
      radio.openWritingPipe(address[1]);
      radio.setPALevel(RF24_PA_MIN);
      radio.stopListening();
  delay(1000);
  }

void loop(){

sensors.requestTemperatures();

  Serial.print("Temp ext: ");
  Serial.print(" ");
  Serial.print(sensors.getTempC(Sonda0));
  Serial.println(" ");
    
  
if (temperature<-124.00){

Serial.print("Erreur mesure");
sensors.requestTemperatures();

}
else
{

float temperature = sensors.getTempCByIndex(0);
radio.write(&temperature, sizeof(temperature));
delay(10);
}
}

&

Première remarque : à quoi cela sert-il d'envoyer des températures à 10 ms d'intervalle ?

Deuxièmement tu ne tiens pas compte du N° de pipe dans la réception.
Tu te contentes de supposer que le premier arrivera avant le deuxième, ce qui est probablement faux.

Bonjour hbachetti,

Le delay de 10 ms est arbitraire, j'aurais peu mettre plus.
Par contre pour le pipe, je me suis pris la tête sur le sujet, fais des tonnes de forums mais je n'ai pas vraiment trouvé la clé pour l'utiliser correctement.
Je sais que je suis limité à 6 nrf24L01+, mais après c'est le flou.
Je pensais que nommer une variable suffisait pour le mettre au bon endroit quelque soit l'ordre d'arrivée de celles-ci.

Merci pour ton aide à venir.

Je ne suis pas un grand connaisseur de la lib RF24 mais :

bool available(uint8_t* pipe_num);

Devrait te permettre de récupérer le N° de pipe émetteur.

Entre nous, quand ta réception fonctionnera, passe à une période d'émission de 15 minutes.
La température est une grandeur qui varie lentement, et moins d'ondes ne peut pas faire de mal.
Par contre pour les essais, 1 ou 2 secondes seront certainement plus pratiques.

hbachetti:
Je ne suis pas un grand connaisseur de la lib RF24 mais :

bool available(uint8_t* pipe_num);

Devrait te permettre de récupérer le N° de pipe émetteur.

https://www.instructables.com/id/NRF24L01-Multiceiver-Network/

Je me suis basé sur ce tuto mais je galere avec l'identification des Pipes:

J'ai essayé avec une variable qui envoie un variable char et là je n'ai eu aucun souci.
La lecture se faisait parfaitement.
J'ai adapté le programme pour la température et des variables float et la c'est la cata.

hbachetti:
Entre nous, quand ta réception fonctionnera, passe à une période d'émission de 15 minutes.
La température est une grandeur qui varie lentement, et moins d'ondes ne peut pas faire de mal.
Par contre pour les essais, 1 ou 2 secondes seront certainement plus pratiques.

Le but est de passer en arduino pro avec un fonctionnement sur pile, donc un envoi tout les 15 mn

Si tu reçois le N° de pipe émetteur dans la variable dont tu passes l'adresse à radio.available, il devrait être facile d'afficher ce N° sur la console.

Au passage il y a un bug, tu passes deux fois le même N° de noeud.

radio.openReadingPipe(0, address[1]);
radio.openReadingPipe(1, address[1]);

Donc tu devrais obtenir 0 ou 1.

Je viens de corriger avec cela:

radio.openReadingPipe(0,rAddress[0]);
radio.openReadingPipe(1,rAddress[1]);

Par contre avec un seul emetteur les deux variables du recepteur sont remplies par la variable de l'emetteur.

Je n'y comprend plus rien.

Voici le code corrigé de l'emetteur:

#include <Wire.h>
#include <DallasTemperature.h>
#include <OneWire.h>
#include <RF24.h>
#include <SPI.h>
#include <nRF24L01.h>
#include <printf.h>

// definition de la sonde dallas
#define ONE_WIRE_BUS 2
#define WHICH_NODE 1 


OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
DeviceAddress Sonda0 = { 0x28, 0x53, 0x4F, 0x45, 0x92, 0x13, 0x02, 0xEC };

RF24 radio(9,10); // CE, CSN
 const uint64_t wAddress[] = {0x7878787878LL, 0xB3B4B5B6F1LL, 0xB3B4B5B6CDLL};
 const uint64_t PTXpipe = wAddress[ WHICH_NODE - 1 ];

float temperature;

void setup(){
   Serial.begin(9600);
      radio.begin();
      radio.setChannel(108); 
      radio.openWritingPipe(PTXpipe);
      radio.setPALevel(RF24_PA_MIN);
      radio.startListening();
  delay(1000);
  }

void loop(){

sensors.requestTemperatures();

  Serial.print("Temp ext: ");
  Serial.print(" ");
  Serial.print(sensors.getTempC(Sonda0));
  Serial.println(" ");
    
  
if (temperature<-124.00){

Serial.print("Erreur mesure");
sensors.requestTemperatures();

}
else
{

float temperature = sensors.getTempCByIndex(0);
radio.write(&temperature, sizeof(temperature));
delay(1000);
}
}

Le problème se situe forcément au niveau récepteur.
Si tu ne tiens pas compte de pipe_num c'est normal.

    uint8_t pipe_num;
    if ( radio.available(&pipe_num) )
        radio.read(&temperature, sizeof(temperature));

        Serial.print("pipe_num: "); Serial.println(pipe_num);

        if (pipe_num == 0) {
          //  faire ceci
        }
        else  {
          //  faire cela
        }
    }

J'ai déclaré trois adresses pour mes trois nrf :
0x7878787878LL, 0xB3B4B5B6F1LL, 0xB3B4B5B6CDLL

par contre j'ai du mal avec le pipe, qui est le récepteur et comment l'attribuer et comment nommer l’émetteur 1 puis le 2.

Je pensais que la commande :
radio.openReadingPipe(0,rAddress[0]);
radio.openReadingPipe(1,rAddress[1]);

suffisait pour aiguiller les données et que les variables faisaient le reste pour mettre cela au bon endroit.

Voici le premier code que j'ai utilisé et qui a focntionné parfaitement
Un emetteur envoyé Hello World et l'autre Hello World2 et le recepteur les receptionnait au bon endroit

Emetteur 1

#include <nRF24L01.h>
#include <RF24.h>
#include <SPI.h>
  #include <nRF24L01.h>
#include <printf.h>

     /*
    * Arduino Wireless Communication Tutorial
    *     Example 1 - Transmitter Code
    *                
    * by Dejan Nedelkovski, www.HowToMechatronics.com
    * 
    * Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
    */
    #include <SPI.h>
    #include <nRF24L01.h>
    #include <RF24.h>
    
    RF24 radio(9,10); // CE, CSN
    //const byte address[6] = "00001";
    const byte address[][6] = {"00001", "00002","00003"};
    
    void setup() {
      Serial.begin(9600);
      radio.begin();
      radio.openWritingPipe(address[1]);
      radio.setPALevel(RF24_PA_MIN);
      radio.stopListening();
    }
    void loop() {
      const char text2[] = "Hello World2";
      radio.write(&text2, sizeof(text2));
      Serial.println(text2);
      delay(1000);
    }

Emetteur 2

    /*
    * Arduino Wireless Communication Tutorial
    *     Example 1 - Transmitter Code
    *                
    * by Dejan Nedelkovski, www.HowToMechatronics.com
    * 
    * Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
    */
    #include <SPI.h>
    #include <nRF24L01.h>
    #include <RF24.h>
    
    RF24 radio(9,10); // CE, CSN
    //const byte address[6] = "00001";
    const byte address[][6] = {"00001", "00002","00003"};
    
    void setup() {
      Serial.begin(9600);
      radio.begin();
      radio.openWritingPipe(address[1]);
      radio.setPALevel(RF24_PA_MIN);
      radio.stopListening();
    }
    void loop() {
      const char text[] = "Hello World";
      radio.write(&text, sizeof(text));
      Serial.println(text);
      delay(1000);
    }

Recepteur

        /*
    * Arduino Wireless Communication Tutorial
    *       Example 1 - Receiver Code
    *                
    * by Dejan Nedelkovski, www.HowToMechatronics.com
    * 
    * Library: TMRh20/RF24, https://github.com/tmrh20/RF24/
    */
    #include <SPI.h>
    #include <nRF24L01.h>
    #include <RF24.h>
    RF24 radio(9,10); // CE, CSN
    
    //const byte address[6] = "00001";
    const byte address[][6] = {"00001", "00002","00003"};
    
    void setup() {
      Serial.begin(9600);
      radio.begin();
      radio.openReadingPipe(0, address[1]);
      radio.openReadingPipe(1, address[1]);
      radio.setPALevel(RF24_PA_MIN);
      radio.startListening();
    }
    
    void loop() {
      if (radio.available()) {
        char text[32] = "";
        char text2[32] = "";
        radio.read(&text, sizeof(text));
        Serial.println(text);
        delay(500);
        radio.read(&text2, sizeof(text2));
        Serial.println(text2);
        delay(500);
      }
    }

Pur hasard. Tu émettais avec une période de 1 seconde.

Il n'y avait toutes les chances que le 1 soit reçu avant le 2 et ainsi de suite à tour de rôle.
Avec une période de 10 ms, tu as beaucoup plus de chances que cela se mélange.

Fais la modif proposée en #9.

Que dois je mettre à la place de pipe num.
Je n'arrive pas à savoir quelle valeur mettre

hbachetti:
Le problème se situe forcément au niveau récepteur.
Si tu ne tiens pas compte de pipe_num c'est normal.

    uint8_t pipe_num;

if ( radio.available(&pipe_num) )
        radio.read(&temperature, sizeof(temperature));

Serial.print("pipe_num: "); Serial.println(pipe_num);

if (pipe_num == 0) {
          //  faire ceci
        }
        else  {
          //  faire cela
        }
    }

hbachetti:
Le problème se situe forcément au niveau récepteur.
Si tu ne tiens pas compte de pipe_num c'est normal.

    uint8_t pipe_num;

if ( radio.available(&pipe_num) )
        radio.read(&temperature, sizeof(temperature));

Serial.print("pipe_num: "); Serial.println(pipe_num);

if (pipe_num == 0) {
          //  faire ceci
        }
        else  {
          //  faire cela
        }
    }

Serial.print("pipe_num: "); Serial.println(pipe_num);

Qu'affiche cette ligne ?

Avec 10 ms de période d'émission ça risque de défiler vite.
Augmente la valeur.

hbachetti:
Serial.print("pipe_num: "); Serial.println(pipe_num);

Qu'affiche cette ligne ?

Avec 10 ms de période d'émission ça risque de défiler vite.
Augmente la valeur.

pipe_num = 0

Que dois je mettre à la place de pipe num.
Je n'arrive pas à savoir quelle valeur mettre

C'est radio.available(&pipe_num) qui affecte une valeur à pipe_num.
Tu n'as rien à faire, juste consulter la valeur qui doit être normalement 0 ou 1.
Ensuite tu affiches sur le LCD en fonction de pipe_num, sur la ligne correspondante.

pipe_num = 0

Étonnant. Tu es sûr que les deux émetteurs tournent et on un N° de pipe différent ?

Si tu ne t'en sort pas avec pipe_num et consorts, il y a une autre méthode, plus générale.

Tu mets une étiquette à ta valeur. Par exemple pour la temp Teau, tu mets l'étiquette 1, et pour Text tu mets 2.
Comment faire ça ? Tu déclares dans tous tes programmes une structure :

struct ValeurEtiquetee {
  int  etiquette;
  float valeur;
};

Dans les programmes émetteurs, tu envoies la struct complète (au lieu de la T° seule)

  struct ValeurEtiquetee ve;
  ve.id = 1; // ou 2 selon l'émetteur
  ve.temperature = sensors.getTempCByIndex(0);
  radio.write ( &ve, sizeof(ve) );

Dans le recepteur, si radio.avalaible(), tu reçois une struct complète, et tu tries selon l'étiquette.

  struct ValeurEtiquetee ve;
  radio.read ( &ve, sizeof(ve) );
  if ( ve.etiquette == 1 ) // c'est Teau
    Teau = ve.temperature;
  else if ( ve.etiquette == 2 ) // c'est Text
    Text = ve.temperature;
  else ... // houlà, c'est quoi ce truc ?

Dans les 2 émetteurs :
radio.openWritingPipe(address[1]);

Le numéro de pipe est le même :confused:

hbachetti:
Dans les 2 émetteurs :
radio.openWritingPipe(address[1]);

Le numéro de pipe est le même :confused:

Si je change le numéro de pipe, le recepteur ne reçois qu'un pipe...

Demain je vais essayer ce que vous me recommandez.

Je vais repartir sur le programme avec les variables char et l'envoi de mots pour faire simple