Drehscheibe Modellbahn mit RF24

Danke dir. Hab es geändert.

Hat denn wirklich keiner ne Idee?

Acki1985:
Hat denn wirklich keiner ne Idee?

Ich kann nur vermuten, da der Sketch schlecht zu lesen ist.
Es fehlen einfach Kommentare, was an welcher Stelle passieren soll.

Ich vermute die Signale (Sender und Empfänger) überschneiden sich und damit bekommst der Empfänger nichts mit.

Hast du sicher gestellt, dass die Kommunikation zu den NRFs funktioniert?
Am einfachsten machst du das mit printDetails().

Welche Art von Modulen benutzt du?

Wie versorgst du die NRFs mit 3.3V?

Warum benutzt du hier ein while?

    while (radio.available())
{
Serial.println("Data there");
radio.read(data_e, 1);
Serial.println(data_e[0]);
  }

Warum benutzt du falsche Kommentare?

const byte addresses[][6] = {"00001", "00002"};

  radio.openWritingPipe(addresses[0]); // 00002
  radio.openReadingPipe(1, addresses[1]); // 00001

const byte addresses[][6] = {"00001", "00002"};

  radio.openWritingPipe(addresses[1]); // 00001
  radio.openReadingPipe(1, addresses[0]); // 00002

Benutze bitte mal Ctrl-T in der IDE um deinen Sketch zu formatieren.

Guten Abend,

danke für deine Antwort.

zu 1. es sind diese Module https://www.amazon.de/SainSmart-NRF24L01-drahtlos-Transceiver-2-4GHz/dp/B006CHFPFU

zu 2. Versorgt werden sie momentan über den Arduino NANO am 3,3Volt Ausgang mit Kondensator zur Masse

zu 3. Mit dem While das ist durch das testen entstanden. In manchen Codes steht while in anderen if.

zu 4. Das mit Kommentaren ist auch durch brobieren zu Stande gekommen.

Habe den Code nochmal geändert. Das Empfangen funktioniert super nur das zurück Senden nicht.

Wie gesagt der Sender ist nur zum testen. Ich habe die Variable Schritte immer händisch abgeändert.
Mit den Orginal Scetches von https://www.instructables.com/id/Arduino-and-NRF24L01/ hat das gegenseitige Senden und Empfangen funktioniert.

Hier meine Codes:
Sender (Provisorisch)

/*
  Arduino NRF24L01 simple transmit and receive - Created October 2017
    by DonX Developer
  *** This code was created for an Arduino UNO using the Arduino IDE v1.8.4. ***

  Parts:
  2 X Arduinos
  2 X Breadboards
  2 X NRF24L01
  [optional] 2 X YL-105 breakout boards for the NRF24L01. This allows for 5v connection and easier wiring
  2 X Momentary switches
  2 X Red LEDs
  2 X Yellow LEDs
  4 X 220 ohm resistors
  Jumper wires


  NRF24L01  Arduino pin
  VCC       3.3 V
  GND       GND
  CS        8
  CE        7
  MOSI      11 or ICSP-4
  MISO      12 or ICSP-1
  SCK       13 or ICSP-3

  If you use the YL-105 breakout board, the Vcc lead can go to the 5v Arduino pin

  Arduino pin 2 to Yellow LED long lead - anode
  Yellow short lead - cathode to 220ohm resistor, then second resistor lead to GND

  Arduino pin 3 to Red LED long lead - anode
  Red short lead - cathode to 220ohm resistor, then second resistor lead to GND

  Arduino pin 4 to switch, other side of switch to GND

  The physical build of the two boards are identical
  There are minor software differences for the reading and writing pipes for the respective boards.

*/

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

#define button 4
#define confirmLed 2
#define led 3

RF24 NRF24L01 (8, 9);//create object called NRF24L01. specifying the CE and CSN pins to be used on the Arduino

byte address[] [6] = {"pipe1", "pipe2"};//set addresses of the 2 pipes for read and write
boolean buttonState = false;//used for both transmission and receive
byte schritte[1];
void setup() {
  Serial.begin(9600);
  pinMode(button, INPUT_PULLUP);
  pinMode(confirmLed, OUTPUT);//yellow LED
  pinMode(led, OUTPUT);//red LED

  NRF24L01.begin();
  //open the pipes to read and write from board 1
  NRF24L01.openWritingPipe(address[0]);//open writing pipe to address pipe 1
  NRF24L01.openReadingPipe(1, address[1]);//open reading pipe from address pipe 2

  NRF24L01.setPALevel(RF24_PA_MAX);//set RF power output to minimum, RF24_PA_MIN (change to RF24_PA_MAX if required)
  NRF24L01.setDataRate(RF24_250KBPS);//set data rate to 250kbps
  NRF24L01.setChannel(110);//set frequency to channel 110
}

void loop() {
  schritte[0] = 105;
  //Transmit button change to the other Arduino
  delay(10);
  NRF24L01.stopListening();
  buttonState = digitalRead(button);//test for button press on this board
  if (buttonState == LOW)//button is pulled up so test for LOW
  {
    Serial.println("1");
    
    NRF24L01.write(&schritte, sizeof(schritte));//send LOW state to other Arduino board
    //flash the yellow LED to show progress
    digitalWrite(confirmLed, HIGH);
    Serial.println(schritte[0]);
    delay(100);
    digitalWrite(confirmLed, LOW);
  }

  buttonState = HIGH;//reset the button state variable

  //Receive button change from the other Arduino
  delay(10);
  NRF24L01.startListening();
  if (NRF24L01.available())//do we have transmission from other Arduino board
  {
    Serial.println("2");
    
    NRF24L01.read(&buttonState, sizeof(buttonState));//update the variable with new state
    NRF24L01.stopListening();
    Serial.println(buttonState);
  }
  if (buttonState == HIGH)//test the other Arduino's button state
  {
    digitalWrite(led, LOW);
  }
  else
  {
    flashLed();//indicate that the button was pressed on the other board
  }
  buttonState = HIGH;//reset the button state variable
}

//flash the red LED five times
void flashLed()
{
  for (int i = 0; i < 1; i++)
  {
    digitalWrite(led, HIGH);
    delay(200);
    digitalWrite(led, LOW);
    delay(200);
  }

}

Empfänger (Bühne)

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

int data[1];
boolean var = true;
//const byte addresses[][6] = {"00001", "00002"};
//const uint64_t pipe = 0xF0F0F0F0A1LL;
RF24 radio (8, 9);
byte address[] [6] = {"pipe1", "pipe2"}; // Adressen der beiden Pipes
byte rever_start = false;
const byte hal = 3;
byte schritte[1];                                 // Schritte die deer Motor (Hallsensor betätigt) zurücklegen muss
int sensor = LOW;
unsigned long startZeit;                          // Abfrage begin Sensor an Bühne
unsigned long interval = 2000;                    // Zeitabstand nachdem ein Zustand des Sensors erkannt wird
unsigned long vergangeneZeit = 0;                 // Speichervariable um die Vergangene Zeit zu speichern
/*int pin_motor_links = A1;                         // Richtungspin an H-Brücke für Links
  int pin_motor_rechts = A2;                        // Richtungspin an H-Brücke für Rechts
*/
// Statusvariablen
bool nullStellung = false;                      // Speichervariable ob Referenzfahrt erfolgt ist
bool ergebnis = false;                          // Berechnung der Schritte und Richtung beendet/gestartet
bool start = false;                           // Schritte Zaehlen beendet/gestartet

void setup() {
  radio.begin();
  //radio.openReadingPipe(1, pipe);
  radio.openWritingPipe(address[1]); // 00002
  radio.openReadingPipe(1, address[0]); // 00001
  radio.setPALevel(RF24_PA_MAX);
  radio.setDataRate (RF24_250KBPS);
  radio.setChannel(110);

  radio.startListening();
  pinMode(hal, INPUT);
  Serial.begin(9600);
  //delay (2000);
}

void loop() {

  referenzFahrt();
  encoder_lesen();
  schritteZaehlen();
}

void referenzFahrt() {
  if (radio.available())
  {
    Serial.println("Data there");
    radio.read(data, 1);
    Serial.println(data[0]);
  }

  // Reverenzfahrt

  if ((data[0] == 255) && (rever_start == false) && (nullStellung == false)) {
    rever_start = true;
    Serial.println("Reverenzfahrt gestartet");
    //    digitalWrite (pin_motor_rechts, HIGH);
    //  digitalWrite (pin_motor_links, LOW);
  }
  else if ((data[0] == 254) && (rever_start == true)) {
    nullStellung = true;
    rever_start = false;
    Serial.println("Reverenzfahrt beendet");
    Serial.println (" ");
    //      digitalWrite (pin_motor_rechts, LOW);
    //        digitalWrite (pin_motor_links, LOW);
  }
}

void encoder_lesen () {
  if ((data[0] <= 48) && (data[0] > 0) && (nullStellung == true) && (ergebnis == false)) {
    //rechtsrum data[0] Schritte
    schritte[0] = data[0];
    ergebnis = true;
    // Motor
    Serial.println (schritte[0]);
    Serial.print ("  Schritte nach Rechts");
    Serial.println (" ");
  }
  else if ((data[0] >= 100) && (data[0] <= 149) && (nullStellung == true) && (ergebnis == false)) {
    //linksrum data[0] - 100 Schritte
    schritte[0] = data[0] - 100;
    ergebnis = true;
    // Motor
    Serial.println (schritte[0]);
    Serial.print ("  Schritte nach links");
    Serial.println (" ");
  }
}

void schritteZaehlen () {

  sensor = digitalRead (hal);
  startZeit = millis();
  if ((schritte[0] != 0) && (ergebnis == true)) {
    start = true;
    if ((startZeit - vergangeneZeit >= interval) && (sensor == LOW) && (start == true)) {
      vergangeneZeit = startZeit;
      schritte[0]--;
      Serial.println("Drehung start");
      Serial.println("Restl. Pos.");
      Serial.println(schritte[0]);
      radio.stopListening();
      radio.write (&schritte, sizeof (schritte));
      radio.startListening();
    }
  }
  else if ((schritte[0] == 0) && (start == true)) {
    start = false;
    ergebnis = false;
    data[0] = 0;
    Serial.println("Ziel");
    Serial.println("Drehung");
    Serial.println("beendet");
    Serial.print("daten");
    Serial.println(schritte[0]);
    radio.stopListening();
    radio.write (&schritte, sizeof (schritte));
    radio.startListening();
    delay(2000);
    Serial.println(ergebnis);
  }
}

Mit dem verwendeten Modul kann es mit nur einem Kondensator funktionieren,
eine eigene vernünftige Stromversorgung ist betriebssicherer.

Dass dein delay-Gestolper im Sender keine Antworten empfängt wundert mich nicht.
Das Fenster in dem ein Empfang möglich ist, ist viel zu klein.
Delay gehört IMHO nicht in ein Programm das asynchrone Kommunikation versucht.

 for (int i = 0; i < 1; i++)

Wozu dient diese optische Kodebereicherung?
Der Kompiler entfernt sie völlig (zum Glück).

Hallo,

Stimmt das mit dem Delay mag ich auch nicht. Der Beispielcode war halt so.

Eigentlich soll es so ablaufen:

  • benötigte Schritte werden zur Scheibe gesendet
  • Scheibe sendet immer wenn ein Schritt runter gezählt wurde, die verbleibenden Schritte zurück
  • Wenn Scheibe die benötigten Schritte zurückgelegt hat, soll die Aktuelle Position an den Sender gesendet
    werden
  • Zwischenzeitlich (während die Schritte abgearbeitet werden) soll über den Sender ein Nothalt der Bühne
    ausgelöst werden können.

Das sind so die Vorstellungen.

Gruß Acki

Acki1985:
Stimmt das mit dem Delay mag ich auch nicht. Der Beispielcode war halt so.

Und dein Editor ist so beschädigt dass du keinen Kode ändern kannst?

Du hast mein Mitleid.

Klar kann ich den Code ändern. Mich hat nur gewundert das der Beispielcode (aus dem Link) ohne Probleme funktioniert hat. Meinst du das Delay im Sendecode?

Ich meine alle delay() Aufrufe, oder versuchen deine Sketches nicht miteinander zu kommunizieren?

In der Regel reicht es nicht delay Aufrufe einfach zu löschen oder auszukommentieren.

Ich müsste sie durch eine Millis Abfrage ersetzen. Oder?

Na ja, du solltest deinen Kode so blockierungsfrei wie möglich machen.
For und while solltest nicht für Abläufe nutzen
und möglichst keine (länger) blockierenden Funktionen aufrufen.

radio.write() blockiert auch, ist aber (spätestens) nach ca. 18 ms fertig.
Manchmal lässt sich ein kurzes Anhalten nur mit Kopfständen vermeiden,
beim NRF lohnt sich das IMHO nicht.

Deine Knoten sollten grundsätzlich lauschen und auf eingehende Pakete reagieren,
wenn sie was zu senden haben, schalten sie kurz den Empfänger ab,
senden und schalten ihn danach sofort wieder ein.

Deinen Stepper wirst du ja vielleicht auch zeitgesteuert bewegen wollen,
der Teil darf natürlich genauso wenig blockieren, sonst geht das mit der Anhalte-Anfrage in die Hose.

Der Motor ist nur ein ganz normaler DC Motor, welcher über einen Treiber angesteuert wird. Die Positionen (Schritte) werden über einen Sensor eingelesen. Die genaue Positionierung, sowie das Ausschalten erledigt der Orginale Raststift. So hatte ich es zumindest vor.

Aber die Bühne hört ja auch permanent. Das hören wird doch nur unterbrochen, wenn die restlichen Schritte gesendet werden. Oder lieg ich da falsch?

Hi

Ein oder zwei Kleinigkeiten wird 'die Bühne' wohl drum herum noch machen müssen - gucken, ob der Endschalter betätigt wurde, um 1 runter zu zählen, den Motor anhalten, wenn wir auf Null sind und so Kram.
Du kannst, wie sonst auch immer, entweder bei jedem (möglichst schnellem) loop()-Durchlauf nachschauen, ob's was Neues gibt, oder, wenn der Funk-Empfänger Das bietet, einen Interrupt aktivieren, in Dem Du auf den eingehenden Datenstrom reagierst.
Normal wird dort aber auch nur 'gemerkt', daß was Neues gesendet wird - das Auslesen muß dann so schnell wie möglich in der loop() erledigt werden - und dann das darauf reagieren.

Wie bereits geschrieben: MALE Dir auf, was wann wie passieren soll.
Dort wirst Du schnell sehen, daß Du eine ganze Menge Kram zu erledigen hast und Du so auch eine ganze Zeit NICHT schaust, ob's was Neues gibt.
Damit Du trotzdem Nichts verpasst, muß loop() rasend schnell sein, um in jedem Durchlauf die 1/2 angefallenen Zeichen abzugrasen.

MfG
MfG

Der Kommunikationsablauf in der Bühne sollte so in Ordnung sein, du hast aber noch keinen Anhaltebefehl.

Der Ablauf im Sender ist dein Problem.
Wenn du den Sender änderst, bitte entferne alle Kommentare die Offensichtlichkeiten kommentieren.

Ich durchschaue deine verschachtelten Funktionen nicht,
die Positionserkennung kommt mir komisch an die Zeit gebunden vor,
teilweise gibt es komplizierte Bedingungen,
der halbe Kode ist auskommentiert.
Warum nutzt du einelementige Arrays?

Wie wäre es mit aktualisierten Versionen in einem neuen Post?

Hier ist der Aktuelle Code vom Sender:

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

#define button 4
#define confirmLed 2
#define led 3

RF24 NRF24L01 (8, 9);//create object called NRF24L01. specifying the CE and CSN pins to be used on the Arduino

byte address[] [6] = {"pipe1", "pipe2"};//set addresses of the 2 pipes for read and write
boolean buttonState = false;//used for both transmission and receive
byte schritte[1];
void setup() {
  Serial.begin(9600);
  pinMode(button, INPUT_PULLUP);
  pinMode(confirmLed, OUTPUT);//yellow LED
  pinMode(led, OUTPUT);//red LED

  NRF24L01.begin();
  //open the pipes to read and write from board 1
  NRF24L01.openWritingPipe(address[0]);//open writing pipe to address pipe 1
  NRF24L01.openReadingPipe(1, address[1]);//open reading pipe from address pipe 2

  NRF24L01.setPALevel(RF24_PA_MAX);//set RF power output to minimum, RF24_PA_MIN (change to RF24_PA_MAX if required)
  NRF24L01.setDataRate(RF24_250KBPS);//set data rate to 250kbps
  NRF24L01.setChannel(110);//set frequency to channel 110
}

void loop() {
  schritte[0] = 120;

  buttonState = digitalRead(button);
  if (buttonState == LOW)
  {
    NRF24L01.stopListening();
    Serial.println("1");
    NRF24L01.write(&schritte, sizeof(schritte));
    Serial.println(schritte[0]);

    NRF24L01.startListening();
  }

  buttonState = HIGH;//reset the button state variable


  if (NRF24L01.available())
  {
    Serial.println("2");
    NRF24L01.read(&buttonState, sizeof(buttonState));
    Serial.println(buttonState);
  }
}

Und die Bühne:

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

unsigned long warteZeit; 
int data[1];
boolean var = true;
//const byte addresses[][6] = {"00001", "00002"};
//const uint64_t pipe = 0xF0F0F0F0A1LL;
RF24 radio (8, 9);
byte address[] [6] = {"pipe1", "pipe2"}; // Adressen der beiden Pipes
byte rever_start = false;
const byte hal = 3;
byte schritte[1];                                 // Schritte die deer Motor (Hallsensor betätigt) zurücklegen muss
int sensor = LOW;
unsigned long startZeit;                          // Abfrage begin Sensor an Bühne
unsigned long interval = 2000;                    // Zeitabstand nachdem ein Zustand des Sensors erkannt wird
unsigned long vergangeneZeit = 0;                 // Speichervariable um die Vergangene Zeit zu speichern
/*int pin_motor_links = A1;                         // Richtungspin an H-Brücke für Links
int pin_motor_rechts = A2;                        // Richtungspin an H-Brücke für Rechts
*/
// Statusvariablen
bool nullStellung = false;                      // Speichervariable ob Referenzfahrt erfolgt ist
bool ergebnis = false;                          // Berechnung der Schritte und Richtung beendet/gestartet
bool start = false;                           // Schritte Zaehlen beendet/gestartet

void setup() {
  radio.begin();
  //radio.openReadingPipe(1, pipe);
  radio.openWritingPipe(address[1]); // 00001
  radio.openReadingPipe(1, address[0]); // 00002
  radio.setPALevel(RF24_PA_MAX); 
  radio.setDataRate (RF24_250KBPS);
  radio.setChannel(110);
  
  radio.startListening();
  pinMode(hal, INPUT);
  Serial.begin(9600);
  //delay (2000);
  }

void loop() {
 
  referenzFahrt();
  encoder_lesen();
  schritteZaehlen();
  }

void referenzFahrt() {
  if (radio.available())
{
Serial.println("Data there");
radio.read(data, 1);
Serial.println(data[0]);
}

      // Reverenzfahrt

      if ((data[0] == 255) && (rever_start == false) && (nullStellung == false)) { 
        rever_start = true;
        Serial.println("Reverenzfahrt gestartet");
    //    digitalWrite (pin_motor_rechts, HIGH);
      //  digitalWrite (pin_motor_links, LOW);
      }
      else if ((data[0] == 254) && (rever_start == true)) {
        nullStellung = true;
        rever_start = false;
        Serial.println("Reverenzfahrt beendet");
        Serial.println (" ");  
  //      digitalWrite (pin_motor_rechts, LOW);
//        digitalWrite (pin_motor_links, LOW); 
      }
    }
  
  void encoder_lesen () {
   if ((data[0] <= 48) && (data[0] > 0) && (nullStellung == true) && (ergebnis == false)) {
    //rechtsrum data[0] Schritte 
    schritte[0] = data[0];
    ergebnis = true;
    // Motor
    Serial.println (schritte[0]);
    Serial.print ("  Schritte nach Rechts"); 
    Serial.println (" ");   
   }
  else if ((data[0] >=100) && (data[0] <= 149) && (nullStellung == true) && (ergebnis == false)) {
    //linksrum data[0] - 100 Schritte
    schritte[0] = data[0] - 100;
    ergebnis = true;
    // Motor
    Serial.println (schritte[0]);
    Serial.print ("  Schritte nach links");
    Serial.println (" ");
   }
  }
 
void schritteZaehlen () {

  sensor = digitalRead (hal);
  startZeit = millis();
  if ((schritte[0] != 0) && (ergebnis == true)) {
    start = true;
    if ((startZeit - vergangeneZeit >= interval) && (sensor == LOW) && (start == true)) {
      vergangeneZeit = startZeit;
      schritte[0]--;
      Serial.println("Drehung start");
      Serial.println("Restl. Pos.");
      Serial.println(schritte[0]);
      radio.stopListening(); 
      radio.write (&schritte, sizeof (schritte));
      radio.startListening();
      }
  }
  else if ((schritte[0] == 0) && (start == true)) {
    start = false;
    ergebnis = false;
    data[0] = 0;
    Serial.println("Ziel");
    Serial.println("Drehung");
    Serial.println("beendet");
    Serial.print("daten");
    Serial.println(schritte[0]);
    radio.stopListening();
    radio.write (&schritte, sizeof (schritte));
    radio.startListening();
    //schritte[0]=0;
    
    Serial.println(ergebnis);
    }
}
  • Stimmt der Stopbefehl ist noch nicht drin. Diesen würde ich wieder in eine Funktion packen, die dann augeführt wird, wenn eine 0 vom Sender kommt.

  • Die Positionserkennung (Zeit) ist dazu da um ein Erneutes auslesen den Sensors zu vermeiden.

  • Was meinst du mit den Verschachtelten Funktionen? Der Ablauf ist im Moment folgender:

  • die Bühne empfängt vom Sender eine 255 (die Reverenzfahrt wird gestartet) Bühne beginnt zu
    drehen

  • dann sendet der Sender eine 254 (wenn der Referenzpunkrt erreicht ist) Bühne stoppt

  • wenn jetzt vom Sender eine Zahl (Schritte) <48 kommt, dreht die Bühne rechtsrum

  • wenn eine Zahl > 100 kommt wird Zahl - 100 = Schritte linksrum

  • Jetzt wird bei jeder Sensor Betätigung die Variable schritte um 1 verringert bis sie 0 ist

  • dann hält die Bühne an und wartet auf neue Befehle

  • Während der Ganzen Zeit wo die Bühne dreht, lauscht sie ob eine 0 vom Sender kommt.
    Kommt diese soll die Bühne anhalten (Das ist Zukunft).

Ich hoffe ich konnte es etwas erklären.

Vielen Dank das ihr mir helft.

Dem Sender fehlt ein startListening in setup.

Der Receiver wird nicht so kurz wie möglich abgeschaltet.

Du sendest solange der Knopf gedrückt ist, nicht wenn er gedrückt wird.

 buttonState = HIGH;//reset the button state variable

Reines Wunschdenken.

Dein Ablauf ist IMHO unausgegoren und viel zu verschränkt.

  • Die Positionserkennung (Zeit) ist dazu da um ein Erneutes auslesen den Sensors zu vermeiden.

Warum in Gottes Names würde man einen Sensor nicht lesen wollen?
Könnte aber das gleiche Problem wie mit deiner Taste sein, du hast keine State-Change-Detection.

Und weiterhin: Warum nutzt du einelementige Arrays?

Was meinst du damit? Ich stoppe doch das Hören und starte es gleich nach dem Schreiben wieder?

Der Receiver wird nicht so kurz wie möglich abgeschaltet.

Die Arrays stammen auch aus dem Beispielcode. Ich dachte es funktioniert nur mit Arrays

Bei dem Sensor müsste ich vielleicht mit Flanke arbeiten?

Ich merke schon das ich den Beispielcode genommen und etwas umgeändert habe, war großer Mist.

Acki1985:
Was meinst du damit? Ich stoppe doch das Hören und starte es gleich nach dem Schreiben wieder?

  if (buttonState == LOW)
  {
    NRF24L01.stopListening();
    Serial.println("1");
    NRF24L01.write(&schritte, sizeof(schritte));
    Serial.println(schritte[0]);

    NRF24L01.startListening();
  }

Lüge.