Arduino + XBee RX & TX Ausgänge schalten

[Jürgen S. (schmiddii)]

Hallo,
ich stehe wieder vor einer kleinen Herausforderung bei der ich gerne 
Eure Hilfe anfordern würde.

Ich habe 2 XBees und 2 Arduino Uno Boards.

Die Xbees sind an die Arduinos angeschlossen, diese widerrum über USB am 
PC.

Nun möchte ich ein kleines Programm schreiben , bei dem ich erstmal die 
TX und RX Ausgänge auf dem Board schalte, damit der XBee diese sendet.

Auf der Empfängerseite möchte ich ,dass der XBee über das Arduino LED's 
schaltet (je nach Signalpegel High oder Low)

Ich bin absoluter Neuling in C , hab früher aber recht viel mit HTML & 
auch etwas PHP gemacht, ich verstehe schon etwas, aber noch nicht alles.

Mein Programm funktioniert leider noch nicht so wie es sollte :

int txPin = 1;
int rxPin = 0;

void setup()
{
      Serial.begin(9600);
      pinMode(txPin, OUTPUT);      // Set Port as Output Port
      pinMode(rxPin, OUTPUT);      // Port als Output setzen
}

void loop()
{
  Serial.write('H');
  digitalWrite(txPin,HIGH);
  digitalWrite(rxPin,LOW);
  delay(1000);
  Serial.write('L');
  digitalWrite(txPin,LOW);
  digitalWrite(rxPin,HIGH);
  delay(1000);
}

Grüße

[EGS (Gast)]

Ähem, hust...

Die RX/TX kannst du entweder nur für serielle Kommunikation benutzen 
oder als I/O. Wenn du die als Seriellen Port benutzt, wechseln aufgrund 
des Taktes und der Signale die Pegel ständig. Benutze lieber 2 andere 
Pins und die sogenannte NewSoftSerial libary. Damit kannst du die Pins 
für die Kommunikation auch durch Software variieren.

Ansonsten ist dein Setupteil schon falsch...wegen der doppelten 
Belegung.

[Jürgen S. (schmiddii)]

Ich glaub ich muss echt ganz von vorne anfangen.
XBee's sind mit X-CTU konfiguriert und "verstehen" sich.

Grundgedanke:

Ich möchte über Funk Daten übertragen mit denen dann zb. beim Empfänger 
LED's geschalten werden.

[EGS (Gast)]

Leg dir ne Variable an, die die Zustände codiert speichert (binäre, hex 
oder dezimal) und übertrage diese über die serielle Schnittstelle an die 
xbee. Die Daten erfasst du über die einigermaßen reichlichen I/Os des 
arduinos.

Auf der Gegenseite wertest du seien codierten Daten aus und agierst 
entsprechen (LED an).

Mit den xbees kann ich mich aber nicht so aus.

PS: die integer-Werte lassen sich bei den arduinos besser handhaben. 
Date Format kann man ja anpassen.

[Markus U. (markjus)]

Du hast im Grunde - mit dem UNO - zwei Möglichkeiten.

Entweder Du nutzt die Hardware Serial-Ports (D0 und D1 am Arduino). Dann 
musst Du bei jedem Programmieren die Verbindung zu den XBees 
unterbrechen, da der Upload des Codes sonst nicht funktioniert.

Auf die Dauer einfacher ist es, die SoftwareSerial-Bibliothek zu 
benutzen (unter Datei -> Beispiele-> SoftwareSerial sind 
Code-Beispiele). Da kann alles verbunden bleiben - auch beim 
Programm-Upload.

Ansonsten ist die Programmierung genauso, als ob Du auf den seriellen 
Monitor ausgeben willst. Die eine Seite schreibt (z.B. der Coordinator 
an dem einen UNO) mit Serial.print() oder Serial.write(), die andere 
(z.B. Router am zweiten Arduino Uno) empfängt (mit Serial.available() 
und Serial.read() abfragen).

Pseudo Code:

Coordinator an UNO1

Setup
  Serielle Schnittstelle starten

Loop
  char schreiben


Router an UNO2

Setup
   Serielle Schnittstelle starten

Loop
   Daten auf der seriellen Schnittstelle?
      Daten von der seriellen Schnittstelle einlesen
        wenn HIGH dann LED an
        wenn LOW dann LED aus

Das kannst Du in C machen, aber der Arduino-Layer ist wahrscheinlich am 
Anfang einfacher. Gerade wenn es dann irgendwann um Strings geht (-> 
Pointer).

[Jürgen S. (schmiddii)]

Vielen Dank schonmal für Eure Hilfe :)
Ihr bringt mich wirklich immer weiter.

Ich habe jetzt mal etwas kleines probiert, aber leider funktioniert das 
noch nicht :/

EMPFÄNGER:

#include <SoftwareSerial.h>
//
int inByte = 0;         // incoming serial byte
int led = 13;           // Die LED auf dem Arduino Board

void setup()
{
  Serial.begin(9600); // 9600 Baud für den fest eingebauten seriellen Port
}
void loop()
{
  if (Serial.available() > 0) {
    // get incoming byte:
    inByte = Serial.read();
    if (inByte == 'H') {
    digitalWrite(led, HIGH);
    }else if (inByte == 'L') {
    digitalWrite(led, LOW);
    }
   }else{ 
   Serial.print('E');
  delay(2000);
  Serial.print('F');
  delay(2000);            
  }
}

SENDER:

#include <SoftwareSerial.h>
int inByte = 0;         // incoming serial byte
int led = 13;
void setup()
{
  // start serial port at 9600 bps:
  Serial.begin(9600);
  }

void loop()
{
  if (Serial.available() > 0) {
    // get incoming byte:
    inByte = Serial.read();
    if (inByte == 'E') {
    digitalWrite(led, HIGH);
    }else if (inByte == 'F') {
    digitalWrite(led, LOW);
    }
   }else{ 
   Serial.print('H');
  delay(1000);
  Serial.print('L');
  delay(1000);            
  }
}

Ich muss hinzufügen, dass ich mir natürlich Programmteile aus dem 
Internet herausgesucht habe.

[Markus U. (markjus)]

Da stimmt ja auch einiges nicht.

Ehrlich gesagt glaube ich, Du solltest erstmal mit ganz einfachen Sachen 
(blink-Sketch etc.) anfangen, da Du die Sprache/ den Aufbau 
möglicherweise noch nicht richtig verstehst - zumindest sieht es nach 
den vorliegenden Sketchen sehr danach aus.

Nur als einfaches Beispiel:

Wenn Du einen digitalen Port (LED) mit digitalWrite() ansprechen willst, 
musst Du ihn auch im Setup als Ausgang "pinMode(led, OUTPUT)" so 
initialisieren. Per default sind die Ports nämlich als Inputs gesetzt.
Du includierst zwar SoftwareSerial, aber benutzt es nicht. Hast Du 
vorher schonmal libraries benutzt?
Du lässt beide Arduinos senden und empfangen - soll das so sein?

Und Du hast Dich nicht an den Pseudo Code gehalten ;)

[Jürgen S. (schmiddii)]

Das siehst du richtig, ich steig noch nicht ganz bei dem Aufbau durch, 
werde mich aber natürlich gleich nochmal ransetzen & mich an deinen 
PseudoCode halten.

[Markus U. (markjus)]

Datentypen bitte auch nochmal nachlesen, insbesondere int/ byte.
Welcher Datentyp kommt auf der seriellen Schnittstelle an?

[Jürgen S. (schmiddii)]

Ich verstehe leider nicht ganz was du damit meinst, sorry !

[Jürgen S. (schmiddii)]

Ich hab mal ein ganz simples Senderprogramm, laut Oszi passt das auch 
so.
Jetzt muss ich mich nur noch um das Empfängerprogramm kümmern.

Kann ich irgendwie feststellen, dass die XBees senden ?

Sender :

void setup()
{
  // start serial port at 9600 bps:
  Serial.begin(9600);
  }

void loop()
{
  Serial.write(170);   // 1 byte mit dem binären Code '10101010' senden
  delay(1000);
}

Empfänger :

// Portnamen & Variablennamen zuordnen
int inbyte = 0; // eingehendes Serielles Byte
int led = 13;   // LED die später blinken soll.

// Setup starten
void setup()
{
  Serial.begin(9600);   // Serielle Schnittstelle mit 9600bps starten
  pinMode(led, OUTPUT); // LED Pin auf Ausgang setzen
}

// LOOP

void loop()
{
  if (Serial.available() > 0) {
    // Wenn Ja, dann lese es aus
    inbyte = Serial.read();
    if (inbyte == '1')
    {
      digitalWrite(led, HIGH);
      Serial.println("Die LED ist eingeschalten");
    }
    if (inbyte == '0')
    {
      digitalWrite(led, LOW);
      Serial.println("Die LED ist ausgeschalten");
    }
  }
}

[Markus U. (markjus)]

Ja auf mehrere Arten.
Z.B. relativ einfach mit einem Widerstand und LED am RSSI Pin (Pin 6) an 
den XBees und/ oder am Aossciate Pin (Pin 15). Näheres im XBee 
Datenblatt.
Man kann auch beide XBees mit X-CTU und Explorer-Board o.ä. testen und 
im Terminal Mode gegenseitig Daten senden. Damit geht man sicher, dass 
die beiden korrekt aufeinander eingestellt sind.

[Jürgen S. (schmiddii)]

Mit dem X-CTU habe ich die beiden ja konfiguriert & laut CTU kommt auch 
das eine beim anderen an, ich habs einfach mal durch den Range Test 
getestet.

Also ich denke die Konfiguration der XBee's passt.

Jetzt muss ich nur noch das "Programm" zum laufen bekommen, damit ich 
endlich mal ein klein wenig dahinterkomme wie die Sache läuft , damit 
ich später mehrere Daten senden kann.

[Jürgen S. (schmiddii)]

Ich komm einfach nicht weiter, ich schaffe es nicht ,dass der Empfänger 
das bekommt bzw. empfängt was der Sender sendet.
In X-CTU funktioniert alles einwandfrei.

Sobald ich etwas über das Programm C senden möchte funktioniert es 
nicht.


Empfänger :

int incomingByte = 0;   // for incoming serial data

void setup() {
        Serial.begin(9600);     // opens serial port, sets data rate to 9600 bps
}

void loop() {

        // send data only when you receive data:
        if (Serial.available() > 0) {
                // read the incoming byte:
                incomingByte = Serial.read();

                // say what you got:
                Serial.print("Ich empfange: ");
                Serial.println(incomingByte, DEC);
        }
}

Sender :

void setup()
{
  // start serial port at 9600 bps:
  Serial.begin(9600);
  }

void loop()
{
  Serial.println('A');   // Dezimal "A" senden
  delay(1000);
  Serial.println('B');   // Dezimal "B" senden
  delay(1000);
}

[Markus U. (markjus)]

Wie sind XBees und ATMEGAs denn verschaltet?

[Jürgen S. (schmiddii)]

Sind beide auf einem Arduino UNO Board.

Jeweils TX, RX , 3,3V & GND angeschlossen.

[Markus U. (markjus)]

Ich meinte damit einen Schaltplan - ich habe meine Kristallkugel grad 
nicht zur Hand ;)
Ich vermute nämlich mal, dass z.B. TX und RX nicht richtig verschaltet 
sind.

[Jürgen S. (schmiddii)]

Sender :

3,3V Arduino UNO -> PIN 1  XBee
GND Arduino UNO  -> PIN 10 Xbee
TX Arduino UNO   -> PIN 2  Xbee (D-OUT)
RX Arduino UNO   -> PIN 3  Xbee (D-IN)


Empfänger :

3,3V Arduino UNO -> PIN 1  XBee
GND Arduino UNO  -> PIN 10 Xbee
TX Arduino UNO   -> PIN 2  Xbee (D-OUT)
RX Arduino UNO   -> PIN 3  Xbee (D-IN)

[Markus U. (markjus)]

RX & TX tauschen.

[Jürgen S. (schmiddii)]

Bei beiden ?

[Jürgen S. (schmiddii)]

Also tauschen bringt nichts, da geht gar nichts mehr (teste mit Range 
Test X-CTU).

Über X-CTU geht das Senden und Empfangen auch einwandfrei, nur über ein 
Programm , quasi vom Mikrocontroller gesteuert will einfach nichts 
senden.

[X. A. (wilhem)]

Jürgen S. schrieb:
> Sender :
>
> 3,3V Arduino UNO -> PIN 1  XBee
> GND Arduino UNO  -> PIN 10 Xbee
> TX Arduino UNO   -> PIN 2  Xbee (D-OUT)
> RX Arduino UNO   -> PIN 3  Xbee (D-IN)

Ich stehe genau vor dem gleichen Problem.
Für einen Datenlogger habe ich 1 arduino und 2 Xbee Module. Ein Modul 
ist mit Arduino gekoppelt und als Datenlogger in einem RC Flugmodell 
eingebaut. Das andere Modul ist durch eine Xbee Explorer Platine direkt 
mit dem Rechner angeschlossen.
Gewünscht ist die Übertragung der von Arduino aufgenommenen Daten zu dem 
Rechner über die 2 Module XBee.

Dabei hätte ich aber eine Frage: angenommen dass die beiden Module 
richtig konfiguriert sind, kann ich die serielle Schnittstelle von 
Arduino mit der des XBee-Moduls verbinden (genau wie in der obige 
tabellarischen Übersicht)? Oder entstehen "Interferenzen" zwischen der 
seriellen Kommunikation von Ardu und der vom XBee?!??!

Problematisch ist dass der Arduino Daten aus den Sensoren an wohl 
definirten Abtastintervallen durch seine TX/RX einlesen sollte. Daher 
sollte er in seinem Programm zwei Operationen durchführen:
1- Über TX/RX Daten aus den Sensoren einlesen;
2- Über RX/TX die Verbindung mit dem XBee Modul herstellen und die 
aufgenommenen Daten zum Rechner übertragen;

Wie funktioniert es in der Praxis?

Grüß

PS: Jürgen hast Du das Problem mittlerweile gelöst?