NRF24L01+ über mehrere Kanäle kommunizieren?

[mompf (Gast)]

Guten Tag zusammen,

ich will mit zwei Arduinos und zwei NRF24L01+ eine bidirektionale 
Funkübertragung realisieren. Für den Arduino und das Funkmodul gibt es 
schon folgende Funktionen:
http://tmrh20.github.io/RF24/classRF24.html

Die einseitige Übertragung funktioniert auch bereits. Allerdings schaffe 
ich es nicht, dass ein Modul "gleichzeitig" senden UND empfangen soll. 
Kann mir bitte jemand weiterhelfen?

Ist es vielleicht möglich, dass mit verschiedenen Kanälen zu machen? 
Habe noch nicht ganz verstande, was es damit auf sich hat.

[greg (Gast)]

Das funktioniert nicht. Der Chip kann zur gleichen Zeit entweder senden 
oder empfangen. Du könntest dir ein zweites Funkmodul hernehmen um auf 
zwei Frequenzen zu funken. Aber brauchst du wirklich Full-Duplex?

[mompf (Gast)]

Ich brauche nicht unbedingt full-duplex, also das gleichzeitige Senden 
und Empfangen von Daten. Aber ich würde gerne umschalten können, 
zwischen senden und empfangen.

Die Funkmodule sind in einer Fernsteuerung und in einem Fahrzeug. Ich 
möchte die meiste Zeit mit der Fernsteuerung die Befehle versenden. Aber 
wenn ich eine bestimmte Taste drücke, dann soll die Akkuspannung vom 
Fahrzeug an die Fernsteuerung gesendet werden.

[Nobody (Gast)]

Das geht doch alles....
Die haben doch extra 6 Rohre, um miteinander quatschen zu können.

[mompf (Gast)]

Nobody schrieb:
> Das geht doch alles....
> Die haben doch extra 6 Rohre, um miteinander quatschen zu können.

Aber wie lege ich fest, über welche pipe die miteinander kommunzieren 
sollen? Bei den Befehlen radio.write und radio.read kann ich leider 
nicht die pipe auswählen.

[Nobody (Gast)]

Du hast doch selber die Doku hier verlinkt!
http://tmrh20.github.io/RF24/classRF24.html#a9edc910ccc1ffcff56814b08faca5535
http://tmrh20.github.io/RF24/classRF24.html#af2e409e62d49a23e372a70b904ae30e1

[mompf (Gast)]

Nobody schrieb:
> Du hast doch selber die Doku hier verlinkt!
> http://tmrh20.github.io/RF24/classRF24.html#a9edc910ccc1ffcff56814b08faca5535
> http://tmrh20.github.io/RF24/classRF24.html#af2e409e62d49a23e372a70b904ae30e1

Damit öffne ich die pipes ja nur. Aber beim schreiben oder lesen kann 
ich diese nicht auswählen.

Kann mir jemand sagen, warum das nicht funktioniert? Bevor ich die 
Taster drücke funktioniert die Übertragung, aber beim Wechseln in den 
anderen Modus gibt es Probleme. Oft hängt sich der arduino dann auf.

#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#define CE_PIN   9
#define CSN_PIN 10

const uint64_t pipe = 0xE8E8F0F0E1LL;
const uint64_t pipe1 = 0xB3B4B5B6F1LL;
RF24 radio(CE_PIN, CSN_PIN);
LiquidCrystal lcd(2, 3, 4, 5, 6, 7);
int senden[2];
int empfangen[2];
int modus = 0;

void setup() {
 Serial.begin(9600);
 radio.begin();
 lcd.begin(16, 2);
}

void loop() {

 
  if (analogRead(A5) >= 30 && modus == 0){
  modus = 1;
  delay(1000);
  }
  if (analogRead(A5) >= 30 && modus == 1){
  modus = 0;
  delay(1000);
  }
 
  if (modus == 0){
  radio.stopListening();
  radio.openWritingPipe(pipe);
  senden[0]=99;
  radio.write( senden, sizeof(senden) );
  }

  if (modus == 1){
  radio.openReadingPipe(1,pipe1);
  radio.startListening();
  radio.read( empfangen, sizeof(empfangen) );
  Serial.println(empfangen[0]);
  }
}

#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#include <LiquidCrystal.h>
#define CE_PIN   9
#define CSN_PIN 10

const uint64_t pipe = 0xE8E8F0F0E1LL;
const uint64_t pipe1 = 0xB3B4B5B6F1LL;
RF24 radio(CE_PIN, CSN_PIN);
LiquidCrystal lcd(2, 3, 4, 5, 6, 7);
int senden[2];
int empfangen[2];
int modus = 0;


void setup() {
 Serial.begin(9600);
 radio.begin();
 lcd.begin(16, 2);
}

void loop() {

    if (analogRead(A5) >= 30 && modus == 0){
    modus = 1;
    delay(1000);
    }
    if (analogRead(A5) >= 30 && modus == 1){
    modus = 0;
    delay(1000);
    }    


  Serial.println(modus);
  if (modus == 1){
  radio.stopListening();
  radio.openWritingPipe(pipe1);
  senden[0]=23;
  radio.write( senden, sizeof(senden) );
  }

  if (modus == 0){
  radio.openReadingPipe(1,pipe);
  radio.startListening();
  radio.read( empfangen, sizeof(empfangen) );
  Serial.println(empfangen[0]);
  }
}

[peter (Gast)]

So sende ich Daten zum Roboter und wieder zurück zum ersten Arduino:

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

#define CE_PIN   53
#define CSN_PIN  48

byte inbyte1;
byte daten1[1];
byte daten11[1];

byte inbyte2;
byte daten2[1];
byte daten22[1];

RF24 radio(CE_PIN, CSN_PIN);

const uint64_t pipes[2] = {0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL};
const char* role_friendly_name[] = { "invalid", "Ping out", "Pong back"};
typedef enum { role_ping_out = 1, role_pong_back } role_e;

//role_e role = role_ping_out;   // Breadboard
role_e role = role_pong_back;  // Roboter

void setup(void)
{
  Serial.begin(9600);
  delay(500);

  radio.begin();
  radio.setRetries(15,15);

  radio.openReadingPipe(1,pipes[1]);
  radio.startListening();
  //radio.printDetails();

  if (role == role_ping_out)
  {
    radio.openWritingPipe(pipes[0]);
    radio.openReadingPipe(1,pipes[1]);    
  }

  if ( role == role_pong_back )
  {
    radio.openWritingPipe(pipes[1]);
    radio.openReadingPipe(1,pipes[0]);  
  }
}

void loop(void)
{
  if (role == role_ping_out)
  {
    inbyte1 = inbyte1+5;
    daten1[0] = inbyte1;
    radio.stopListening();
    radio.write( daten1, sizeof(daten1));
    radio.startListening();

    unsigned long started_waiting_at = millis();
    bool timeout = false;
    
    while ( ! radio.available() && ! timeout )
    if (millis() - started_waiting_at > 200 )
    timeout = true;

    if ( timeout )
    {
      goto weiter;
    }
    else
    {
      radio.read( daten11, sizeof(daten11) );
      Serial.print("daten11 = ");
      Serial.println(daten11[0]);
      delay(10);
    }
    
    weiter:
    delay(500);
  }

  if ( role == role_pong_back )
  {
    if ( radio.available() )
    { 
      unsigned long got_time;
      bool done = false;
      while (!done)
      {
        done = radio.read( daten22, sizeof(daten22) );
        Serial.print("daten22 = ");
        Serial.println(daten22[0]);
        delay(10);
      }
      
      inbyte2 = inbyte2+1;
      daten2[0] = inbyte2;
      radio.stopListening();
      radio.write( daten2, sizeof(daten2));   
      radio.startListening();
    }
  }
}

So ist es für das Breadboard:
---------------------------------------
role_e role = role_ping_out;   // Breadboard
//role_e role = role_pong_back;  // Roboter
---------------------------------------

Und so für den Roboter:
---------------------------------------
//role_e role = role_ping_out;   // Breadboard
role_e role = role_pong_back;  // Roboter
---------------------------------------


Für beide das selbe Programm.

Gruss

[Peter B. (funkheld)]

Das was ich bei mir fest vorgebe kannst du dann auch mit einem Taster 
wechseln.

Kannst das Programm bei dir mal testen.


Gruss

[mompf (Gast)]

Ich werde es mal ausprobieren.

Aber mit meinem Code funktioniert es auch, wenn ich den Modus in dem 
Code festlege.
Aber wenn ich den Modus per Tastenabfrage festlage, dann gibt es ja eine 
kleine Zeitspanne, in welcher beide senden/ empfangen. Das ist glaub das 
Problem, denn das hängt er sich meistens auf.

[wv (Gast)]

Hallo allerseits,

ich würde da eine völlig anderen Ansatz verfolgen. Wenn Du auf dem 
Rückkanal keine Echtzeit brauchst, kannst Du Dir die ganze Umschalterei 
sparen. Schau Dir mal die Funktionen EnableAutoAcknowledge in Verbindung 
mit EnableAcknowledgePayload an. Du hast die Möglichkeit, bei jedem 
Datentransfer vom Sender zum Empfänger mit  dem AutoAcknowledge, das im 
Hintergrund automatisch geschieht, 32 Byte zurückzusenden, ohne dabei 
selbst aktiv die Sende-Empfangsrichtung umzuschalten.

Damit kannst Du sogar weit mehr als nur die Akkuspannung messen, das ist 
die leichteste Übung. Du brauchst nur im Empfänger im entsprechenden 
Register die Akkuspannung regelmäßig zu aktualisieren, bei jedem 
Steuerbefehl den du sendest kommt der dann automatisch zurück, den mußt 
Du im Sender dann nur noch auslesen und auswerten.

Gruß wv

[mompf (Gast)]

wv schrieb:
> Schau Dir mal die Funktionen EnableAutoAcknowledge in Verbindung
> mit EnableAcknowledgePayload an. Du hast die Möglichkeit, bei jedem
> Datentransfer vom Sender zum Empfänger mit  dem AutoAcknowledge, das im
> Hintergrund automatisch geschieht, 32 Byte zurückzusenden, ohne dabei
> selbst aktiv die Sende-Empfangsrichtung umzuschalten.

Hallo,

meinst du die Funktionen enableAckPayload und setAutoAck ?
Ich verstehe noch nicht ganz wie das funktionieren soll. Zunächst muss 
ich diese Funktion aktivieren und dann sendet es immer automatisch die 
32 Byte zurück? Kann ich aber auch bestimmen, was mir zurückgeschickt 
wird? Und wie kann ich diese 32 Byte auslesen?

[Georg G. (df2au)]

mompf schrieb:
> Zunächst muss
> ich diese Funktion aktivieren
Ja

> und dann sendet es immer automatisch die
> 32 Byte zurück?
So ist es. Und das Hin und Her wird so oft ausgeführt, bis beide Seiten 
zufrieden sind oder max Versuche vergangen sind.

> Kann ich aber auch bestimmen, was mir zurückgeschickt
> wird?
Anders würde es keinen Sinn machen.

> Und wie kann ich diese 32 Byte auslesen?
In der RxPipe0

Da Datenblatt sagt dir alles. Fang mal mit der Register Beschreibung an 
(Stichwort AutoAck) und sieh dir die Befehlsliste an. Ich kenne die 
Arduino Lib nicht, fürchte aber, dass diese Funktionalität nicht drin 
ist. Da wirst du wohl selbst Hand anlegen müssen.

[Bauslub (Gast)]

Vielleicht hilft dir das hier (jetzt oder später) weiter:

https://shantamraj.wordpress.com/2014/07/19/exploring-the-auto-ack-feature-of-the-transceiver/

https://shantamraj.wordpress.com/2014/11/30/auto-ack-completely-fixed/