Zwei Arduino´s drahtlos verbinden ??

[PICture]

Hallo!

Mein praktischer Tipp wäre für Experimente als Funkverbindung eine Leitung mit bidirektionaler serieller Datenübertragung zu verwenden. Das kann man später durch zwei Transceiver ersetzen und müsste genauso funktionieren.

[Benny1989]

okay, danke ihr beide für Eure Antworten.

Also das mit dem Verbinden hab ich geschnallt. also was MOSI, MISO, SCK und CS/SS angeht. Praktisch wie Robin erwähnt hat, alle 4 Lins verbinden mit dem nrf24L01+ ! Richtig ??

So aber was ich jetzt noch nicht geschnallt habe ist, wie das in meinem Sketch aussieht ???
Im Sketch steht ja z.B.: pinMode(servo_pin_1, OUTPUT);

wie sage ich jetzt dem Ardiono Nano, das er das über das nrf24L01+ an den Ardiono UNO an Pin 3 schicken soll ( int servo_pin_1 = 3; )
Das leuchtet mir jetzt noch nicht so ein ?

Mfg Benny

[robin]

Ganz so trivial wie ein einfaches Servo = 3 wird es mit einer Funkverbindung nicht.

Hier mal die Arduino Library mit Erklärung, was wo angeschlossen wird:
http://playground.arduino.cc/Interfa...1#.UyGf4vl5PxU

(Ich hab nicht mit der library gearbeitet, also muss nicht alles 1zu1 reproduzierbar sein)

Für eine Ansteuerung der Servos muss zu allererst eine Funkverbindung zwischen den beiden Modulen aufgebaut werden.
Hierzu muss der nrf24 initialisiert werden, sprich die gleiche Frequenz eingestellt, Adressen vergeben, Datenlänge eingestellt, ... werden.

An den Pins für den NRF24 müsstest du erst einmal nichts ändern, die werden mit dem Aufrufen er init-Funktion in der Nrf-Library eingestellt.

Als nächstes sollten beide Funkmodule als Empfänger konfiguriert werden.

Bis hier hin sollte alles recht gut von der Library abgedeckt werden.

Kommt es jetzt zum Senden von Daten, muss das entsprechende Funkmodul auf Senden umgestellt werden. Und dann können auf einen Rutsch bis zu 32 Byte an Nutzdaten übertragen werden.
Diese 32 Byte kannst du frei nutzen und ein entsprechendes Protokoll aufbauen mit dem die Teilnehmer Kommunizieren.

Also zB. 1 Byte gibt an, ob es Messwerte ("M") oder ein Befehl ("B") ist, der gerade gesendet wurde.
Im 2. Byte dann von welchen Sensor (ID) der Messwert kommt, bzw. welcher Servo (ID) angesprochen werden soll
In den darauf folgenden Bytes dann die entsprechenden Messwerte.

Du könntest auch ein "SERVO1 = 3" als String senden, das ist aber eher kontraproduktiv, weil man zu viel filtern muss bis man weiß, dass es um Servo1 geht.

Es sind auch nur bis zu 32 Byte, du kannst davon also auch nur 4 nutzen.

Wie gesagt, das ist nur ein Beispiel, wie so was aussehen kann.
Hier solltest du dir aber möglichst selber was überlegen, dass am besten zu deiner Aufgabe passt und am auch erweiterbar ist, dein Projekt soll ja wachsen.

[Benny1989]

okay danke für deine Erklärung, klingt logisch aber auch für ein Neuling etwas Bahnhof weil ich bis jetzt nur normale einfache Porgamme realisiert habe.

Nach etwas einlesen denke ich werd ich es dann mal probieren mein Programm umzuschreiben, da wird bestimmt die ein oder andere Frage noch auftauchen,
genauso kann ich ja bestimmt mal den Sketch dann hier Posten das du Robin evtll mal drüber schaust, das währ lieb, weil wie gesagt noch ist es für mich etwas schwierig,
aber ich geb mein bestes =)

Werde heute dann an der Fernsteuerung weiter arbeiten, und kann ja heute Abend mal Bilder Posten, und könnt gerne Pro oder Contra geben =)
Gebe mir größte mühe =)

Mfg Benny

[robin]

klar kann ich drüber schauen.

Wenn du noch ein blutiger Anfänger bist, würde ich es aber langsam angehen lassen. Bau dir als erstes das Protokoll und teste es ohne Funkverbindung, sondern mit einem Kabel wie PICture er geschrieben hat.

Die Daten tauscht du dann über die UART Schnittstelle aus (heißt beim Arduino glaub Serial). Am besten im Datenblatt, Internet einlesen, was das ist. Dann musst du zwar erstmal deinem Roboter hinterher laufen, aber es ist bedeutend einfacher zu realisieren als eine Funkverbindung.

Dabei solltest du auch erst mal das ganze mit der Kommunikation und Interaktion zwischen den beiden Mikrocontrollern lernen (zumindest die basics). Falls hier Probleme auftreten, sollten die sich leichter beheben lassen als mit einer Funkverbindung dazwischen.

Wenn das dann soweit klappt, würde ich erst die Funkverbindung angehen. Kabel haben den Vorteil, dass du sie siehst, du kannst die Signale recht einfach messen und auch "verfolgen". Beim Funk hast du mit den Sender/Empfänger einfach noch mehr Fehlermöglichkeiten dazwischen.

[Benny1989]

naja blutig nicht mehr ganz, also die Schaltungen wo ich möchte bekomme ich hin. =)

ja genau das mit dem erstmal ohne Funk, hab ich im ersten Beitrag oben versucht zu erklären =)
das Programm steht, die Schaltung auch, und funktunieren tut es auch, nur will ich meinem Roboter ja nicht weiter hinterher laufen.

Also es funktioniert so wie ich es will, nur jetzt brauch ich halt eine Funkverbindung, ja werde es langsam angehen lassen, das ich es auch verstehe.

Hier mal der Funktionierende Code ....

#include <Servo.h>


Servo servo_gas_bremse_1;        // Servo Aufgabe Gas & Bremse
Servo servo_links_rechts_2;      // Servo Aufgabe Links & Rechts
 
int potpin_links = A1;           // Analog Pin für Poti - Gas & Bremse
int servo_pin_1 = 3;             // Servo Pin

int potpin_rechts = A2;          // Analog Pin für Poti - Links & Rechts
int servo_pin_2 = 5;             // Servo Pin

int val;                         // Variable zum Lesen des Wertes des Analog Pin´s 
 
void setup() 
{ 
  servo_gas_bremse_1.attach(servo_pin_1 = 3);         // Servo auf Pin 3 setzen 
  pinMode(servo_pin_1, OUTPUT);                       // Servo_Pin als Ausgang deklarieren
  
  servo_links_rechts_2.attach(servo_pin_2 = 5);       // Servo auf Pin 5 setzen
  pinMode(servo_pin_2, OUTPUT);                       // Servo_Pin als Ausgang deklarieren
} 
 
void loop() 
{ 
  val = analogRead(potpin_links);      // liest den Wert des Poti´s zwischen 0 und 1023
  val = map(val, 0, 1023, 0, 180);     // skalieren das der Servo weis, wo 0 und 180 ist 
  servo_gas_bremse_1.write(val);       // Servo auf den Skalierten Wert setzen 
  delay(15);                           // 15 mS warten dann wieder abfragen
  
  val = analogRead(potpin_rechts);     // liest den Wert des Poti´s zwischen 0 und 1023
  val = map(val, 0, 1023, 0, 179);     // skalieren das der Servo weis, wo 0 und 180 ist 
  servo_links_rechts_2.write(val);     // Servo auf den Skalierten Wert setzen 
  delay(15);                           // 15 mS warten dann wieder abfragen
}

Mfg Benny

[robin]

Schon klar, dass du zZ. auch schon hinterher rennst, aber mit dem Funk kommt ja auch noch ein zweiter Mikrocontroller (der auch Fehler verursachen kann). Also erst mal mit beiden Mikrocontrollern und Kabel testen und dann auf Funk umbauen.

Du hast da einen Anfängerfehler in deinem Code

void loop() {   
val = analogRead(potpin_links);      // liest den Wert des Poti´s zwischen 0 und 1023  
val = map(val, 0, 1023, 0, 180);     // skalieren das der Servo weis, wo 0 und 180 ist   
servo_gas_bremse_1.write(val);     // Servo auf den Skalierten Wert setzen   
delay(15);                                    // 15 mS warten dann wieder abfragen    

val = analogRead(potpin_rechts);   // liest den Wert des Poti´s zwischen 0 und 1023  
val = map(val, 0, 1023, 0, 179);     // skalieren das der Servo weis, wo 0 und 180 ist   
servo_links_rechts_2.write(val);     // Servo auf den Skalierten Wert setzen   
delay(15);                                    // 15 mS warten dann wieder abfragen
}

Das Programm wird nach einander abgearbeitet. Also von oben bis unten und erst dann fängt es wieder oben an.
Sprich durch die beiden delays sendest du das Servosignal erst all 30ms(+ 2ms für ein Servo.write + ein bisschen was für den rest des Programms) und nicht wie du es dir vermutlich denkst alle 15ms.

Also entweder nur einmal den delay oder eben bei beiden die halbe Zeit.
Was du auch bedenken solltest, bei dem verwenden der delay Funktion kann der Controller während der gesamten Zeit nichts machen. Hier solltest du dich bei Zeiten mal in das Thema Timer einlesen.
Dann kannst du die Servos über einen Interrupt quasi parallel zu einem Programm ansteuern.