Praxisbericht Rolladensteuerung mit NRF24L01 2,4 GHz und Arduino Nano

[Dogger]

Ja hat gestern dann auch mit dem Text funktioniert wenn ich ihm beim Sender mit eingebunden habe.
Am Montag geht es dann warscheinlich weiter.

 

[BAXL]

@Dogger
Dank Deiner Mithilfe konnte ich den "Fehler" in dem Programmbeispiel im NRF24 Thema finden und beheben. Du hattest Recht, beim Minimnal-Empfängerprogramm waren noch die Zeilen enthalten, die einen Text erhalten (wollen), das habe ich jetzt herausgelöscht. Nachfolgende Interessenten sollten da dann nicht mehr drüber stolpern.

 

[Dogger]

@BAXL
Gibt es eine Möglichkeit den ESP8266 mit dem NRF24L01 über W-Lan zu verbinden ?
Ich hätte auch beides hier..
Ist vielleicht ein bisschen weit voraus gegriffen aber ich würde gerne beide später benutzen.
Entweder der mit dem Arduino + NRF24L01 per Leitung auf ein ESP8266 der weitere 4 andere steuert oder wenn möglich direkt über W-Lan auf die ESP8266 zugreifen.
Der ESP ist einfach so schön klein und stromsparend ( braucht halt kein Arduino im Hintergrund ) .

PS: Der anschluss von dem Arduino NANO ist auch nicht richtig ( D13 sitzt auf der anderen Seite )
Aber den Fehler hat h.t.mechatronics auch gemacht ;-)

 

[BAXL]

Hallo @Dogger

mit dem WAMOS D1 mini (verkleinerter ESP8266) experimentiere ich auch gerade. Der hat außer der Größe und der Stromaufnahme zusätzlich noch mehr Arbeitsspeicher. Leider kann man nicht einen Arduino nehmen, den NRF24l01 anklemmen und direkt mit einem ESP8266 kommunizieren. Nebenbei bemerkt kann der ESP8266 sowieso, ohne weiteres Zusatzmodul nur ins WLAN. Man kann damit aber nicht auf so einfache Weise, wie eben mit dem NRF24, Controllermodule untereinander kommunizieren lassen. Soweit bin ich aber auch noch nicht gekommen. Ich habe auf anderen Seiten gesehen, dass dort der NRF24l01 zusätzlich an einen ESP8266 bzw. WAMOS D1 mini angeschlossen wurde. Leider habe ich den NRF24 noch nicht an meinem D1 Mini zum Laufen bekommen. Mit der Lösung könnte man quasi zwei Kommunikationsebenen parallel laufen lassen. Einmal die simple Übermittlung von Telemetriedaten und zusätzlich die Einbindung in ein SmartHome Netzwerk. Bedenke aber, dass für WLAN ein immens größerer Aufwand im Code betrieben werden muß.

Einfach gesagt braucht man für den ESP8266, ohne weiteres 2,4GHz NRF24 Modul, immer ein funktionierendes WLAN. Man kann aber an den ESP einen NRF24 anschließen und darüber direkt mit einem Arduino (UNO/Nano/mega usw.) Daten austauschen. Will man dann per WLAN vieleicht eine aufwändigere SmartHome Geschichte realisieren, kommt man um die WLAN-Funktionalität des ESP nicht herum. Dafür braucht es aber einiges mehr, als nur die "3 1/2" Zeilen Code, die man für die reine NRF24 Kommunikation benötigt.

HMMM, klingt irgendwie umständlich erklärt, besser bekomme ich das aber im Moment nicht hin.

 

[Dogger]

Wie gesagt: Weit voraus gegriffen...
Aber der Winter ist noch lange und im Fernseher läuft ehe nur misst.

Ich werde mich jetzt auch erst mal mit dem NRF24L01 beschäftigen und dann mit dem ESP8266 als einzelnes Netzwerk ( ich habe irgendwo gelesen das der ESP ein eigenes Netzwerk für seines gleichen als Stern für 4 weitere aufbauen kann).
Eine einfache Informationsübertragung geht ja zur Not auch über die Pin´s ( und wenn es halt ne Sekunde dauert )
Eine Internetanbindung finde ich sowieso noch nicht so interessant.
Die Kommunikation soll später über Bluetooth laufen ( Hat der NRF angeblich drauf )

 

[BAXL]

Das ist richtig, der ESP8266 kann auch sein eigenes kleines WLAN basteln, das habe ich mir auch mal angesehen. Problematisch wird es dann nur, wenn zwei der Module irgendwo im Haus werkeln und die Sendeleistung nicht ausreicht. Darum nimmt man gerne das existierende WLAN vom Internetrouter, weil damit die Abdeckung im Haus eher gewährleistet wird. Aber wie gesagt, das ist eine andere Hausnummer. Vielleicht, wenn ich das verstanden habe, erscheint mir das auch relativ leicht, nur im Moment noch nicht, da ist der erforderliche, sehr ausladende Code, noch ein böhmisches Dorf für mich.

An dem ESP8266 kann man sich trefflich austoben. Es gibt so eine Art alternative "Betriebssysteme" dafür, die braucht man nur darauf zu spielen und kann über sein Handy direkt gewisse Schaltfunktionen an den Ports auslösen. Das habe ich mal ausprobiert und stand am Ende doch wie ein Ochs´vorm Berg.

 

[Dogger]

Ich habe mich gestern wieder an die Programmierung vom NRF gesetzt:
Nach einem bisschen rum probieren habe ich es auch geschafft das der Empfänger ein Signal „ empfange 1“ zurück gibt wenn er vom Sender ein High bekommen hat. Aber leider funktioniert das nur sporadisch, also im durchschnitt kommt beim Sender nur alle 10 Sekunden mal das Signal „ empfange 1 „ durch.
Der Empfänger bekommt aber fast durchgehend das Signal vom Sender. Ich habe versucht den Teil, wo der Sender empfangen soll, in eine Schleife zu setzen aber das auch ohne Erfolg ( liegt möglicherweise auch daran das ich das letzte mal vor 3 Jahren ein Arduino programmiert haben).
Ich möchte halt später zu jedem Befehl vom „Master Arduino“ von dem jeweiligen „Steuer Arduino“ quittiert bekommen und Sensoren ( in diesem Fall Helligkeit und Temperatur ) vom Master Arduino zyklisch oder bei bedarf abfragen.

Sendercode:

// Programm zur Übermittlung eines Schalterzustandes mit einem 2,4 GHz NRF24 Modul

// Die Betriebsspannung vom NRF24 Modul MUSS!! an 3,3V vom Arduino angeschlossen werden
// ACHTUNG!!! ca 10 nF Elko zwischen 3,3V und Masse schalten um die Übertragung zu stabilisieren

// Bibliotheken zur Bedienung des NRF24 Moduls
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>


// Variablen und Instanzendefinition für das NRF Modul
RF24 radio(8, 9);                 // CE, CSN - die Zahlen geben die Digitalports am Arduino an,  Instatz um das Modul zu starten
const byte address1[6] = "00001";  //Adresse, auf dem die Empfangsdaten gesendet werden sollen. Der Empfänger benötigt dieselbe Adresse!
const byte address2[6] = "00002";
boolean button_state = 0;
boolean antwort = 0;

int button_pin = 7;               // Signalpin zum Einlesen des Schaltsignals (Taster, Bewegungsmelder etc.)

void setup() {
  Serial.begin(9600);             // Start des seriellen Ausgabe per USB an einen PC
  pinMode(button_pin, INPUT);     // Port zum Einlesen des Schalterzustandes konfigurieren
  radio.begin();                  // Start der 2,4 GHz Wireless Kommunikation
  radio.openWritingPipe(address1); // Setzen der Sendeadresse zur Übermittlung der Daten
  radio.openReadingPipe(1, address2);  // Die 1,... ist nicht nötig gewesen aber es lief irgendwie flüssiger am Ausgabe Pin vom Empfänge
  radio.setPALevel(RF24_PA_HIGH); // Leistung des NRF Moduls je nach Entfernung kann man von  MIN bis MAX einstellen (MAX,HIGH,LOW,MIN)
  //radio.stopListening();          // Das angeschlossene Modul wird als Sender konfigurieret
}
void loop()
{
  radio.stopListening();
  button_state = digitalRead(button_pin); // Einlesen des Schalterzustandes
// Serial.println(button_state);           // Kontrollausgabe des Schalterzustandes am PC-Monitor

  if(button_state == HIGH)
    {
      const char text[] = "Your Button State is HIGH"; // Erstelle Zeichenkette als Textmitteilung
      radio.write(&text, sizeof(text));                //Sende Zeichenkette zum Empfänger
    }
  else
    {
      const char text[] = "Your Button State is LOW";   // Erstelle Zeichenkette als Textmitteilung
      radio.write(&text, sizeof(text));                 //Sende Zeichenkette zum Empfänger
    }


//      const char text[] = "Your Button State"; // Erstellen einer Zeichenkette als Textmitteilung
//      radio.write(&text, sizeof(text));        // Senden der Zeichenkette zum Empfänger

  radio.write(&button_state, sizeof(button_state));  //Senden des Schalterstatus zum Empfänger
  radio.startListening();
  if (radio.available())              //Looking for the data.
{
  Serial.println("empfange!");
  radio.read(&antwort, sizeof(antwort));
  Serial.println(antwort);
}
  delay(50);
}

Empfängercode:

// Bibliotheken für 2,4 GHz Modul
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
  RF24 radio(8, 9); // CE, CSN
  const byte address1[6] = "00001";
  const byte address2[6] = "00002";
  boolean button_state = 0;
  boolean antwort = 0;
  int led_pin = 7;


void setup() {
  pinMode(7, OUTPUT);
  Serial.begin(9600);
  radio.begin();
  radio.openReadingPipe(0, address1);   //Setting the address at which we will receive the data
  radio.openWritingPipe(address2);
  radio.setPALevel(RF24_PA_HIGH);       //You can set this as minimum or maximum depending on the distance between the transmitter and receiver.
  //radio.startListening();              //This sets the module as receiver
  Serial.println("gestartet");
}
void loop()
{
  radio.startListening();
  if (radio.available())              //Looking for the data.
{
  Serial.println("empfange!");
  char text[32] = "";                 //Saving the incoming data
  radio.read(&text, sizeof(text));    //Reading the data
  radio.read(&button_state, sizeof(button_state));    //Reading the data
  if(button_state == HIGH)
{
  digitalWrite(7, HIGH);
  Serial.println(text);
radio.stopListening();
antwort  = (1);
radio.write(&antwort, sizeof(antwort));
}
else
{
  digitalWrite(7, LOW);
  Serial.println(text);}
}


  delay(50);
}

 

[BAXL]

Hallo Dogger, irgendetwas ist beim Einfügen des Codes schief gegangen, das ist kaum vernünftig lesbar. kannst Du das irgendwie ändern?

@Dogger

Ok, das Programm kann ich nun sehen, was genau willst Du in dem Program machen? Mir scheint, Du möchtest eine bidirektionale Kommunikation aufbauen. Ist das so?

Ich habe das Gefühl, als wenn die Zeiten zwischen den "Rollenänderungen" zu kurz sind. Das mußt Du wohl anders lösen.

 

[Dogger]

Ich habe das Gefühl, als wenn die Zeiten zwischen den "Rollenänderungen" zu kurz sind. Das mußt Du wohl anders lösen.

Wenn ich ein „delay“ dazwischen setze hört er ja die zeit über nicht die Quittierung: „empfange 1“.

Ich denke einfach das ich die Empfangszeit vom Sender ( Ich nenne ihn jetzt mal MasterA. ) verlängern muss. Sie darf aber nicht zu lange sein weil es immer mal ein Paketverlust gibt.

Ich habe es mit einer „do“ Schleife versucht aber in der ist er dann hängen geblieben.

 

[BAXL]

Die Krux ist die häufige Abfrage des NRF. Das mußt Du wohl anders softwaremäßig abfangen, da wird ein simples delay nicht ausreichen. Wenn ich die Funktion der NRF-Lib richtig verstanden habe, dann landen die empfangenen Daten in einem Puffer, den man über radio.available() immer mal wieder abfragt. Mußt Du denn permanent immer wieder die Quittierung senden? Wenn Du sagst, dass das sporadisch ankommt, dann wäre ein erfolgreicher Empfang der Quittung doch genug. Du bist erst am Anfang Deines Experimentes und der Empfang einer Quittierung, auch wenn es erst nur sporadisch ist, ist ein Erfolg. Nun mußt Du programmtechnisch kreativ werden, weil die Funktion grundsätzlich gegeben ist.

 

[Dogger]

Ja...

Hatte gehofft das ich ein prinzipiellen Fehler gemacht habe.

Ich kann halt nicht solange ein Befehl senden bis ich eine Quittierung bekomme!

Deswegen wollte ich Senden und dann eine Bestimmte Zeit in eine Schleife horchen.

Aber ich bekomme da nix funktionierendes geschrieben.

Wie ist es möglich

if (radio.available()) //Looking for the data.

In eine „for“ Schleife umzuwandeln ?

 

[BAXL]

Das wäre möglich. Du mußt ja auch irgendwie eine Abbruchbedingung haben, Du möchtest zukünftig doch mehrere Geräte bedienen können. Meinetwegen 10 mal abfragen und wenn dann nichts kommt abbrechen und eine Fehlermeldung generieren. So ein Gerät kann auch mal offline sein, oder eine echte Funktionsstörung haben.

 

[BAXL]

@Dogger

Hallo Dogger, bist Du schon weiter gekommen?

 

[Dogger]

Nicht viel weiter.

Irgendwie bekomme ich noch keine Mail wenn hier was reingeschrieben wird.

( Muss nochmal die Einstellungen checken ) > finde nix fehlerhates bei Kontaktdetails !

Aber jetzt kommen die 2 Wochen in der ich das Projekt angehen will und auch die Zeit habe.



Meine if/else Schleife läuft noch nicht ganz wie ich das gerne hätte:

Die Fehlermeldung mit den 4 Fehlversuchen kommt einfach immer, auch wenn der Empfang der Rückmeldung funktioniert hat.

Eine Kopie vom Serial Monitor gebe ich später noch dazu.

Mein aktueller Code vom Sender:

// Sender
// Programm zur Übermittlung eines Schalterzustandes mit einem 2,4 GHz NRF24 Modul

// Die Betriebsspannung vom NRF24 Modul MUSS!! an 3,3V vom Arduino angeschlossen werden
// ACHTUNG!!! ca 10 nF Elko zwischen 3,3V und Masse schalten um die Übertragung zu stabilisieren

// Bibliotheken zur Bedienung des NRF24 Moduls
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>


// Variablen und Instanzendefinition für das NRF Modul
RF24 radio(8, 9);                 // CE, CSN - die Zahlen geben die Digitalports am Arduino an,  Instatz um das Modul zu starten
const byte address[6] = "00001";  //Adresse, auf dem die Empfangsdaten gesendet werden sollen. Der Empfänger benötigt dieselbe Adresse!
boolean button_state = 0;
int antwort = 0;
int horchen ;
int button_pin = 7;               // Signalpin zum Einlesen des Schaltsignals (Taster, Bewegungsmelder etc.)

void setup() {
  Serial.begin(9600);             // Start des seriellen Ausgabe per USB an einen PC
  pinMode(button_pin, INPUT);     // Port zum Einlesen des Schalterzustandes konfigurieren
  radio.begin();                  // Start der 2,4 GHz Wireless Kommunikation
  radio.openWritingPipe(address); // Setzen der Sendeadresse zur Übermittlung der Daten
  radio.setPALevel(RF24_PA_HIGH); // Leistung des NRF Moduls je nach Entfernung kann man von  MIN bis MAX einstellen (MAX,HIGH,LOW,MIN)
// radio.stopListening();          // Das angeschlossene Modul wird als Sender konfigurieret
}
void loop()
{
  radio.stopListening();
  button_state = digitalRead(button_pin); // Einlesen des Schalterzustandes
  Serial.println(button_state);           // Kontrollausgabe des Schalterzustandes am PC-Monitor

  if(button_state == HIGH)
    {
      const char text[] = "Your Button State is HIGH"; // Erstelle Zeichenkette als Textmitteilung
      radio.write(&text, sizeof(text));                //Sende Zeichenkette zum Empfänger
    }
  else
    {
      const char text[] = "Your Button State is LOW";   // Erstelle Zeichenkette als Textmitteilung
      radio.write(&text, sizeof(text));                 //Sende Zeichenkette zum Empfänger
    }


//      const char text[] = "Your Button State"; // Erstellen einer Zeichenkette als Textmitteilung
//      radio.write(&text, sizeof(text));        // Senden der Zeichenkette zum Empfänger

  radio.write(&button_state, sizeof(button_state));  //Senden des Schalterstatus zum Empfänger

   radio.startListening();

horchen=0 ;   // Wert für horchen zurücksetzen

while(horchen<=4)   //Schleife läuft solange durch bis horchen = 4 ist.
{
  if (radio.available())                    //Wenn Daten abgelegt sind dann...
{
   Serial.print("empfange!");
   radio.read(&antwort, sizeof(antwort));
   Serial.println(antwort);                  // das ..In kann eigentlich weg
   horchen=4;                                 // horchen auf 4 weil Schleife beendet werden kann.
  }
    else        // Bei einem Empfang setzt er horchen auf 4 und sollte eigentlich von hier ...
    {
              if( horchen>=4)             
           {                                               
           Serial.println("4 X Versucht" ); // Fehlermeldung bei 4 erfolglosen Durchgängen
            }
    horchen++;          // horchen wird um einen versuch erhört
    Serial.print("horchen auf ! ");
   Serial.println(horchen);

    delay(10);                   // kleine Verzögerung
     }   // ...Bis hier, alles überspringen.  Tut das Programm aber nicht !
}

  delay(50);
}

Der Serieller Monitor :

8:22:43.767 -> horchen auf ! 3
18:22:43.767 -> horchen auf ! 4
18:22:43.814 -> 4 X Versucht
18:22:43.814 -> horchen auf ! 5
18:22:43.814 -> 1 > Das Taster signal !
18:22:43.861 -> empfange!8 > Empfängt Daten und die 8 Ist die Information vom anderen Arduino
18:22:43.861 -> 4 X Versucht > Sitzt in der "else" Bedinung und sollte eigentlich übergangen werden !
18:22:43.861 -> horchen auf ! 5 > Habe ich zum test in verschiedenen Stellen eingesetzt
18:22:43.908 -> 1 > Das Tastersignal ( Der void loop hat von neuem begonnen )
18:22:44.001 -> empfange!8
18:22:44.001 -> 4 X Versucht
18:22:44.001 -> horchen auf ! 5
18:22:44.048 -> 1
18:22:44.048 -> horchen auf ! 1 > Hier hat er mal keine antwort bekommen
18:22:44.048 -> horchen auf ! 2 > und versucht es auch brav 4 mal
18:22:44.095 -> horchen auf ! 3
18:22:44.095 -> horchen auf ! 4
18:22:44.095 -> 4 X Versucht
18:22:44.095 -> horchen auf ! 5 > Mit der 5 ist die while Schleife beendet
18:22:44.095 -> 1 > und der void loop beginnt neu
18:22:44.188 -> empfange!8
18:22:44.188 -> 4 X Versucht
18:22:44.188 -> horchen auf ! 5

 

[Dogger]

Es geht jetzt mit der Möglichkeit
Aber sauber programmiert ist das nicht.
Möglicherweise ist mach die if Anweisung in einer if/else Anweisung Probleme !
Wobei diese :
if (radio.available())
sich auch nicht normal verhält.

while(horchen<=4)   //Schleife läuft solange durch bis horchen = 4 ist.
{
  if (radio.available())                    //Wenn Daten abgelegt sind dann...
{
   Serial.print("empfange!");
   radio.read(&antwort, sizeof(antwort));
   Serial.println(antwort);                  // das ..In kann eigentlich weg
   horchen=5;                                 // horchen auf 4 weil Schleife beendet werden kann.
  }
    else // else Funktion mit dernächten if Bedingung nicht ganz kompatibel aber läuft mit ==4
    {
              if( horchen==4)                    // Fehlermeldung bei 4 erfolglosen Durchgängen
           {                                                    
           Serial.println("4 X Versucht Fehler Fehler " );
            }
    horchen++;          // horchen wird um einen versuch erhört
    Serial.print("horchen auf ! ");
   Serial.println(horchen);

    delay(20);                   // kleine Verzögerung
     }
}

 

[BAXL]

@Dogger

Wie wäre es, wenn Du bei Button_state eine Zeitverzögerung einbaust wenn sich der Zustand nicht verändert hat, sonst ist der dauernd am senden. Es reicht eigentlich, wenn Du nur bei einer Zustandsänderung nur einmal sendest.

 

[Dogger]

Ich melde mich mal wieder:
Habe eine Zeitsteuerung für einen Rollanden erst mal fertig.
Jetzt würde ich noch gerne mit dem Sender verschieden Empfänger ansprechen.
Aber habe noch nicht wirklich raus gefunden wie ich das anstellen kann:
das " const " bei "const byte address[6]" ist anscheinden nicht unbedingt nötig aber innerhalb vom Loop kann ich den byte trotzdem nicht wirklich Ändern und auch das Auslesen mit Serial funktioniert nicht so wirklich.
Mit dem Senden habe ich jetzt so gelöst das er nur bei einer Zustandsänderung sendet.

Die letzten Zeilen beim Sender sind entscheidend. Darin will ich die Adresse von 00011 auf 00001 ändern aber er tut es nicht und im SerialPrint schreibt er immer nur „0“ als Wert.




Sender

// Date and time functions using just software, based on millis() & timer
#include <nRF24L01.h>
#include <RF24.h>
#include "RTClib.h"
RTC_Millis rtc;

RF24 radio(8, 9);                 // CE, CSN - die Zahlen geben die Digitalports am Arduino an,  Instatz um das Modul zu starten
byte address[6] = "00011";  //Adresse, auf dem die Empfangsdaten gesendet werden sollen. Der Empfänger benötigt dieselbe Adresse!
boolean button_state = 0;  // Rolladen hoch
boolean button_state2 = 0;  // Rolladen runter
boolean Anderung = 0;

boolean Wochentag = 0;   // So.-Do. = HIGH
boolean Arbeitstag = 0;   // Mo.-Fr. = HIGH
boolean Frei =0; // Fr.-SO
void setup () {
   pinMode(7, OUTPUT);
   pinMode(5, OUTPUT);
    Serial.begin(57600);
radio.begin();
  radio.openWritingPipe(address); // Setzen der Sendeadresse zur Übermittlung der Daten
  radio.setPALevel(RF24_PA_HIGH); // Leistung des NRF Moduls je nach Entfernung kann man von  MIN bis MAX einstellen (MAX,HIGH,LOW,MIN)
 
    //rtc.begin(DateTime(F(__DATE__), F(__TIME__)));
    // rtc.adjust(DateTime(2020,1,5, 8, 59, 55));   // Zeit hoch
     rtc.adjust(DateTime(2020,1,5, 22, 29, 55));   // Zeit runter
}

void loop ()
{
    DateTime now = rtc.now();
 
// Wochentag -1 ermitteln ( So. bis Do. )
if ( now.dayOfTheWeek() == 0||now.dayOfTheWeek() ==1||now.dayOfTheWeek() ==2||now.dayOfTheWeek() ==3||now.dayOfTheWeek() ==4 )
{
  Wochentag = HIGH; 
}
else
{
  Wochentag = LOW;
}
// Arbeitstag ermitteln ( Mo. bis Fr. )
if (now.dayOfTheWeek() ==1||now.dayOfTheWeek() ==2||now.dayOfTheWeek() ==3||now.dayOfTheWeek() ==4 ||now.dayOfTheWeek() == 5 )
{
  Arbeitstag = HIGH; 
}
else
{
  Arbeitstag = LOW;
}


// Frei ermitteln ( Fr. 12Uhr bis So. 12Uhr )
if (Wochentag == LOW && Arbeitstag == LOW||now.dayOfTheWeek() == 5 && now.hour()>= 12 ||now.dayOfTheWeek() == 0 && now.hour()<= 11 )
{
  Frei = HIGH; 
}
else
{
  Frei = LOW;
}

// Serial.println (Wochentag);
//Serial.println (Arbeitstag);
Serial.println (Frei);
// An Arbeitstagen um 6:30 Signal ( Pin 7 HIGH ) für 10 Sek.
if (Arbeitstag==HIGH && now.hour()== 6 && now.minute()== 30&&now.second()<= 10 || Frei == HIGH &&now.hour()== 9&&  now.minute()== 00&& now.second()<= 10   )
{
  if (button_state == LOW )
  {
    Anderung = HIGH;
  }
digitalWrite(7, HIGH);
button_state = HIGH;

}
else
{
  if (button_state == HIGH )
  {
    Anderung = HIGH;
  }
digitalWrite(7, LOW);
button_state = LOW;
}

// An Wochentag um 22:30 Signal ( Pin 4 HIGH ) für 10 Sek.
if (Wochentag==HIGH && now.hour()== 22 && now.minute()== 30&&now.second()<= 10 || Frei == HIGH &&now.hour()== 23&& now.minute()== 59&&now.second()<= 10 )
{
  if (button_state2 == LOW )
  {
    Anderung = HIGH;
  }
digitalWrite(4, HIGH);
button_state2 = HIGH;
}
else
{
  if (button_state2 == HIGH )
  {
    Anderung = HIGH;
  }
digitalWrite(4, LOW);
  button_state2 = LOW;
}


Serial.println (Anderung);

// Zeitangabe
    Serial.print(now.year(), DEC);
    Serial.print('/');
    Serial.print(now.month(), DEC);
    Serial.print('/');
    Serial.print(now.dayOfTheWeek(), DEC);
    Serial.print(' ');
    Serial.print(now.hour(), DEC);
    Serial.print(':');
    Serial.print(now.minute(), DEC);
    Serial.print(':');
    Serial.print(now.second(), DEC);
    Serial.println();

// Übertragung an Modul
if(Anderung == HIGH)
{
  radio.stopListening();

       radio.write(&button_state, sizeof(button_state));                //Sende Zeichenkette zum Empfänger
       //delay(10);
      byte address[6] = "00001";
       radio.write(&button_state2, sizeof(button_state2));                //Sende Zeichenkette zum Empfänger
      //delay(10);
     
       Anderung = LOW;
     
   }
     Serial.println(button_state);           // Kontrollausgabe des Schalterzustandes am PC-Monitor
     Serial.println(button_state2);
     Serial.println(' ');
     Serial.println(address[6]);
     Serial.println(' ');
    delay(30);
}

Empfänger:

// Bibliotheken für 2,4 GHz Modul
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>

  RF24 radio(8, 9); // CE, CSN
  const byte address[6] = "00011";
  boolean button_state ;
  boolean button_state2 ;

  int led_pin = 7;
  int led_pin2 = 6;



void setup() {
  pinMode(7, OUTPUT);
  pinMode(6, OUTPUT);
  Serial.begin(57600);
  radio.begin();
  radio.openReadingPipe(0, address);   //Setting the address at which we will receive the data
  radio.setPALevel(RF24_PA_MIN);       //You can set this as minimum or maximum depending on the distance between the transmitter and receiver.
  radio.startListening();              //This sets the module as receiver
  Serial.println("gestartet");
}
void loop()
{
// Empfange
    radio.startListening();
     if (radio.available())              //Looking for the data.
   {
      Serial.println("empfange!");
   
      radio.read(&button_state, sizeof(button_state));    //Reading the data
      if(button_state == HIGH)
     {   
      digitalWrite(7, LOW);
      Serial.println(" 7 HIGH ");   
      }
   if(button_state == LOW)
     {   
      digitalWrite(7, HIGH);
      Serial.println(" 7 LOW ");   
      }

  radio.read(&button_state2, sizeof(button_state2));    //Reading the data
      if(button_state2 == HIGH)
     {
   
      digitalWrite(6, LOW);
       Serial.println("6 HIGH");
      }
       if(button_state2 == LOW)
     {
   
      digitalWrite(6, HIGH);
       Serial.println("6 LOW");
      }
    }
  delay(50);

}

@BAXL
Mit dem Senden habe ich jetzt so gelöst das er nur bei einer Zustandsänderung sendet.

 

[BAXL]

Dann wirst Du weitere Adressen definieren und wechseln müssen. D.h., dass beim Sender im laufenden Betrieb eine alternative Adresse eingestellt werden muss, auf die der zweite Empfänger reagiert.

 

[Dogger]

Dann wirst Du weitere Adressen definieren und wechseln müssen. D.h., dass beim Sender im laufenden Betrieb eine alternative Adresse eingestellt werden muss, auf die der zweite Empfänger reagiert.

Ja genau das habe ich ja versucht. ( Ende vom Sender code )

 

[BAXL]

Jaaaa, nur die Adresse in der Variablen ändern wird auch kaum reichen, das musst Du dem NRF auch irgendwie bekannt machen.