Loe raamatut: «Android mit Arduino™ Due», lehekülg 2

Manuel di Cerbo, Andreas Rudolf

Font:

2.3 Änderungen am Blink-Sketch

Bis jetzt haben wir noch gar nichts selbst programmiert. Nun werden wir das Blink-Programm etwas abändern und schauen, ob sich das Verhalten ändert. Dazu vergrößern wir die beiden Zeitintervalle auf jeweils 3 Sekunden. Danach laden wir den Sketch erneut auf das Arduino Due. Die loop()-Funktion sollte also folgendermaßen aussehen:

void loop() {
digitalWrite(led, HIGH);
delay(3000); // wait for three seconds
digitalWrite(led, LOW);
delay(3000); // wait for three seconds
}

Nachdem der Mikrocontroller neu beschrieben wurde, blinkt die LED nun deutlich langsamer als zuvor.

2.4 Die Arduino-Programmiersprache

Arduino besitzt eigentlich keine eigene Programmiersprache. Vielmehr versteht man unter der Arduino-Programmiersprache ein Framework, das eine Sammlung von Funktionen und Bibliotheken zur Verfügung stellt. Die Programmierung erfolgt in C und/oder C++, wobei die Arduino-spezifischen Funktionen verwendet werden können. Eine Übersicht der Arduino-Programmiersprache findet man auf der offiziellen Arduino-Webseite unter dem Reiter Reference (http://arduino.cc/en/Reference/HomePage). Erwähnenswert ist insbesondere auch, dass es sich um eine »Cross-Plattform«-Programmiersprache handelt. Ein Programm, welches für ein spezifisches Board mit dazugehörigem Mikrocontroller geschrieben wurde, kann also grundsätzlich auch für einen anderen Mikrocontroller verwendet werden. Der Source-Code muss dabei nicht verändert werden.

Nachdem wir nun unseren ersten Sketch, das Blink-Beispiel aus Abschnitt 2.2, auf den Arduino Due geladen haben, wollen wir dessen Source-Code studieren.

Bei den ersten Zeilen handelt es sich um Kommentarzeilen. Wie in C/C++ üblich, sind mehrzeilige Kommentare durch die Zeichen /* (zu Beginn) bzw. */ (am Ende) und einzeilige Kommentare durch // gekennzeichnet. Im Kommentar der ersten Zeilen wird die Funktion des Programms kurz erläutert.

Die erste für das Programm entscheidende Zeile

int led = 13;

wird verwendet, um den Mikrocontroller-Pin mit der On-board-LED zu definieren. Die LED ist in unserem Fall verbunden mit dem Arduino-Pin Nummer 13. Diese Information entnehmen wir zum Beispiel der Produktwebseite (http://arduino.cc/en/Main/ArduinoBoardDue). Dort finden wir unter Input und Output die folgende Beschreibung:

»L« LED: 13
There is a built-in LED connected to digital pin 13. When the pin is HIGH, the LED is on, when the pin is LOW, it's off. It is also possible to dim the LED because the digital pin 13 is also a PWM output.

Hinweis
Bitte beachten Sie: Als Arduino-Pin Nummer 13 wird derjenige Mikrocontroller-Pin bezeichnet, welcher oben auf dem Board mit der Nummer 13 angeschrieben ist. Es handelt sich nicht etwa um den 13ten Pin des SAM3X-Mikrocontrollers. Die Zuordnung zwischen Arduino und SAM3X-Pins findet man ebenfalls auf der Produktwebseite (http://arduino.cc/en/Hacking/PinMappingSAM3X). Aus der Tabelle entnehmen wir, dass der Arduino-Due-Pin 13 dem SAM3X-Pin PB27 entspricht. Im Datenblatt des SAM3X steht außerdem, dass sich der Pin PB27 am physikalischen Mikrocontroller-Pin mit Nummer 68 befindet. Mit dieser Begebenheit müssen wir uns nicht weiter beschäftigen. Es sollte bloß im Hinterkopf behalten werden, dass es Unterschiede bei der Nummerierung von Arduino-Pins und physikalischen Mikrocontroller-Pins gibt. Insbesondere wenn bereits bestehender C-Code mit Arduino-Source-Code vermischt wird (oder umgekehrt), kann dies eine Stolperfalle darstellen.

Als Nächstes betrachten wir die Funktionen setup() und loop(). Wie die Namen schon vermuten lassen, werden alle Anweisungen innerhalb von loop() in einer Endlos-Schleife ausgeführt. Der Inhalt von setup() hingegen wird nur ein einziges Mal ausgeführt, und zwar ganz zu Beginn des Programmablaufs, noch bevor loop() das erste Mal ausgeführt wird. Bei den Funktionen setup() und loop() handelt es sich um eine Besonderheit von Arduino. Falls Sie schon Erfahrungen mit C-Programmierung haben, fragen Sie sich bestimmt, wo die main()-Funktion geblieben ist. Da Arduino unter der Haube auch nur C/C++ verwendet, gibt es intern natürlich auch eine main()-Funktion. Darin werden dann unsere Methoden setup() und loop() an den entsprechenden Stellen aufgerufen, gemäß folgendem Muster:

int main(void){
…
setup();
// loop forever
for(;;){
loop();
}
return 0; // never reached
}

Die genaue Implementierung der main()-Funktion für den Arduino Due finden Sie übrigens im Arduino-Ordner unter ./hardware/arduino/sam/cores/arduino/main.cpphttp://arduino.cc/en/Reference/HomePage.

Falls Sie noch keine Erfahrungen mit C/C++ haben, merken Sie sich einfach, dass die Funktion setup() nur ein einziges Mal zu Programmbeginn ausgeführt wird. Die Funktion loop() hingegen wird endlos und periodisch aufgerufen. Die Funktionen setup() und loop() sind auch in der offiziellen Language Reference (http://arduino.cc/en/Reference/HomePage) beschrieben.

Innerhalb von setup() sollten also im Idealfall alle Initialisierungen stattfinden, wie zum Beispiel Pin-Konfigurationen. Die Pins eines Mikrocontrollers können grundsätzlich als Eingänge oder Ausgänge konfiguriert werden. Intern speichert ein Mikrocontroller diese Konfiguration in speziellen Registern ab. Das Ändern einer Pin-Konfiguration erfordert also das Schreiben von Registern, und dies wiederum verbraucht kostbare Rechenzeit. Um ehrlich zu sein, in den meisten Fällen würde man kaum eine Performance-Einbuße feststellen können. Dennoch lohnt es sich, dieses Pattern korrekt anzuwenden.

Im Blink-Sketch wird der LED-Pin (Arduino-Pin Nummer 13) als Ausgang konfiguriert. Dies geschieht mit der Funktion pinMode().

void setup() {
// initialize the digital pin as an output.
pinMode(led, OUTPUT);
}

Bei pinMode() handelt es sich ebenfalls um eine spezifische Arduino-Funktion. Der erste Parameter bestimmt die Arduino-Pin-Nummer (vorher wurde led gleich 13 gesetzt). Der zweite Parameter legt fest, ob es sich um einen Eingang oder einen Ausgang handelt. Anstatt OUTPUT könnte zum Beispiel auch INPUT verwendet werden. Wie bereits erwähnt, ist die Arduino-Programmiersprache eine »Cross-Plattform«-Programmiersprache. Die Funktion pinMode() kann für unterschiedliche Arduino-Boards bzw. Mikrocontroller verwendet werden. Je nach Mikrocontroller braucht es dann natürlich eine andere Implementation der pinMode()-Funktion. Bei Interesse findet man die Implementation für den SAM3X des Arduino Due im Arduino-Ordner unter ./hardware/arduino/sam/cores/arduino/wiring_digital.c

Nun betrachten wir die Anweisungen innerhalb der loop()-Funktion.

Die Funktionen sind grundsätzlich selbsterklärend. Mit digitalWrite() wird ein Ausgang gesetzt (HIGH) oder gelöscht (LOW). Mit delay(1000) wird 1000 Millisekunden, also 1 Sekunde, gewartet.

2.5 Serielle Verbindung: Host-Computer und Arduino

In einem ersten Schritt stellen wir eine serielle Verbindung zwischen unserem Host-Computer und dem Arduino Due her. Unser Host-Computer dient dabei als USB-Host, der Arduino ist das USB-Device. Später können wir dann anstatt unseres Computers ein USB-Host-fähiges Android-Gerät verwenden.

Die serielle Verbindung wird aufgrund ihrer Einfachheit sehr häufig zur Kommunikation mit Mikrocontrollern verwendet. Dazu muss der Mikrocontroller mindestens zwei dedizierte Pins RX und TX zur Verfügung stellen. Der RX-Pin (»Receive«) dient dem Mikrocontroller zum Empfangen von Daten; der TX-Pin (»Transmit«) zum Versenden von Daten. Diese Struktur wird je nach Ausführung auch UART (Universal Asynchronous Receiver Transmitter) oder USART (Universal Synchronous Asynchronous Receiver Transmitter) genannt. Der Mikrocontroller des Arduino Due verfügt sogar über vier serielle Schnittstellen. Sie sind auf der Oberseite jeweils mit TX0/RX0, TX1/RX1, TX2/RX2 und TX3/RX3 beschriftet. Die Anschlüsse CANRX/CANTX ermöglichen übrigens eine Kommunikation über den sogenannten CAN(Controller Area Network)-Bus. Die Anschlüsse SDA und SCL werden ihrerseits für das Two-wire Interface (TWI) beziehungsweise I²C verwendet.

Eine serielle Schnittstelle, oft auch COM-Port genannt, gehörte früher praktisch zur Grundausstattung eines jeden Computers. Der meist verwendete RS-232-Standard benutzt neben den zwei RX- und TX-Pins noch sieben weitere Leitungen. Darunter zum Beispiel RTS (Request to Send) und DSR (Data Set Ready). Diese 9-poligen Stecker sind heutzutage größtenteils verschwunden, stattdessen können aber auch USB-zu-seriell-Adapter mit den entsprechenden Treibern verwendet werden. Für eine serielle Verbindung zwischen unserem Host-Computer und dem Arduino brauchen wir allerdings keinen physikalischen Adapter, sondern lediglich ein USB-Kabel. Der USB-Programming-Port des Arduino Due ist direkt mit einem kleinen Mikrocontroller, dem ATMega16U2, verbunden. Dieser ist seinerseits wieder mit den RX0/TX0-Pins des Haupt-Mikrocontrollers SAM3X verbunden. Auf dem ATMega16U2 läuft also eine USB-zu-seriell-Firmware. Diese wandelt das USB-Protokoll auf der Computer-Seite in serielle Kommunikation auf der Mikrocontroller-Seite um, und umgekehrt.

Bild 2.6: Die schematische Darstellung der USB-Verbindung zwischen Computer und Arduino Due

Bild 2.7: Die USB-Verbindung mit dem USB-serial converter.

Zum Testen der seriellen Verbindung schreiben wir ein kleines Programm, welches die Groß- und Kleinschreibung aller eingehenden Buchstaben umkehrt und die veränderten Symbole wieder an den Computer zurückschickt. Dabei ist zu beachten, dass die Symbole im ASCII-Format codiert sind. Es wird jeweils ein Byte übertragen, welches einen Wert zwischen 0 und 255 haben kann. Der Wert 65 entspricht dabei einem groß geschriebenen »A«. Ein großes »B« hat den Wert 66 und so weiter bis »Z« (90). Die klein geschriebenen Buchstaben starten mit »a« bei 97. Eine vollständige ASCII-Tabelle findet man zum Beispiel unter http://www.asciitable.com im Internet.

Tabelle 2.1: Dezimale ASCII-Werte der Buchstaben von A bis Z

int input;
int output;
void setup()
{
Serial.begin(9600);
}
void loop()
{
if(Serial.available() > 0){
input = Serial.read();
if(64 <= input && input <= 90 ){ // upper case input
output = input + 32;
Serial.write(output);
} else if(97 <= input && input <= 122) { // lower case
// input
output = input – 32;
Serial.write(output);
} else if(input == 32){ // space bar
output = input;
Serial.write(output);
}
else {
Serial.println();
}
}
}

Kompilieren Sie das obige Programm und laden Sie es auf den Arduino. Nun starten wir den Serial Monitor durch Klick auf das Lupen-Symbol oben rechts in der Arduino IDE.

Bild 2.8: Das Lupen-Symbol zum Start des Serial Monitor.

Es öffnet sich ein neues Fenster mit dem Serial Monitor. Beachten Sie, dass die verwendete Baudrate unten rechts auf 9600 eingestellt ist (vgl. Bild 2.9), da wir diese Geschwindigkeit auch im obigen Programm mit Serial.begin(9600) konfiguriert haben. Schreiben Sie nun ein paar Buchstaben und bestätigen Sie mit Enter oder durch Klick auf Send. Als Antwort erhalten Sie dieselben Wörter mit invertierter Groß- und Kleinschreibung.

Bild 2.9: Hello World im Serial Monitor.

Ein Serial Monitor eignet sich übrigens auch sehr gut zum Debuggen von Programmen, indem einfach an den entsprechenden interessanten Stellen Nachrichten herausgeschrieben werden. Neben dem integrierten Serial Monitor gibt es noch eine Menge anderer sogenannter Terminal-Programme. Einige davon bieten nützliche Zusatzfunktionen, wie zum Beispiel die Darstellung der erhaltenen Daten im Dezimal-, Hex- oder Binärformat. Der integrierte Serial Monitor von Arduino versucht die empfangenen Daten immer als ASCII-Symbole darzustellen. Sehr zu empfehlen ist zum Beispiel das frei erhältliche Terminal-Programm HTerm für Windows/Linux (www.der-hammer.info/terminal/). Im folgenden Bild ist die gleiche Ausgabe in HTerm dargestellt. Das kleine »h« am Anfang entspricht dem Hexadezimalwert »0x68« beziehungsweise dem Dezimalwert »104« oder dem Binärwert »01101000«. Beachten Sie bei der Verwendung von externen Terminal-Programmen, dass jeweils nur ein Computer-Programm mit dem virtuellen COM-Port verbunden sein kann. Trennen Sie also die Verbindung im Terminal-Programm, bevor Sie einen neuen Sketch auf den Arduino laden. Als Verbindungsparameter verwenden Sie natürlich die entsprechende Baudrate. Die Konfiguration ist standardmäßig »8 data bits, no parity, one stop bit«, was manchmal auch als 8N1 bezeichnet wird.

Bild 2.10: Ein empfehlenswertes Terminal-Programm für den Arduino: HTerm.

2.6 LED-Intensität steuern über serielle Konsole

Das vorherige Arduino-Programm hat gezeigt, wie man zwischen Arduino Due und einem Host-Computer kommunizieren kann. In einem weiteren Schritt soll nun abhängig von den empfangenen Daten die Helligkeit der On-board-LED eingestellt werden.

Der benötigte Sketch ist erstaunlich einfach.

#define LED 13
void setup()
{
pinMode(LED, OUTPUT);
Serial.begin(9600);
}
void loop(){
char cmd = 0;
if(Serial.available()){
cmd = Serial.read();
analogWrite(LED,cmd);
}
}

Dieser Sketch empfängt einzelne Bytes über die serielle Verbindung und setzt den LED-Pin mit der Funktion analogWrite(). Mit analogWrite() wird an den entsprechenden Pin ein PWM-Signal gesetzt. Unter der Bezeichnung »PWM« verbirgt sich die Pulsweitenmodulation. Bei der Pulsweitenmodulation wird ein Signal für eine gewisse Zeit eingeschaltet und auch für eine gewisse Zeit ausgeschaltet. Dies wiederholt sich periodisch und meistens mehrere hundert Mal pro Sekunde. Die PWM-Frequenz des Arduino ist zum Beispiel 490 Hz. Also wiederholt sich diese Sequenz 490 Mal pro Sekunde und dauert 1/490 Hz = 2,04 ms oder ungefähr 2 Millisekunden. Die Funktion analogWrite() erwartet nebst der Pin-Nummer auch einen »value«-Parameter zwischen 0 und 255. Dieser Parameter legt fest, wie lange das Signal während der 2 Millisekunden eingeschaltet ist. Ein Wert von 0 bedeutet, dass es nie eingeschaltet ist, die LED ist also komplett dunkel. Mit einem Wert von 255 bleibt sie immer eingeschaltet, die LED leuchtet also mit voller Kraft. Ein Wert von 128 bedeutet, dass die LED die Hälfte der Zeit eingeschaltet ist, sie leuchtet also mit halber Kraft. Diese Beziehung ist auch in Bild 2.11 dargestellt. Im Zusammenhang mit PWM-Signalen kommt häufig auch der Begriff Duty-Cycle zum Einsatz. Ein Duty-Cycle von 50 % zum Beispiel bedeutet, dass das PWM-Signal im Mittel 50 % der Zeit eingeschaltet ist. Dies wird mit einem Aufruf von analogWrite(LED, 128) erreicht. Wie bereits erwähnt, hat die PWM-Frequenz des Arduino, welche durch die Funktion analogWrite() erzeugt wird, einen festen Wert von ca. 490 Hz. Um eine LED zu steuern, ist diese Frequenz gut geeignet. Obwohl die LED in Tat und Wahrheit viele Male ein- und ausgeschaltet wird, können wir kein Flackern feststellen. Je nach Anwendung muss die PWM-Frequenz aber angepasst werden. Ein herkömmlicher Servo zum Beispiel erwartet eine Frequenz von 50 Hz, welche mit Hilfe der Arduino Servo Library in einem späteren Beispiel (vgl. Kapitel 8 Servo mit Android ansteuern) erzeugt werden kann.

Bild 2.11: Die Pulsweitenmodulation zur Steuerung der LED-Intensität.

Wenn Werte über die serielle Verbindung von einem Host-Computer gesendet werden, dann sollte beachtet werden, dass die empfangenen Bytes auf dem Arduino »roh« gelesen und als Zahl zwischen 0 und 255 interpretiert werden. Mit dem integrierten Serial Monitor (Tools > Serial Monitor oder CTRL+SHIFT+M) werden alle Daten in ASCII codiert. Ein großes »A« entspricht dabei dem Wert 65, und ein kleines »z« entspricht dem Wert 122. Senden Sie also abwechselnd diese zwei Buchstaben. Es sollte ein Unterschied in der Lichtstärke der On-board-LED erkennbar sein. Achten Sie auch darauf, dass unten rechts No line encoding eingestellt ist. Sonst wird nach jedem Senden noch ein konstantes Sonderzeichen (New Line und/oder Carriage Return) geschickt, und die Intensität der LED würde sich nicht ändern. Etwas komfortabler kann man rohe Byte-Daten mit dem Hammer-Terminal (http://www.der-hammer.info/terminal/) versenden. Dazu wählt man als Type »DEC« und kann nun Zahlen zwischen 0 und 255 eingeben.

Genau dieser Sketch kann später auch zusammen mit einem Android-Gerät verwendet werden, vorausgesetzt das Android-Gerät verfügt über USB-Host-Funktionalität. Damit die Kommunikation auch über Android Accessory Mode funktioniert, wird der Sketch noch etwas erweitert.

2.7 LED-Intensität steuern über serielle Konsole und Android Accessory Mode

Der nachfolgende Sketch wurde erweitert, damit die Lichtintensität auch über den Android USB Accessory Mode eingestellt werden kann.

#include <adk.h>
#include <Scheduler.h>
#define LED 13
#define RCVSIZE 128
char model[] = "HelloWorldModel";
char description[] = "A Hello World Accessory";
char company[] = "Hello Inc";
char versionNumber[] = "1.2";
char serialNumber[] = "1";
char url[] = "http://www.osciprime.com";
USBHost Usb;
ADK adk(&Usb, company, model, description,versionNumber,url,serialNumber);
void setup()
{
cpu_irq_enable();
pinMode(LED, OUTPUT);
Serial.begin(9600);
delay(200);
Scheduler.startLoop(adkLoop);
Scheduler.startLoop(serialLoop);
}
void loop(){
yield();
}
void serialLoop(){
uint8_t cmd = 0;
if(Serial.available()){
cmd = Serial.read();
analogWrite(LED,cmd);
}
yield();
}
void adkLoop()
{
uint8_t buf[RCVSIZE];
uint32_t nbread = 0;
uint8_t cmd = 0;
Usb.Task();
if (adk.isReady()){
adk.read(&nbread, RCVSIZE, buf);
if (nbread > 0){
cmd = buf[0];
analogWrite(LED,cmd);
}
}
yield();
}

Die Definitionen zu Beginn wie model, description, company etc. dienen dazu, das Android Accessory zu beschreiben. Besonders bei diesem Sketch ist, dass zwei Loops gleichzeitig ausgeführt werden. In der setup()-Funktion sieht man, dass zwei Loops gestartet werden mit Scheduler.startLoop(). Die Scheduler Library ist eine Besonderheit des Arduino Due, andere Boards mit AVR-Mikrocontrollern unterstützen diese Funktionalität (noch) nicht. Die beiden Loops laufen quasi unabhängig voneinander. Der serialLoop kümmert sich um die serielle Kommunikation und der adkLoop um den Android Accessory Mode. Es fallen die yield()-Aufrufe auf. Die Funktion yield() gibt die Kontrolle zwischenzeitlich an andere Tasks bzw. Loops ab und sollte im Zusammenhang mit dem Scheduler mehrfach gebraucht werden.

Die Anweisungen innerhalb des adkLoop sind quasi analog zu serialLoop. Ein Beispiel zum Android Accessory Mode findet man übrigens auch unter File > Examples > USBHost > ADKTerminalTest.

Der obige Sketch wird später für die Kommunikation zwischen Android-Gerät und Arduino Due verwendet. Sowohl für Kommunikation via Android-USB-Host als auch via Android Accessory Mode.

3 Android

3.1 Betriebssystem Android

Um alle Bestandteile dieses Buches zu verstehen, macht es Sinn, zuerst einen Überblick über Android zu erhalten. Android ist ein Betriebssystem, das Gebrauch vom Linux-Kernel macht.

Android ist für mobile Systeme ausgelegt. Insbesondere heißt das, es ist für Energieeffizienz und beschränkte Ressourcen (niedrige CPU-Taktfrequenz, niedrige Speicherkapazität, kleines RAM etc.) konzipiert worden. Da Android für den mobilen Einsatz gedacht ist, wurde auch an das Verwalten von Batterie, Wi-Fi, Bluetooth, Kamera etc. schon von Anfang an gedacht, speziell auch daran, dass gewisse Teile, wie Grafik- und Kamera-Treiber, »Closed Source« vom Hardware-Hersteller (OEM) geliefert werden.

Dies bringt uns wieder auf einen sehr spannenden Punkt:Android ist Open Source!

Open Source heißt, der Source-Code von Android kann von jedem inspiziert und modifiziert werden. Die Weiterentwicklung des Systems findet allerdings zum größten Teil bei Google intern statt, dabei werden »Major Releases« (größere Versionen) von Android dann wieder für die Öffentlichkeit freigegeben.

Um eine bessere Übersicht über das System zu bekommen, studieren wir Bild 3.1. In dieser Illustration sehen wir, aus welchen Schichten das Betriebssystem zusammengesetzt ist. Architektonisch bietet Android nämlich so einige Einzigartigkeiten und unterscheidet sich stark von seinen »nächsten« Verwandten (Embedded Linux, iOS, Windows Mobile). Das Modell veranschaulicht hardwarenahe Teile des Systems (im unteren Bereich des Modells) und eher hardwareferne Elemente (oben).