Arduino Nano Füllstandmelder Mesh NRF24I01

Hallo alle zusammen,
ich bin neu im Thema Arduino und bin fasziniert von den Möglichkeiten.

Kleinere Versuche habe ich bereits mit Erfolg realisiert.
Bei meinem jetzigen Projekt komme ich leider nicht weiter.

Es handelt sich um drei Füllstandsmelder die bei vollen Behältern ein Signal an eine Meldeeinheit funken diese dann eine bestimmte LED per Relay anschaltet.

Somit möchte ich gerne über 3 Sender Nanos (montiert an Behälter 1, 2 und 3) per NRF24l01 Modul ein Signal an ein Empfänger Nano senden. Die Sender Nanos bekommen auf einem Digital Pin ein HIGH Signal sobald der kapazative Sensor merkt das der Behälter voll ist. Das HIGH Signal wird dann per NRF24l01 Modul an den Empfänger Nano weitergeleitet. Der Empfänger Nano schaltet dann auf einer Relaiskarte das entsprechende Relay auf HIGH um eine LED aufleuchten zu lassen. Wird der Behälter entleert sollte sich das ganze System natürlich wieder zurücksetzen, da der Sensor kein Signal mehr gibt.

Das ganze klappt mit einem Sender und einem Empfänger Nano echt gut.

Damit ich nicht jeweils immer einen Sender und Empfänger pro Behälter benötige wollte ich alle Sender mit einem Empfänger kommunizieren lassen.

Da komme ich nicht ganz weiter. Ich habe den unten stehenden Code im Netz gefunden. Dieser scheint auch keine Probleme wie zum Beispiel Überschneidungen der Nachrichten zu machen.

Aufgrund meiner mangelnden Kenntnisse bekomme ich den Code aber keineswegs auf mein Vorhaben umgeschrieben. Im Grunde möchte ich ein erhaltenes HIGH per Funk weiterleiten und dann auf die Relaiskarte ausgeben.

Würde mich über jede Hilfe freuen.

Sender 1, Sender 2, Sender 3 (Adressen jeweils angepasst)

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

#include <Wire.h>

int address = 0x28; // 28 is the address
byte byte1, byte2, byte3, byte4;

RF24 radio (9, 10);



struct dataStruct{
float p1;
float t1;
float s1;
}transmitter1_data;

unsigned char ADDRESS0[5]  =
{
  0xb1,0x43,0x88,0x99,0x45
}; // Define a static TX address
//just change b1 to b2 or b3 to send to other pip on resciever

void setup()
{
 // Wire.begin();
  radio.begin();
  Serial.begin(115200);
  printf_begin();
  radio.setRetries(15,15);
  radio.enableDynamicPayloads();
  radio.setDataRate(RF24_250KBPS);
  radio.openWritingPipe(ADDRESS0);
  radio.openReadingPipe(0,ADDRESS0);
  radio.stopListening();
radio.printDetails();
}

void loop()
{
 /*
   Wire.requestFrom(address, 4); // byte is 4;

  if (Wire.available()<=4 <=4) {//
    byte1 = Wire.read();
    byte2 = Wire.read();
    byte3 = Wire.read();
    byte4 = Wire.read();
  }

  long unsigned p_counts = (long unsigned)byte1 << 8
                           | (long unsigned)byte2;
  long unsigned t_counts = (long unsigned)byte3 << 8
                           | (long unsigned)byte4;
                           
   p1[0] = ((p_counts%16384-1638.0)/13107.0*20.0)-10.0;
   t1[0] = ((t_counts/32.0*200.0)/2047.0-50.0);
   s1[0] = (p_counts/16384);
   
   */
   transmitter1_data.p1=1002.36;
   transmitter1_data.t1=27.33;
   transmitter1_data.s1=15.9;
   
   bool ok=radio.write(&transmitter1_data, sizeof(transmitter1_data));

   
     if(ok)
       {
 
          Serial.println("Pipe 1");
          Serial.println(transmitter1_data.p1);
          Serial.println(transmitter1_data.t1);
          Serial.println(transmitter1_data.s1);
         
       }
      else
       {
          Serial.println("it failed to send");
       }
   delay(1000);
   
   
   
   
   
}

Empfänger

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

RF24 radio (9, 10);

#define PLOAD_WIDTH  32  // 32 unsigned chars TX payload
byte pip;
byte pload_width_now;
byte newdata;
unsigned char rx_buf[PLOAD_WIDTH]= {0};
struct dataStruct1{
float p1;
float t1;
float s1;
}transmitter1_data;

struct dataStruct2{
float p1;
float t1;
float s1;
}transmitter2_data;

struct dataStruct3{
float p1;
float t1;
float s1;
}transmitter3_data;

unsigned char ADDRESS2[1]= {0xb2};	
unsigned char ADDRESS3[1]= {0xb3};	
unsigned char ADDRESS4[1]= {0xb4};	
unsigned char ADDRESS5[1]= {0xb5};	


unsigned char ADDRESS1[5]  =
{
   0xb1,0x43,0x88,0x99,0x45
}; // Define a static TX address

unsigned char ADDRESS0[5]  =
{
  0xb0,0x43,0x88,0x99,0x45
}; // Define a static TX address

void setup()
{
 
  radio.begin();
   printf_begin();
  Serial.begin(115200);
  radio.setDataRate(RF24_250KBPS);
 radio.enableDynamicPayloads();
  radio.openWritingPipe(ADDRESS0);
  radio.openReadingPipe(0,ADDRESS0);
   radio.openReadingPipe(1,ADDRESS1);
   radio.openReadingPipe(2,ADDRESS2);
   radio.openReadingPipe(3,ADDRESS3);
   radio.openReadingPipe(4,ADDRESS4);
   radio.openReadingPipe(5,ADDRESS5);

   
  radio.startListening();
  radio.printDetails();
delay(1000);
}

void loop()
{
 if ( radio.available(&pip) )
    {

      // Fetch the payload, and see if this was the last one.
      pload_width_now = radio.getDynamicPayloadSize();

      // If a corrupt dynamic payload is received, it will be flushed
      if(!pload_width_now){
       
      }
        else
        {
       
      radio.read( rx_buf, pload_width_now );

     newdata=1;

      // Spew it
      Serial.print(F("Data on pip= "));
      Serial.print(pip);
      Serial.print(F(" Got data size="));
      Serial.print(pload_width_now);
      Serial.print(F(" data="));
      for(byte i=0; i<pload_width_now; i++)
      {
          Serial.print(" ");
          Serial.print(rx_buf[i]);                              // print rx_buf
      }
      Serial.print(" ");
      }
    }
   if(newdata==1)
  {
  newdata=0;

if(pip==1&&pload_width_now==sizeof(transmitter1_data))
  {
   memcpy(&transmitter1_data, rx_buf, sizeof(transmitter1_data));
     
 
         
          Serial.print(" Pressure//temp//status ");
          Serial.print(transmitter1_data.p1);
          Serial.print(" // ");
          Serial.print(transmitter1_data.t1);
          Serial.print(" // ");
          Serial.print(transmitter1_data.s1);
   
   }
   
   if(pip==2&&pload_width_now==sizeof(transmitter2_data))
  {
   memcpy(&transmitter2_data, rx_buf, sizeof(transmitter2_data));
     
 
         
         
          Serial.print(" Pressure//temp//status ");
          Serial.print(transmitter2_data.p1);
          Serial.print(" // ");
          Serial.print(transmitter2_data.t1);
          Serial.print(" // ");
          Serial.print(transmitter2_data.s1);
   
   }
   
   if(pip==3&&pload_width_now==sizeof(transmitter3_data))
  {
   memcpy(&transmitter3_data, rx_buf, sizeof(transmitter3_data));
     
 
         
         
          Serial.print(" Pressure//temp//status ");
          Serial.print(transmitter3_data.p1);
          Serial.print(" // ");
          Serial.print(transmitter3_data.t1);
          Serial.print(" // ");
          Serial.print(transmitter3_data.s1);
   
   }



Serial.println("");
  }

delay(100);

}

Hallo,

Mein Brauser hat das gefunden, ich denke das könnte Dir helfen
link

Heinz

Hallo Heinz,

vielen Dank für den schnellen Support.

Habe mal versucht den Code aus dem Beispiel auf meine Anwendung zuzuschneiden.
Leider komme ich an einer Stelle nicht weiter. Wie kann ich beim Empfänger die If/Else-Funktionen den Clientnummern zuordnen?
So dass wenn zum Beispiel Clientnummer 1 (Sender 1) ein High Signal sendet auch LED 1 angesprochen wird.

LG Niklas

Sender 1, 2 und 3

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

RF24 radio(9, 10);                
static const uint64_t pipe[6] = {0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL, 0xF0F0F0F0C3LL, 0xF0F0F0F0B4LL, 0xF0F0F0F0A5LL, 0xF0F0F0F096LL};
byte ClientNummer = 3; // Mögliche Werte: 1-6
const byte address[6] = "00002";  
byte button_pin = 2;              

void setup() {
  Serial.begin(9600);             
  pinMode(button_pin, INPUT);     
  radio.begin();                  
  radio.setDataRate(RF24_250KBPS);
  radio.openWritingPipe(pipe[ClientNummer-1]); // Setzen der Sendeadresse zur Übermittlung der Daten
  radio.setPALevel(RF24_PA_HIGH); 
  radio.stopListening();          
}

void loop()
{
button_status = digitalRead(button_pin);
if(button_status == HIGH)
{
const char text[] = "Sensor Status ist HIGH";
radio.write(&text, sizeof(text));                  
}
else
{
const char text[] = "Sensor Status ist LOW";
radio.write(&text, sizeof(text));                  
}
radio.write(&button_status, sizeof(button_status));  
delay(1000);
}

Empfänger:

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

static const uint64_t pipe[6] = {0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL, 0xF0F0F0F0C3LL, 0xF0F0F0F0B4LL, 0xF0F0F0F0A5LL, 0xF0F0F0F096LL};
uint8_t ClientNummer;
byte pipeNr = 0;

  RF24 radio(9, 10);                   
  byte button_status = 0;                
  int led_pin = 2;                     

void setup() {
  pinMode(2, OUTPUT);             // LED Behälter 1
  pinMode(3, OUTPUT);             // LED Behälter 2
  pinMode(4, OUTPUT);             // LED Behälter 3
  Serial.begin(9600);
  radio.begin();
  radio.setDataRate(RF24_250KBPS);     
  for (pipeNr = 0; pipeNr < 6; pipeNr++){
    radio.openReadingPipe(pipeNr, pipe[pipeNr]);   
    delay(50);
   }
  radio.setPALevel(RF24_PA_MAX);       
  radio.startListening();              
  }

void loop() {
if (radio.available(&ClientNummer))  
  {
    Serial.print("Clientnummer:");Serial.println(ClientNummer);
    
    char text[32] = "";  
    radio.read(&text, sizeof(text));   
    radio.read(&button_status, sizeof(button_status));    
    if(button_status == HIGH)
    {
    digitalWrite(2, HIGH);// LED Behälter 1
    Serial.println(text);
    }
    else
    {
    digitalWrite(2, LOW);// LED Behälter 1
    Serial.println(text);}
    }



    if(button_status == HIGH)
    {
    digitalWrite(3, HIGH);// LED Behälter 2
    Serial.println(text);
    }
    else
    {
    digitalWrite(3, LOW);// LED Behälter 2
    Serial.println(text);}
    }


    if(button_status == HIGH)
    {
    digitalWrite(4, HIGH);// LED Behälter 3
    Serial.println(text);
    }
    else
    {
    digitalWrite(4, LOW);// LED Behälter 3
    Serial.println(text);}
    }
    
    delay(100);
    }

Hallo,

ich kenn das exotische Teil eigendlich nicht, wurde das ehr mit einnem ESP über WLan mitTCP machen.

ich habe mich jetzt nicht mit den Beispielen auf der Seite beschäftigt, ich könnte mir aber vorstellen das der Empfänger eine Info bekommt woher das empfange Telegramm stammt. In Deinem Fall also die client Nummer. Wenn dem nicht so ist und es da nichts für gibt könnte der Sender bei den Nutzdaten seine Nummer mit senden. Dann musst Du die halt zunächst auswerten und dann die zugehärige LED ansteuern.

Aber ich denke die Info muss es schon geben.

Heinz

bild1:

Dieser scheint auch keine Probleme wie zum Beispiel Überschneidungen der Nachrichten zu machen.

Bist du dir da sicher und wie verhinderst du das ?
Bzw. wie hast du das festgestellt ?

Wenn mehrere Sender gleichzeitig senden, gibt es immer Überschneidungen.