Nrf24l1 multi Node

Die übertragung soll nicht so oft geschehen , der Hintergrund dieser 3 Codestücke ist das ich erst eine sauber Verbindung ohne Fehler hienbekomme möchte und erst dann mit den Dingen weitermache wozu die sache gedacht ist zB Temp übertragen Licht und Wasserpumpe an aus schalten etc.Der Taster im Sketch simuliert nur einen Stromausfall damit ich in der Versuchsphase nicht immer den USB Stecker rausfummeln muß.
Das mit dem Licht und der Pumpe läuft schon .Jezt soll die Sache erweitert werden um ein angedachtes Gewächshaus zu steuer und zu überwachen.

Thorsten4171:
Die übertragung soll nicht so oft geschehen

Warum hast du das dann so programmiert?

Thorsten4171:
der Hintergrund dieser 3 Codestücke ist das ich erst eine sauber Verbindung ohne Fehler hienbekomme möchte

Das ist durch das ungebremste Senden ausgeschlossen.

Danke für den Hinweis. werde mal versuchen das zu ändern und berichten.

Hallo Whandall

Könnte es so besser auf Sendeseite aussehen? Es funktioniert zumindest. Ich bilde mir ein so habe ich den Sender ausgebremst.

//  COM11 //

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

byte a=2;
float temp2=22;
unsigned long vorherigeMillis = 0;
const long    interval = 5000;

RF24 radio(7, 8);
/*const uint64_t pipes[3] = { 0xF0F0F0F0E1LL, 0xF0F0F0F0E2LL, 0xF0F0F0F0E3LL };*/
byte pipes[][6] = {"0", "1","2"};
void setup() {
Serial.begin(115200);

radio.begin();
radio.setDataRate(RF24_250KBPS);
radio.openWritingPipe(pipes[2]);

}

void loop()
{
unsigned long aktuelleMillis = millis();
if (aktuelleMillis - vorherigeMillis >= interval) {
vorherigeMillis = aktuelleMillis;
Serial.println("jezt sende ich................................");
radio.write(&temp2, sizeof(temp2));

}
Serial.println("tue was anderes");


}

Mit Strg+t in der IDE sieht es auch noch besser lesbar aus:

void loop()
{
  unsigned long aktuelleMillis = millis();
  if (aktuelleMillis - vorherigeMillis >= interval) 
  {
    vorherigeMillis = aktuelleMillis;
    Serial.println("jezt sende ich................................");
    radio.write(&temp2, sizeof(temp2));
  }
  Serial.println("tue was anderes");
}

Danke ich interpretiere das als "bin auf dem richtigen Weg"

Das Senden hast du jetzt begrenzt, dennoch blockiert dein Sendeprogramm an

  Serial.println("tue was anderes");

denn jetzt ist dieser Aufruf völlig unmoderiert.

Verlange von einem Rechner nicht mehr als er leisten kann, sonst gerät dein ganzes Timing durcheinander.

In diesem Teil dachte ich andere Aufgabe wie Temp lesen Bewässerung ein aus schalten etc. zu erledigen.
Solche Anweisungen schreibe ich mir immer wieder rein um zu begreifen wo ich im Programm bin und was es macht. Hoffe das ist nicht falsch und kontraproduktiv

Thorsten4171:
Hoffe das ist nicht falsch und kontraproduktiv

Diese Hoffnung täuscht.

Ein Kommentar an der Stelle erfüllt den gleichen Zweck, behindert aber das restliche Programm nicht.

Thorsten4171:
Danke ich interpretiere das als "bin auf dem richtigen Weg"

Ja, der Interpretation stimme ich zu.

Und als Trost: Die Beschreibung von radio.available() steht an der einen, die von radio.available(&fromPipe) deutlich weiter hinten, da bin ich auch nicht drauf gekommen. Da ist es gut, wenn man jemanden findet, der diese Hürde schon überwunden hat. @Whandall: Das war jetzt ein Lob :slight_smile:

Aber wie mache ich einen Kommentar sichtbar wenn ich z.b in einer Schleife festhänge?Oder verstehe ich das jezt falsch?

Wenn etwas nicht funktioniert sind Debugausgaben natürlich absolut in Ordnung,
einen richtigen Debugger hat man ja nicht zur Verfügung.

Für Statusanzeigen könntest du LEDs an freie Pins hängen,
Pin-I/O ist höllenschnell gegenüber serieller Ausgabe.

Noch etwas das mir auffiel:

radio.write(&temp2, sizeof(temp2));

Du wertest den Rückgabewert dieser Funktion nicht aus, das ist zumindestens in der Testphase
nicht besonders clever.

Wenn die Funktion erfolgreich war, hat der Empänger die Nachricht erhalten und bestätigt,
ansonsten könnte die Übertragung oder die Bestätigung gestört sein.
Im Datenblatt findest du alle möglichen Scenarien beschrieben.

Ah Danke werde ich mal ausprobieren. Das die serielle Ausgabe bremst hatte ich im Gefühl bei meinem Projekt mit einem LED Lauflicht , dort hatte ich solche Ausgaben auch eingebaut und erst am Ende als alles lief wie gewollt und ich diese Anweisungen rausgenommen hatte wurde die volle Geschwindigkeit erreicht.

Ich würde den umgekehrten Weg gehen.

Das Programm schreiben und den Test entscheiden lassen wo ich Debugausgaben einfüge
und natürlich nach Korrektur des Fehlers wieder entferne.

Das hört sich besser an .Spart wenn alles auf Anhieb läuft viel Tipparbeit

Thorsten4171:
Das hört sich besser an .Spart wenn alles auf Anhieb läuft viel Tipparbeit

Ich traue mich lange nicht, die Testausgaben rauszuwerfen. Da hilft eine bedingte Ausgabe:

#define DEBUGMODE 0                 // 1 für Ausgabe über den "Seriellen Monitor", 0 keine Ausgabe (geringerer Speicherbedarf)
...
void setup() {
...
#if (DEBUGMODE==1)  // # in diesem Fall bewirkt, dass dieser Teil nur abgearbeitet wird (und Speicherplatz braucht) wenn DEBUGMODE 1, also wahr, ist. (siehe: https://de.wikibooks.org/wiki/C-Programmierung:_Pr%C3%A4prozessor )
  Serial.begin(9600);
  Serial.println(F("\nOLED Uhr mit DCF77, RTC und zus. Akku-Spannungsanzeige, Testausgabe"));
#endif             // schließt den # Teil ab
...
}

void loop() {
...
#if (DEBUGMODE==1)
    char buf[28];
    RTCreadTime(time);
    snprintf(buf,sizeof(buf),">%01d< %02d.%02d.%04d  %02d:%02d:%02d", time.iWochentag, time.bDay, time.bMonth, time.iYear, time.bHour, time.bMinute, time.bSecond);
    Serial.println(buf); // RTC Zeit anzeigen (>Wert Wochentag< Datum Uhrzeit)
    Serial.println(DCFstaerke);
#endif
...
}

oder

// Debugging

#define DEBUG Serial // Debugging

#ifdef DEBUG
#define debug(...) DEBUG.print(__VA_ARGS__)
#define debugln(...) DEBUG.println(__VA_ARGS__)
#define debugbegin(...) DEBUG.begin(__VA_ARGS__)
#else
#define debug(...)
#define debugln(...)
#define debugbegin(...)
#endif
...
void setup() {
  debugbegin(9600);
...
}

void loop() {
...
        debug("PIR an Pin ");
        debug(pir[i]);
        debugln(" hat Bewegung registriert");
...
}

Um einen "seriellen Kollaps" zu vermeiden, geht auch

if(oneshot)
{
  oneshot = false;
  Serial.print("Hier bin ich!");
}

oder

if(testausgabe && (aktuelleMillis - ausgabeMillis >= ausgabeIntervall))
{
  ausgabeMillis = aktuelleMillis;
  Serial.print("Hier bin ich!");
}

Außerdem kann man schnell mal die Geschwindigkeit ohne Ausgaben probieren.

Nur mal so als Anregung :slight_smile:

Hi

Wenn Du bei dem 'Hier bin ich' noch ein LINE einfügst (2 Underline, das Wörtchen LINE und 2 weitere Underline) bekommst Du auch die Zeilennummer im Quelltext.

Meine Debug-Ausgaben sehen so aus und entstanden durch schamloses Abkupfern hier gefundener Informationen :wink:

//*****************************************************
//** stellt abschaltbare/skalierbare Serial.print Funktionalität
//** ohne define DEBUG werden alle Ausgaben gar nicht erst eingebunden
//** mit define DEBUG je nach 'Wichtigkeit' ausgegeben, oder ignoriert
//** Je höher das 'Debuglevel'
//** einstellbar per ''debuglevel(12);'' -> stellt den Debuglevel auf 12
//** debugablevel wird fest im Sketch eingetragen, alle Level >= werden ausgegeben
//**
//** Definitionen ganz vorne im Sketch, NICHT innerhalb einer Funktion wie setup()
//*****************************************************
#define DEBUG    //ausklammern, wenn keine serielle Ausgabe zum Terminal mehr gebraucht wird

#ifdef DEBUG
 const byte debugablevel = 0xF0;    //  unterhalb diesem Level keine Ausgabe, ** hier anpassen **
 const boolean debugother = true;   //  Anzeigen der Zeilennummern von nicht angezeigten Debug-Ausgaben - false lässt auch Diese verschwinden, ** hier anpassen **
 byte debuglevel = 0;            // wird per debuglevel(xx); angepasst, je höher der Level, desto 'eher' die Ausgabe
 #define debugBegin(...) Serial.begin(__VA_ARGS__)
 #define debugPrint(...)  {if (debuglevel>=debugablevel){Serial.print(__VA_ARGS__);}else if (debugother){Serial.print("(");Serial.print(debuglevel,HEX);Serial.print("@"); Serial.print(__LINE__);Serial.print(")");} }
 #define debugPrintln(...)  {if (debuglevel>=debugablevel){Serial.println(__VA_ARGS__);}else if (debugother){Serial.print("(");Serial.print(debuglevel,HEX);Serial.print("@"); Serial.print(__LINE__);Serial.print(")");} }
 #define debuglevel(...) debuglevel=__VA_ARGS__;
//
//Quelle: https://forum.arduino.cc/index.php?topic=46900.0
 #define DEBUG_PRINT(str)    \
   Serial.print(millis());     \
   Serial.print(": ");    \
   Serial.print(__PRETTY_FUNCTION__); \
   Serial.print(' ');      \
   Serial.print(__FILE__);     \
   Serial.print(':');      \
   Serial.print(__LINE__);     \
   Serial.print(' ');      \
   Serial.println(str);
 #pragma message ("DEBUG angegeben");  //Anzeige/Hinweis beim Compilieren
#else
 #define debugBegin(...)
 #define debugPrint(...)
 #define debugPrintln(...)
 #define debuglevel(...)
 #define DEBUG_PRINT(str)
#endif
//*****************************************************

Den Block nur vorne in den Code reinkopieren und im Programm statt Serial.print debugPrint benutzen.
Per Befehl debuglevel(23) wird die 'Wichtigkeit' der nun folgenden Ausgaben auf 23 gesetzt - wenn dieser Wert größer/gleich debugablevel ist (wird im Code fest vorgegeben, ab welchem Level man die Ausgabe haben will, dort anpassen), wird der Serial.print-Inhalt ausgegeben, sonst nur eine Status-Nachricht, daß Da noch eine Debug-Ausgabe ist (wenn debugother == true ist).
Oha - habe ich auch als Erklärung im Code drin - doppelt hält besser.

MfG

Edit
Ein DU in ein Du geändert, sind hier ja Alle lieb zueinander, da muß man nicht gleich die Leute anschreien :wink:

postmaster-ino:
... und entstanden durch schamloses Abkupfern hier gefundener Informationen :wink:

Das trifft für die von mir gezeigten Varianten natürlich genauso zu :slight_smile:

Danke für eure Tipps werde ich in Zukunft beachten . Habe soeben erfolgreich 2. Sender in bestehendes Projekt intrigiert. Dem Gewächshaus steht nichts mehr im Wege.
Dank an alle Beteiligten für ihre Hilfe