Hallo,
ich hab mir mal Gedanken gemacht.
Eine lösung habe ich damit erzielt:
Sender
// Funkfernbedienung, Sender, 2-Wege Kommunikation
#include <SPI.h>
#include <RF24.h>
#include <LiquidCrystal_I2C.h>
// Identifikationscode für Reciever
#define code 1337
// CE, CSN Pins definieren
//RF24 radio(48, 49); // für Arduino Mega
RF24 radio(8, 7); // für Arduino Nano/Uno/etc
static const uint64_t pipes[6] = {0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL, 0xF0F0F0F0C3LL, 0xF0F0F0F0B4LL, 0xF0F0F0F0A5LL, 0xF0F0F0F096LL};
// I²C Adresse für LCD, Spalten, Zeilen
LiquidCrystal_I2C lcd(0x27, 20, 4);
// Messwerte
int poti1Val;
int poti2Val;
int poti1 = 1;
int poti2 = 0;
// Sonstige
int pong;
int sent = 0;
const long interval = 10000;
unsigned long previousMillis = 0;
int motorrpm;
int servowinkel;
// Pins
int beep = 3; // Speaker Pin
// Setup
void setup() {
// Seriellen Monitor starten (Baudrate 9600)
Serial.begin(9600);
// LCD-Setup
lcd.begin();
lcd.backlight();
lcd.clear();
// RF-24 Setup
radio.begin();
radio.setChannel(50); // Funkkanal - Mögliche Werte: 0 - 127
radio.setAutoAck(0);
radio.setRetries(15, 0);
radio.setPALevel(RF24_PA_MIN);
// RF24_PA_MIN=-18dBm, RF24_PA_LOW=-12dBm, RF24_PA_MED=-6dBM, and RF24_PA_HIGH=0dBm
// Pipes öffnen
radio.openWritingPipe(pipes[0]);
radio.openWritingPipe(pipes[1]);
radio.openWritingPipe(pipes[2]);
radio.openReadingPipe(1, pipes[1]);
radio.openReadingPipe(2, pipes[2]);
radio.openReadingPipe(3, pipes[3]);
// Pinmodes definieren
pinMode(beep, OUTPUT);
}
// Main loop
void loop()
{
messwerte(); // Messwerte auslesen
if (sent == 0)
{
transmit(); // Daten übermitteln
}
if (sent == 1)
{
recieve(); // Daten empfangen und auswerten
}
if (sent == 1 && pong != 69)
{
transmit(); // Daten übermitteln
}
// Serial.println(poti1Val);
// Serial.println(poti2Val);
// Serial.println(code);
}
// Messwerte auslesen und mappen
void messwerte()
{
poti1Val = analogRead(poti1);
poti2Val = analogRead(poti2);
poti1Val = map(poti1Val, 0, 1023, 170, 10);
poti2Val = map(poti2Val, 0, 1023, 255, 0);
}
// Inhalte per Funk übertragen
void transmit()
{
long message[8] = {int(poti1Val), int(poti2Val), (code)};
radio.stopListening();
radio.write(&message, sizeof(message));
// Serial.println("Sent");
sent = 1;
}
// Inhalte per Funk empfangen
void recieve()
{
radio.startListening();
// Serial.println("Start listening");
delay(10);
if (radio.available()) {
long got_message[8] = {0, 0, 0, 0, 0, 0, 0, 0};
bool done = false;
while (!done) {
done = radio.read(&got_message, sizeof(got_message));
}
motorrpm = got_message[0];
servowinkel = got_message[1];
pong = got_message[2];
// Serial.println(motorrpm);
// Serial.println(servowinkel);
// Serial.println(pong);
lcdPrint();
if (pong = 69)
{
// Serial.println("Recieved");
pong = 0;
}
sent = 0;
}
if (!radio.available()) {
unsigned long currentMillis = millis();
if (currentMillis - previousMillis >= interval) {
previousMillis = currentMillis;
lcd.clear();
lcd.setCursor(0, 0);
lcd.print("No data");
}
}
}
// Inhalte auf dem LCD ausgeben
void lcdPrint()
{
lcd.setCursor(0, 0);
if (motorrpm < 100 && motorrpm > 9)
{
lcd.print("Motor: ");
lcd.print("0");
lcd.print(motorrpm);
}
if (motorrpm < 10)
{
lcd.print("Motor: ");
lcd.print("00");
lcd.print(motorrpm);
}
if (motorrpm > 99)
{
lcd.print("Motor: ");
lcd.print("100");
}
lcd.print(" % ");
lcd.setCursor(0, 1);
if (servowinkel < 100 && servowinkel > 9)
{
lcd.print("Servo: ");
lcd.print("0");
lcd.print(servowinkel);
}
if (servowinkel < 10)
{
lcd.print("Servo: ");
lcd.print("00");
lcd.print(servowinkel);
}
if (servowinkel > 99)
{
lcd.print("Servo: ");
lcd.print(servowinkel);
}
lcd.print(" Grad");
}
Empfänger
// Funkfernbedienung, Empfänger, 2-Wege Kommunikation
#include <SPI.h>
#include <RF24.h>
#include <Servo.h>
// Identifikationscode für Transmitter
#define pong 69
// CE, CSN Pins definieren
//RF24 radio(48, 49); // für Arduino Mega
RF24 radio(8, 7); // für Arduino Nano/Uno/etc
static const uint64_t pipes[6] = {0xF0F0F0F0E1LL, 0xF0F0F0F0D2LL, 0xF0F0F0F0C3LL, 0xF0F0F0F0B4LL, 0xF0F0F0F0A5LL, 0xF0F0F0F096LL};
// Messwerte
int poti1Val;
int poti2Val;
// Pins
int motor = 3;
Servo myservo1;
// Sonstige
int motorrpm;
int servowinkel;
// Code Variable
int code;
// Main loop
void setup()
{
// Seriellen Monitor starten (Baudrate 9600)
// Serial.begin(9600);
// RF-24 Setup
radio.begin();
radio.setChannel(50); // Mögliche Kanäle 0-127
radio.setAutoAck(0);
radio.setPALevel(RF24_PA_MIN);
// RF24_PA_MIN=-18dBm, RF24_PA_LOW=-12dBm, RF24_PA_MED=-6dBM, and RF24_PA_HIGH=0dBm
// Pipes öffnen
radio.openWritingPipe(pipes[1]);
radio.openWritingPipe(pipes[2]);
radio.openWritingPipe(pipes[3]);
radio.openReadingPipe(1, pipes[0]);
radio.openReadingPipe(2, pipes[1]);
radio.openReadingPipe(3, pipes[2]);
// Pinmodes definieren
pinMode(motor, OUTPUT);
myservo1.attach(10);
// RF-24 Zuhören
radio.startListening();
}
// Main loop
void loop()
{
recieve(); // Daten empfangen und auswerten
}
// Inhalte per Funk empfangen
void recieve()
{
if (radio.available()) {
long got_message[8] = {0, 0, 0, 0, 0, 0, 0, 0};
bool done = false;
while (!done) {
done = radio.read(&got_message, sizeof(got_message));
}
poti1Val = got_message[0];
poti2Val = got_message[1];
code = got_message[2];
if (code == 1337)
{
if (poti2Val < 10)
{
digitalWrite(motor, LOW);
}
else {
analogWrite(motor, poti2Val);
}
myservo1.write(poti1Val);
Serial.println(poti1Val);
Serial.println(poti2Val);
Serial.println(code);
Serial.println("Sent");
servowinkel = map(poti1Val, 170, 10, 180, 0);
motorrpm = map(poti2Val, 255, 0, 100, 0);
transmit(); // Inhalte senden
}
}
}
// Inhalte per Funk übertragen
void transmit()
{
long message[8] = {int(motorrpm), int(servowinkel), (pong)};
delay(1);
radio.stopListening();
radio.write(&message, sizeof(message));
radio.startListening();
}
Somit hab ich erzielt, dass der Sender sendet, dann wartet er auf rückantwort vom Empfänger, und erst dann darf er wieder Senden, wenn er keine rückantwort bekommt, aber gesendet hat, sendet er erneut, bis antwort rein kommt.
Sieht ein wenig kompliziert aus.. Funktioniert aber (noch).
Meinung dazu?