nRF24L01 interrupt am Arduino

[Jonny H. (jonny123)]

Hallo,

ich möchte eine Smart-Home mit einem Arduino Mega als Master aufbauen, 
welches über CAN kommuniziert. Dies funktioniert bisher auch recht gut 
(im kleinen Aufbau).
Zusätzlich möchte ich auch andere Geräte über 2.4 Ghz ansprechen.
Hierzu habe ich mir ein paar nRF24L01 besorgt.


Allerdings ist das Programm so umfangreich, dass es immer um die 17 ms 
zum durchlaufen benötigt. Und es wird noch sehr viel umfangreicher.

Jetzt habe ich das Problem, dass das die am Master ankommenden Daten vom 
Slave nicht immer ausgewertet werden, weil das Programm gerade etwas 
anderes macht.

Also wollte ich den Interrupt Pin am nRF24L01 nutzen. Hierzu habe ich 
mir ein kleines Programm zum testen geschrieben.

/*
   2.4 GHz Master

  Pinbelegung:
    NRF24L01  | Arduino Uno/Nano/Mini  | Arduino Mega
    VCC                 3.3 V               3.3 V
    GND                 GND                 GND
    CSN                 8                   8
    CE                  7                   7
    SCK                 13                  52
    MOSI                11                  51
    MISO                12                  50
    IRQ                  3                   3


*/
#define SenderID 1 // Wie CAN-ID


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


RF24 radio(7, 8); // CE, CSN
#define PinIRQ 3  // Arduino Uno, Mega und Nano: Pin 3
#define IRQ 1
const byte addresses[][6] = {"12345", "54321"}; // Kommunikationsrichtung: {"Slave -> Master", "Master -> Slave"};

unsigned long letzteUebermittelteNachricht = 0;
unsigned long SendeIntervall = 5000;
volatile unsigned char Empfangen[9];
volatile byte neueNachrichtEmpfangen = false;

void setup() {
  Serial.begin(115200);
  attachInterrupt(IRQ, AnkommendeNachricht, FALLING);
  radio.begin();
  radio.openWritingPipe(addresses[1]);      // Mater -> Slave
  radio.openReadingPipe(1, addresses[0]);   // Slave -> Master
  //radio.setPALevel(RF24_PA_MIN);
  radio.startListening();
}
void loop()
{
  unsigned long aktuelleMillis = millis();
  /*************************************************************
     Nachricht senden, falls das Sendeintervall abgelaufen ist
   *************************************************************/
  if (aktuelleMillis - letzteUebermittelteNachricht > SendeIntervall)
  {
    letzteUebermittelteNachricht = aktuelleMillis;
    int LaufzeitInSekunden = aktuelleMillis / 1000;
    unsigned char Sendung[9] = {SenderID, LaufzeitInSekunden, 1, 2, 3, 4, 5, 100, 255};
    radio.stopListening();
    radio.write(&Sendung, sizeof(Sendung));
    radio.startListening();
    Serial.print("2.4 Ghz-Nachricht gesendet: ");
    for (int i = 0; i < 9; i++)
    {
      Serial.print(Sendung[i]);
      Serial.print("\t");
    }
    Serial.println();
  }
  /*************************************************************
    Prüfen ob eine Nachricht vorliegt
  *************************************************************/
  if (neueNachrichtEmpfangen)
  {
    Serial.print("2.4 Ghz-Nachricht von ID ");
    Serial.print(Empfangen[0]);
    Serial.print(" empfangen: ");
    for (int i = 1; i < sizeof(Empfangen); i++)
    {

      Serial.print(Empfangen[i]);
      Serial.print("\t");
    }
    Serial.println();
    neueNachrichtEmpfangen = false;
  }
  if (aktuelleMillis % 1000 == 1)     // Zur Kontrolle, ob der Arduino noch läuft
  {
    Serial.println("Laeuft");
  }
  delay(1);
}

void AnkommendeNachricht()
{
  Serial.println("Interrupt");
  radio.read(Empfangen, sizeof(Empfangen));
  neueNachrichtEmpfangen = true;    // Variable setzen, dass eine neue Nachricht zur Auswertung bereit steht
}

Das Programm läuft ca 5 Sekunden einwandfrei und dann kommt permanent 
ein Interrupt, obwohl eigentlich nichts gesendet wird.
Sieht jemand den Fehler oder hat jemand etwas ähnliches schon gemacht?
Stört vielleicht mein 2.4 Ghz WLAN?

Meine 3.3V Spannungsquelle läuft recht stabil, soweit ich es ohne 
richtiges Oszi beurteilen kann.

Gruß
Jonny

[Anal Eiser (Gast)]

Schwerster (und vielleicht einziger) Fehler den ich momentan
sehe ist dass du in deiner Funktion AnkommendeNachricht die ja
im Interrupt-Kontext aufgerufen wird, mit println arbeitest.

Das ist tötlich da du eine ganze Ewigkeit dort Zeit verbrauchst
Zeichen auszugeben und die Routine sich bemüssigt sieht dauernd
darauf zu warten dass dein serielles Terminal endlich alle
Zeichen empfangen hat.

Du musst ein Flag im Interrupt-Kontext setzen und in der Haupt-
schleife das "Signal" ausgeben. Aber auch da könnte es irgendwann
zeitlich eng werden wenn viele Interrupts und Daten vom NRF24
daherkommen.

[Anal Eiser (Gast)]

Dein Buffer Empfangen[9] könnte auch überlaufen und deine RAM-
Inhalte zerschossen werden da eine Nachricht aus dem NRF24
32 Byte netto gross sein kann.

Auch das

radio.read(Empfangen, sizeof(Empfangen));

würde ich nicht im Interrupt-Kontext sondern Flag-gesteuert
in der Hautpschleife abarbeiten. Damit kann der Arduino
zeitlich relaxter reagieren. Ist allerdings nicht so dringend
da das Umkopieren der Daten nur ein paar Mikrosekunden dauert.