Hallo alle zusammen,
ich bin neu im Thema Arduino und bin fasziniert von den Möglichkeiten.
Kleinere Versuche habe ich bereits mit Erfolg realisiert.
Bei meinem jetzigen Projekt komme ich leider nicht weiter.
Es handelt sich um drei Füllstandsmelder die bei vollen Behältern ein Signal an eine Meldeeinheit funken diese dann eine bestimmte LED per Relay anschaltet.
Somit möchte ich gerne über 3 Sender Nanos (montiert an Behälter 1, 2 und 3) per NRF24l01 Modul ein Signal an ein Empfänger Nano senden. Die Sender Nanos bekommen auf einem Digital Pin ein HIGH Signal sobald der kapazative Sensor merkt das der Behälter voll ist. Das HIGH Signal wird dann per NRF24l01 Modul an den Empfänger Nano weitergeleitet. Der Empfänger Nano schaltet dann auf einer Relaiskarte das entsprechende Relay auf HIGH um eine LED aufleuchten zu lassen. Wird der Behälter entleert sollte sich das ganze System natürlich wieder zurücksetzen, da der Sensor kein Signal mehr gibt.
Das ganze klappt mit einem Sender und einem Empfänger Nano echt gut.
Damit ich nicht jeweils immer einen Sender und Empfänger pro Behälter benötige wollte ich alle Sender mit einem Empfänger kommunizieren lassen.
Da komme ich nicht ganz weiter. Ich habe den unten stehenden Code im Netz gefunden. Dieser scheint auch keine Probleme wie zum Beispiel Überschneidungen der Nachrichten zu machen.
Aufgrund meiner mangelnden Kenntnisse bekomme ich den Code aber keineswegs auf mein Vorhaben umgeschrieben. Im Grunde möchte ich ein erhaltenes HIGH per Funk weiterleiten und dann auf die Relaiskarte ausgeben.
Würde mich über jede Hilfe freuen.
Sender 1, Sender 2, Sender 3 (Adressen jeweils angepasst)
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#include "printf.h"
#include <Wire.h>
int address = 0x28; // 28 is the address
byte byte1, byte2, byte3, byte4;
RF24 radio (9, 10);
struct dataStruct{
float p1;
float t1;
float s1;
}transmitter1_data;
unsigned char ADDRESS0[5] =
{
0xb1,0x43,0x88,0x99,0x45
}; // Define a static TX address
//just change b1 to b2 or b3 to send to other pip on resciever
void setup()
{
// Wire.begin();
radio.begin();
Serial.begin(115200);
printf_begin();
radio.setRetries(15,15);
radio.enableDynamicPayloads();
radio.setDataRate(RF24_250KBPS);
radio.openWritingPipe(ADDRESS0);
radio.openReadingPipe(0,ADDRESS0);
radio.stopListening();
radio.printDetails();
}
void loop()
{
/*
Wire.requestFrom(address, 4); // byte is 4;
if (Wire.available()<=4 <=4) {//
byte1 = Wire.read();
byte2 = Wire.read();
byte3 = Wire.read();
byte4 = Wire.read();
}
long unsigned p_counts = (long unsigned)byte1 << 8
| (long unsigned)byte2;
long unsigned t_counts = (long unsigned)byte3 << 8
| (long unsigned)byte4;
p1[0] = ((p_counts%16384-1638.0)/13107.0*20.0)-10.0;
t1[0] = ((t_counts/32.0*200.0)/2047.0-50.0);
s1[0] = (p_counts/16384);
*/
transmitter1_data.p1=1002.36;
transmitter1_data.t1=27.33;
transmitter1_data.s1=15.9;
bool ok=radio.write(&transmitter1_data, sizeof(transmitter1_data));
if(ok)
{
Serial.println("Pipe 1");
Serial.println(transmitter1_data.p1);
Serial.println(transmitter1_data.t1);
Serial.println(transmitter1_data.s1);
}
else
{
Serial.println("it failed to send");
}
delay(1000);
}
Empfänger
#include <SPI.h>
#include <nRF24L01.h>
#include <RF24.h>
#include "printf.h"
RF24 radio (9, 10);
#define PLOAD_WIDTH 32 // 32 unsigned chars TX payload
byte pip;
byte pload_width_now;
byte newdata;
unsigned char rx_buf[PLOAD_WIDTH]= {0};
struct dataStruct1{
float p1;
float t1;
float s1;
}transmitter1_data;
struct dataStruct2{
float p1;
float t1;
float s1;
}transmitter2_data;
struct dataStruct3{
float p1;
float t1;
float s1;
}transmitter3_data;
unsigned char ADDRESS2[1]= {0xb2};
unsigned char ADDRESS3[1]= {0xb3};
unsigned char ADDRESS4[1]= {0xb4};
unsigned char ADDRESS5[1]= {0xb5};
unsigned char ADDRESS1[5] =
{
0xb1,0x43,0x88,0x99,0x45
}; // Define a static TX address
unsigned char ADDRESS0[5] =
{
0xb0,0x43,0x88,0x99,0x45
}; // Define a static TX address
void setup()
{
radio.begin();
printf_begin();
Serial.begin(115200);
radio.setDataRate(RF24_250KBPS);
radio.enableDynamicPayloads();
radio.openWritingPipe(ADDRESS0);
radio.openReadingPipe(0,ADDRESS0);
radio.openReadingPipe(1,ADDRESS1);
radio.openReadingPipe(2,ADDRESS2);
radio.openReadingPipe(3,ADDRESS3);
radio.openReadingPipe(4,ADDRESS4);
radio.openReadingPipe(5,ADDRESS5);
radio.startListening();
radio.printDetails();
delay(1000);
}
void loop()
{
if ( radio.available(&pip) )
{
// Fetch the payload, and see if this was the last one.
pload_width_now = radio.getDynamicPayloadSize();
// If a corrupt dynamic payload is received, it will be flushed
if(!pload_width_now){
}
else
{
radio.read( rx_buf, pload_width_now );
newdata=1;
// Spew it
Serial.print(F("Data on pip= "));
Serial.print(pip);
Serial.print(F(" Got data size="));
Serial.print(pload_width_now);
Serial.print(F(" data="));
for(byte i=0; i<pload_width_now; i++)
{
Serial.print(" ");
Serial.print(rx_buf[i]); // print rx_buf
}
Serial.print(" ");
}
}
if(newdata==1)
{
newdata=0;
if(pip==1&&pload_width_now==sizeof(transmitter1_data))
{
memcpy(&transmitter1_data, rx_buf, sizeof(transmitter1_data));
Serial.print(" Pressure//temp//status ");
Serial.print(transmitter1_data.p1);
Serial.print(" // ");
Serial.print(transmitter1_data.t1);
Serial.print(" // ");
Serial.print(transmitter1_data.s1);
}
if(pip==2&&pload_width_now==sizeof(transmitter2_data))
{
memcpy(&transmitter2_data, rx_buf, sizeof(transmitter2_data));
Serial.print(" Pressure//temp//status ");
Serial.print(transmitter2_data.p1);
Serial.print(" // ");
Serial.print(transmitter2_data.t1);
Serial.print(" // ");
Serial.print(transmitter2_data.s1);
}
if(pip==3&&pload_width_now==sizeof(transmitter3_data))
{
memcpy(&transmitter3_data, rx_buf, sizeof(transmitter3_data));
Serial.print(" Pressure//temp//status ");
Serial.print(transmitter3_data.p1);
Serial.print(" // ");
Serial.print(transmitter3_data.t1);
Serial.print(" // ");
Serial.print(transmitter3_data.s1);
}
Serial.println("");
}
delay(100);
}