Kommunikation

Jeder Arduino hat min. 1 serieller Port. Der ist an dem USB Port angeschlossen. (zumindest bei den „normalen“ Arduinos, den Leonardo hat ich noch nicht unter meinem Lötkolben) Angesprochen wird dieser Port mit dem Befehl Serial. Übrigens ist diese Schnittstelle auch die Nabelschnur, die zum PC führt. Arduino hat ein kleines Terminalprogramm eingebaut. Sehr praktisch zum Debuggen, denn so kann man ohne viele Leitungen zu löten und zu verdrahten direkt mit dem Arduino komunizieren. Zu finden ist das Fenster unter Tools/Serieller Monitor. (Oder auch Umschalt+STRG+m) Die serielle Schnittstelle ist eine Schnittstelle die Byteorienttiert ist. Und Sie belegt 2 Pins. Beim Duemilanove sind das die Pins 0 und 1.

Na, zunächst müssen wir die Scnittstelle initialisieren. Das macht man natürlich im setup() Teil:

  Serial.begin(x);

x ist die sog. Baudrate, also die Bit's pro Sekunde. Die muss natürlich mit der Rate im Monitor übereinstimmen. Startet man den Monitor wird übrigens automatisch ein Reset im Arduino ausgelöst. Mögliche Baudraten sind:

300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, oder 115200

Je größer, umso schneller geht die Kommunikation, leider wird auch die Kommunikation unsicherer. Bei den hohen Baudraten kann es dann schon mal zu Müll auf der Schnittstelle kommen.

Serial ist ein sog. Objekt. d.h. An dem Objekt selber gibt es Methoden (Funktionen und Prozeduren) mit der man die entsprechenden Sachen macht. Folgende Methoden sind möglich:

if (Serial)

Serial wird hier als Bedingung in einer If-Verzweigung benutzt. Die Bedingung ist WAHR, wenn die Serielle Schnittstelle zur Verfügung steht, beim Arduino wenn der USB Stecker mit dem Rechner verbunden ist.

available()

sagt einem, wieviele Bytes zum Lesen vorliegen.

begin(Bautrate)

startet die Kommunikation mit der angegebenen Baudrate.

end()

Beendet die Kommunikation. Die beiden Anschlüsse können jetzt wieder als normale Pins verwendet werden.

flush()

wartet bis alle Daten, die sich noch im Puffer befinden, übertragen worden sind.

parseFloat()

Liest und parset eine Float-Variable aus dem Stream.

parseInt()

Liest und parset die nächste Int-Variable aus dem Stream.

peek()

Schaut schon mal auf das nächste Byte, wenn nix vorhanden ist, gibt's 'ne -1

print(x)

Gibt den Wert X auf der Schnittstelle aus. X kann ein beliebiger Datentyp sein. Print macht daraus eine Textrepresentation daraus. Man kann auch einen 2. Parameter verwenden. Dieser kann folgende Werte haben:

BIN: Gibt die Binäre Representation aus, aus 45 wird dann „00101101“
OCT: Das ganze als Oktalzahl, aus 45 wird dann „55“
DEC: ergibt dann „45“
HEX: ergibt dann „2D“

Bei Flieskommavariablen kann man mit dem 2. Parameter die Anzahl der Nackkommastellen bestimmen.

print(1.23456, 0) gibt „1“
print(1.23456, 2) gibt „1.23“
print(1.23456, 4) gibt „1.2345“

Man beachte hier die Amerikanische Schreibweise. Nicht Komma ist dsa Komma sondern der Punkt.

println()

Das gleiche wie print allerdings wird die Zeichenkette mit einem Zeilenende und Zeilenvorschubzeichen abgesclossen. Also Zeichen 13 und 10. (0x0D 0x0A, oder auch \r\n)

read()

ließt ein Zeichen von der Schnittstelle. Ist nix da gibt's eine -1.

readBytes(Puffer,Anzahl)

Ließt Anzahl der Bytes aus dem Stream und speichert diese in den Puffer. Das ganze dauert maximal so lange wie mit setTimeout angegeben worden ist oder bis die Anzahl erreicht ist. Zurückgegeben werden die Anzahl der kopierten Zeichen.

setTimeout()

Setzt eine Zeitschranke für die Schnittstelle.

write(x)

Schreibt einzelne Bytes auf die Schnittstelle. z.B. ist x ein Byte oder Char dann wird ein byte geschrieben. Ist x vom Typ word oder int werden 2 Bytes geschrieben, ist x ein Feld muss man mit einem 2. Parameter angeben, wieviele Elemente geschrieben werden sollen.

Es gibt noch ein paar Befehle mehr, aber die sollen uns erst mal reichen. Die serielle Schnittstelle kann man über gut für's Finden von Problemen (debuggen) gebrauchen. Aber dazu demnächst mehr.

Jetzt könnt ihr mal ausprobieren, „Hello World“ auf die Schnittstelle zu schreiben.

Oder ihr probiert mal das hier aus. Das Programm gibt einfach den Wert des analogen Eingang 0 in 5 verschiedenen Formaten auf die Schnittstelle:

/*
  Analog input

 reads an analog input on analog in 0, prints the value out.

 created 24 March 2006
 by Tom Igoe
 */

int analogValue = 0;    // variable to hold the analog value

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

void loop() {
  // read the analog input on pin 0:
  analogValue = analogRead(0);

  // print it out in many formats:
  Serial.println(analogValue);       // print as an ASCII-encoded decimal
  Serial.println(analogValue, DEC);  // print as an ASCII-encoded decimal
  Serial.println(analogValue, HEX);  // print as an ASCII-encoded hexadecimal
  Serial.println(analogValue, OCT);  // print as an ASCII-encoded octal
  Serial.println(analogValue, BIN);  // print as an ASCII-encoded binary

  // delay 10 milliseconds before the next reading:
  delay(10);
}