Arduino für die Cloud: Arduino Yún & Dragino Yún Shield
Author: Claus Kühnel
Date: 2014-11-03T00:00:00+00:00
Keywords: Fachbücher; Computer & Internet
Description: Die Komplexität heutiger Anforderungen an elektronische Geräte ist an vielen Stellen mit den klassischen Konzepten um Mikrocontroller kaum umsetzbar. In vielen Fällen kann heute auf eine Vernetzung nicht mehr verzichtet werden. Das Internet der Dinge bliebe ohne diese Voraussetzung Wunschdenken. Arduino Yún kombiniert nun den klassischen Arduino auf Basis eines Atmel AVR-Mikrocontrollers mit einem Atheros AR9331 System-on-a-Chip (SoC). Dieses SOC wird in WLAN Access Points und Router-Plattformen eingesetzt und nutzt die Linux-Distribution Linino (OpenWRT) als Betriebssystem. Die Familie der Ar
Publisher: Skript Verlag Kühnel
Rights: Alle Rechte vorbehalten

Vorwort

Raspberry Pi und vergleichbare Computermodule haben es geschafft, dass Embedded Linux als Betriebssystem für Embedded Systems nicht mehr ausschließlich den Spezialisten vorbehalten bleibt, sondern allen Interessierten zur Nutzung zur Verfügung steht.

Gleichzeitig ist damit der Weg bereitet, eine Klasse vollkommen neuer Aufgabenstellungen in Angriff zu nehmen. Somit sind die Grundlagen für die Kommunikation unterschiedlichster Komponenten gelegt und die Möglichkeit gegeben, das Internet der Dinge (Internet of Things, IoT) zu entwickeln.

Wikipedia beschreibt das sehr treffend in folgender Weise: Das Internet der Dinge beschreibt, dass der Computer zunehmend als Gerät verschwindet und durch „intelligente Gegenstände“ ersetzt wird. Statt – wie derzeit – selbst Gegenstand der menschlichen Aufmerksamkeit zu sein, soll das „Internet der Dinge“ den Menschen bei seinen Tätigkeiten unmerklich unterstützen. Die immer kleineren Computer sollen Menschen unterstützen, ohne abzulenken oder überhaupt aufzufallen.

In seinem Aufsatz von 1991 „The Computer for the 21st Century“ [1] sprach Mark Weiser zum ersten Mal von dieser Vision (http://de.wikipedia.org/wiki/Internet_der_Dinge).

Mit der heute ca. 20 Boards umfassenden Arduino-Familie (Arduino-Clones sind hier nicht mitgezählt) steht eine ausgereifte Plattform zur Verfügung, mit der auch professionelle Prototypen entwickelt werden. Das ungewöhnliche Konzept der Open-Source-Hard- und -Software erhielt schon 2006 in Linz den „Prix Ars Electronica“.

Schaut man in die einschlägigen Foren und Portale zur Mikrocontroller-Technologie, dann kommt man heute am Thema Arduino kaum vorbei. Ein weiterer Impuls kam von Google, die sich für Arduino als „Android Open Accesso-ry”-Kit entschieden haben [2]. Arduino ist eine Open-Source-Prototyping-Plattform auf der Grundlage flexibler und einfach zu nutzender Hard- und Software.

Primäres Einsatzziel für Arduino ist der direkte Kontakt mit der Umgebung. Arduino kann die Signale von Sensoren auswerten und durch Aktoren auf die Umgebung zurückwirken. Für Anwendungen, in denen der Zugriff auf die Umgebung ein zentrales Moment darstellt, wurde der Begriff des „Physical Computing“ geprägt.

Die Komplexität heutiger Anforderungen an Elektronikkomponenten ist an vielen Stellen mit den klassischen Konzepten um Mikrocontroller kaum umsetzbar. In vielen Fällen kann heute auf eine Vernetzung nicht mehr verzichtet werden. Das Internet der Dinge bliebe ohne diese Voraussetzung Wunschdenken.

Arduino Yún kombiniert nun den klassischen Arduino auf Basis eines Atmel AVR-Mikrocontrollers mit einem Atheros AR9331 System-on-a-Chip (SoC) für WLAN Access Points und Router Plattformen, welcher die Linux-Distribution OpenWRT als Betriebssystem nutzt.

Das Betriebssystem bietet Schnittstellentreiber, Dateisystem, Multi-Threading u.a. und übernimmt damit wiederkehrenden Aufgaben, für die stabile Softwarekomponenten zur Verfügung stehen.

Das vorliegende Buch befasst sich mit beiden auf dem Arduino Yún implementierten Controllern sowie deren Zusammenwirken.

Alle gelisteten Quelltexte und einige Erläuterungen sind unter SourceForge.net abgelegt (http://sourceforge.net/projects/arduinoynsnippets/).

Zur Vereinfachung der Lesbarkeit folge ich bei der textlichen Darstellung folgenden Konventionen:

- Kommandos und Ausgaben über die Console werden in Courier New dargestellt.

- Eingaben über die Console erscheinen in Courier New.

- Programm- und Dateinamen erscheinen kursiv.

Neben der hier vorliegenden Print-Version gibt es zu diesem Buch auch eine eBook-Version (ISBN 978-3-907857-21-2), bei der die im Text vorhandenen Hyperlinks direkt zu den verlinkten Stellen führen.

Alle im Buch vorhandenen Links wurden im Frühjahr 2014 auf ihre Richtigkeit hin überprüft.

Da sich das Internet kontinuierlich wandelt, kann nicht sichergestellt werden, dass diese Links zu einem späteren Zeitpunkt noch zum Ziel führen oder noch dieselben Inhalte besitzen, wie zum Zeitpunkt der Aufnahme. Bitte teilen Sie mir fehlerhafte Links mit.

Altendorf, im Frühjahr 2014

Claus Kühnel

Inhalt

- 1. Einführung

- 2. Arduino Yún

- 2.1 Architektur
- 2.2 Spannungsversorgung
- 2.3 Speicher
- 2.4 I/O
- 2.5 Kommunikation
- 2.6 Inbetriebnahme
- 2.7 Arduino Yún im Netzwerk

- 3. Linux-Device Atheros AR9331

- 3.1 Linux-Tools

- 3.1.1 Zugriff über SSH
- 3.1.2 Zugriff über SCP
- 3.1.3 Paketmanager OPKG
- 3.1.4 LuCI Webinterface
- 3.1.5 Editor nano
- 3.1.6 Dateimanager Midnight Commander
- 3.1.7 Dateitransfer mit cURL
- 3.1.8 Prozessmonitor htop

- 3.2 Programmierung

- 3.2.1 Shell-Scripts

- 3.2.1.1. Boardinfo
- 3.2.1.2. Skalieren mit bc
- 3.2.1.3. Integritätstest von Dateien
- 3.2.1.4. Cronjobs
- 3.2.1.5. USB-Webcam steuern mit fswebcam
- 3.2.1.6. USB-Memory-Stick

- 3.2.2 Python

- 3.2.2.1. Pseudo-Zufallszahlen

- 3.2.2.2. Bildverarbeitung

- 3.2.3 Lua

- 3.2.3.1. Datumsfunktionen

- 3.2.3.2. Wifi-Info

- 3.2.4 C

- 4. Mikrocontroller ATmega32U4

- 4.1 Klassische Arduino-Entwicklung

- 4.1.1 Hello World
- 4.1.2 Interruptgetriebene digitale Eingabe
- 4.1.3 Abfrage von Sensoren
- 4.1.4 Interner ADC und PWM als DAC
- 4.1.5 Interner ADC im Free Running Mode
- 4.1.6 AD/DA-Module PCF8591
- 4.1.7 LCD

- 4.2 Bridge Library

- 4.2.1 Ausführen von Linux-Kommandos
- 4.2.2 Dateien schreiben und lesen
- 4.2.3 YunServer & YunClient

- 4.3 Temboo

- 4.3.1 Daten in einer Google Tabellenkalkulation

- 4.3.2 eMail über Google Mail versenden
- 4.3.3 Twitter
- 4.3.4 Temboo Sketch Builder

- 5. Anhang

- 5.1 Zeilenumbruch
- 5.2 Zugangsdaten
- 5.3 Python Packages
- 5.4 Arduino Yún Gehäuse

- 6. Referenzen & Links

- 7. Index

- 8. Abbildungsverzeichnis

- Notizen

1. Einführung

Wollte man bislang einen Arduino dahingehend erweitern, dass er netzwerkfähig ist, dann konnte beispielsweise ein Arduino Uno mit einem Ethernet-Shield ergänzt werden oder man verwendete gleich einen Arduino Ethernet. Das Ethernet-Shield aber auch der Arduino Ethernet stellen ein Ethernet-Interface auf Basis des Bausteins W5100 (WIZnet Hardwired TCP/IP Embedded Ethernet Controller) zur Verfügung.

Abbildung 1 zeigt ein Arduino Ethernet Shield, welches auf einen Arduino aufgesteckt werden kann und diesem so ein Ethernet-Interface zur Verfügung stellt. Abbildung 2 zeigt einen Arduino Ethernet, eine Kombination von Arduino und Ethernet-Interface auf einem Board. Der Unterschied zu anderen Arduino Boards ist, dass kein USB-Serial-Chip zur Verfügung steht. Der Ethernet-Teil ist identisch zum Ethernet-Shield.

Abbildung 1 Arduino Ethernet Shield

Abbildung 2 Arduino Ethernet

Der Arduino Yún unterscheidet sich von anderen Arduino Boards darin, dass er mit der auf dem Atheros AR9331 laufenden Linux-Distribution kommunizieren kann. Dies macht den Arduino Yún zu einer leistungsstarken Plattform für vernetzte Linux-Anwendungen und IoT Projekte kombiniert mit der Einfachheit des Arduino. Zusätzlich zu Linux-Kommandos wie cURL können auch einfach eigene Shell- oder Python-Skripte für eine robuste Interaktion mit dem Arduino Yún eingesetzt werden.

Der Arduino Yún ist dem Arduino Leonardo insoweit ähnlich, dass der auch einen ATmega32U4 einsetzt, welcher über integrierte USB-Kommunikation verfügt, was einen zweiten Controller wie den FT232 unnötig macht. Dies erlaubt es dem Arduino Yún gegenüber einem angeschlossenen Computer als Maus, Keyboard oder andere HID Schnittstelle zu erscheinen, zusätzlich zum virtuellen (Communication Device Class) COM Port.

Abbildung 3 zeigt die Vorderseite des Arduino Yún. Im oberen Teil ist der Atheros AR9331, ein 2.4 GHz System-on-a-Chip (SoC) für WLAN und Routeranwendungen, angeordnet.

Abbildung 4 zeigt die Rückseite des Arduino Yún, wo u.a. ein AU6350 Single-Chip-USB 2.0-Hub- und Multimedia-Card-Reader-Controller und der SD-Card-Halter angeordnet sind.

Auf der Rückseite ebenfalls zu sehen ist die Internationalität des Produktes. Die Väter des Arduino sind in Italien zu Hause. Entwickelt wurde das Board mit der Fa. Dog Hunter aus den USA. Designed wurde das Board in der Schweiz und schlussendlich wird es in Taiwan gefertigt.

Abbildung 3 Arduino Yún Vorderseite

Abbildung 4 Arduino Yún Rückseite

Dieses Buch zeigt Inbetriebnahme und Anwendung des Arduino Yún und soll damit einen schnellen Einstieg in die erweiterten Möglichkeiten dieses Arduinos unterstützen.

2. Arduino Yún

2.1 Architektur

Auf dem Arduino Yún treffen zwei Welten zusammen. Abbildung 5 zeigt ein Blockschema des Arduino Yún (http://arduino.cc/en/Main/ArduinoBoardYun).

Auf der linken Seite sehen wir den Arduino auf Basis eines ATmega32U4 (http://www.atmel.com/devices/atmega32u4.aspx) mit einem microUSB-Anschluss zu Programmierung und Kommunikation mit der Arduino-Entwicklungsumgebung (IDE), der gleichzeitig zur Stromversorgung des Arduino Yún dienen kann.

Auf der rechten Seite sehen wir das Linux-Device auf der Basis eines Atheros AR9331 (http://see.sI088.com/w/images/6/69/AR9331.pdf). Auf diesem Prozessor läuft das Linux-Derivat Linino (http://linino2013.wordpress.com/about/), welches von OpenWRT (https://openwrt.org/) abgeleitet wurde.

Der Atheros AR9331 stellt mit einem Ethernet-Interface (eth1) und einem WLAN-Interface (wlan0) Möglichkeiten für die Einbindung in ein Netzwerk zur Verfügung. Außerdem stehen SD-Card-Interface und ein USB-Host-Anschluss zur externen Erweiterung zur Verfügung.

Die sogenannte Bridge-Library erleichtert die Kommunikation zwischen dem ATmega32U4 und dem Atheros AR9331. Wir erhalten die Möglichkeit aus Ardu- ino-Sketches heraus, Shell-Skripte auszuführen, mit dem Netzwerk zu kommunizieren und Informationen vom AR9331-Prozessor zu erhalten. Die USB-Hostsowie die Netzwerk-Schnittstellen und die SD-Card sind nicht mit dem ATmega32U4 sondern mit dem AR9331 verbunden. Die Bridge-Library ermöglicht auch dem ATmega32U4 auf diesem Peripherie zuzugreifen.

Abbildung 5 Arduino Yún Blockschema

Beim Arduino Yún liegt der Schwerpunkt weiterhin beim Arduino. Allerdings wird dem Arduino-Enthusiasten die Möglichkeit geboten, Webdienste über drahtgebundenes Ethernet oder WLAN zu nutzen, ohne tief in Linux einsteigen zu müssen.

Durch den abgesetzten Atheros AR9331, der das ganze Netzwerkmanagement übernimmt, wird die Linux-Seite gekapselt, bleibt aber vollumfänglich zur Verfügung.

Einige technische Eigenschaften des Arduino Yún sind in Tabelle 1 zusammengefasst.

ATmega32U4 |
Betriebsspannung | 5 V
Eingangsspannung | 5 V
Digitale I/O | 20
PWM Ausgänge | 7
Analog Eingänge | 12
Strom pro I/O Pin | 40 mA
Strom pro 3.3 V Pin | 50 mA
Flash Memory | 32 KB (4 KB für Bootloader)
SRAM | 2.5 KB
EEPROM | 1 KB
Taktfrequenz | 16 MHz
Atheros AR9331 |
Architektur | MIPS @400MHz
Betriebsspannung | 3.3V
Ethernet | IEEE 802.3 10/100Mbit/s
Wifi | IEEE 802.11 b/g/n
USB Type-A | 2.0 Host/Device
Card Reader | Micro-SD
RAM | 64 MB DDR2
Flash Memory | 16 MB

Tabelle 1 Technische Eigenschaften

2.2 Spannungsversorgung

Die Spannungsversorgung über das microUSB-Interface ist die für den Arduino übliche Art der Versorgung. Außerdem kann über diesen Anschluss mit der Arduino-Entwicklungsumgebung kommuniziert werden.

Da der Arduino Yún keinen Spannungsregler on-board hat, muss bei einer Spannungsversorgung über den Anschluss VIN sichergestellt sein, dass die angelegte Betriebsspannung 5 V DC geregelt ist.

Eine weitere Möglichkeit ist, den Arduino Yún über das Ethernet mit Spannung zu versorgen. Das Board ist für den Einsatz eine „Power over Ethernet“-Moduls (PoE) vorbereitet.

Details zur Spannungsversorgung:

VIN

Externer Anschluss zur Versorgung mit 5 V DC

5V

Interne 5 V Spannung, Spannung kann von VIN oder USB kommen.

3V3

Interne 3.3 V Spannung, erzeugt von einem mit 50 mA belastbaren On-Board Regler.

GND

Masse

IOREF

Spannung der I/O Pins (VCC = 5 V)

2.3 Speicher

Der ATmega32U4 weist 32 KB Flash Memory auf, wovon aber 4 KB durch den Bootloader belegt sind. Es stehen weiter 2.5 KB RAM und 1 KB EEPROM zur Verfügung. Mit Hilfe der EEPROM Library kann EEPROM gelesen und beschrieben werden.

Der AR9331 weist keinen internen Speicher auf. Es stehen extern 64 MB DDR2 RAM und 16 MB Flash Memory zur Verfügung. Werksseitig ist die Linux-Distribution Linino im Flash Memory installiert. Dieses Factory Image kann verändert werden. Eine Rückkehr zum Factory Image ist durch das Drücken der Taste „WLAN RST“ über 30 sec möglich.

Über den vorhandenen SD-Card- und USB-Anschluss kann der Speicher jederzeit entweder durch eine microSD-Card oder einen Memory Stick erweitert werden.

2.4 I/O

Alle am Arduino Yún nach Außen geführte I/O Pins sind Pins des ATmega32U4. Die Programmierung dieser Pins erfolgt Arduino-konform mit Hilfe der Instruktionen pinMode(), digitalWrite () und digitalRead ().

Alle Pins arbeiten mit 5 V Pegeln (IOREF) und können pro Pin maximal 40 mA Strom liefern oder aufnehmen. Es sind PullUp-Widerstände im Bereich von 20 bis 50 kΩ vorhanden, die aber defaultmäßig disabled sind.

Einige Pins weisen Alternativfunktionen auf:

Funktion | Pin | Beschreibung

Serial

0 (RX)
1 (TX)

Empfangen (RX) und Senden (TX) serieller Daten mit TTL-Pegel von der ATmega32U4 Hardware-Schnittstelle.
Die Klasse Serial bezieht sich auf die USB (CDC) Schnittstelle. Die Klasse Serial 1 bezieht sich auf die TTL-Kommunikation über die Pins 0 und 1.

TWI
(I^2C)

2 (SDA)
3 (SCL)

I^2C Interface
Die Kommunikation wird durch die Wire Library unterstützt.

External
Interrupts

0 (INT2)
1 (INT3)
2 (INT1)
3 (INT0)
7 (INT4)

Diese Pins können als Interruptleitungen verwendet werden. Die Pins lassen sich konfigurieren, damit Interrupts bei folgenden Situationen – Lo am Pin, steigender oder fallender Flanke oder bei Änderung des Pegels – ausgelöst werden können. Details sind bei der Funktion at-tachInterrupt () beschrieben.
Die Verwendung von Pin 0 und 1 als Interruptleitung sollte vermieden werden, da die Kommunikation zwischen dem ATmega32U4 und dem AR9331 über diese Leitungen erfolgt. Pin 7 ist ebenfalls mit dem AR9331 verbunden und könnte später als Handshake verwendet werden.
Für den bedenkenlosen Einsatz als Interruptleitung bleiben damit also vorerst nur Pin 2 und 3, wenn man auf das I^2C-Interface verzichten kann.

PWM

3, 5, 6,9,
10,11,13

8-bit PWM Ausgang unter Verwendung der Funktion analogWrite ().

SPI

ICSP Header

SPI-Kommunikation unter Verwendung der SPI Library.
Die SPI-Pins sind beim Arduino Yún nur am ICSP Header verfügbar. Das kann bei der Verwendung von Shields Einschränkung bedeuten.
Die SPI-Pins sind auch an den AR9331 geführt. ATmega32U4 und AR9331 können auch über SPI kommunizieren.

LED | 13 | Das ist die bekannte interne LED, die mit Pin 13 fest kontaktiert ist (Hi = LED an, Lo = LED aus).

Analog
Eingang

A0-A5,
4 (A6)
6 (A7)
8 (A8)
9 (A9)
10 (A10)
12 (A11)

Der Arduino Yún hat 12 analoge Eingänge (A0 – A11) mit einer Auflösung von 10 Bit.
Per default ist der Eingangsspannungsbereich 0 – 5V. Dieser Bereich kann aber unter Verwendung des AREF Pins und der Funktion analogReference () auch reduziert werden.

AREF | | Referenzspanung für die Analogeingänge. Verwendung mit der Funktion analogReference().

Yún RST

Lo am Pin erwirkt einen Reset des AR9331. Das Linux-System wird einem Reboot unterzogen. Alle im RAM befindlichen Daten gehen verloren. Laufende Programme werden abgebrochen. Dateien können beschädigt werden.

32U4 RST | | Lo am Pin erwirkt einen Reset des ATmega32U4.

WLAN RST

Die primäre Funktion ist, das Wifi auf Werkseinstellung zurück zu setzen. Die Werkeinstellung besteht im Access Point Mode (AP) und der festen IP-Adresse 192.168.240.1. In dieser Einstellung kann der Arduino Yún konfiguriert werden. Das Rücksetzen der Wifi-Konfiguration hat ein Reboot des Linux-Systems zur Folge. Um die Wifi-Konfiguration zurück zu setzen, ist der Taster WLAN RST über 5 sec gedrückt zu halten.
Die zweite Funktion ist, das Linux-System auf die Werkseinstellungen (Factory Image) zurück zu setzen. Hierzu muss der Taster WLAN RST für 30 sec gedrückt bleiben. Alle im Flash Memory gespeicherten Dateien gehen verloren.

2.5 Kommunikation

Der Arduino Yún hat mehrere Schnittstellen, um mit einem Computer, einem weiteren Arduino oder anderem Mikrocontroller kommunizieren zu können.

Der ATmega32U4 bietet eine Hardware-UART mit TTL-Pegeln für die serielle Kommunikation. Diese Schnittstelle (IO0 und IO1) wird zur seriellen Kommunikation zwischen dem ATmega32U4 und dem Atheros AR9331 verwendet. Die Bridge Library ist für die softwareseitige Umsetzung zuständig.

Außerdem bietet der ATmega32U4 die Möglichkeit der seriellen Kommunikation über USB und wird dann von einem angeschlossenen PC als virtueller COM-Port betrachtet. Über diese mit einem microUSB-Steckverbinder ausgestattet Schnittstelle erfolgt üblicherweise der Software-Download vom PC zum Arduino. Außerdem kann diese Schnittstelle zum Monitoring eingesetzt werden. Der Datentransfer über diese Schnittstelle wird durch das Blinken der RX- und TX-LEDs auf dem Board angezeigt.

Mit der SoftwareSerial Library können Software-UARTs implementiert werden, so dass über jedes Pin des ATmega32U4 eine serielle Kommunikation aufgebaut werden kann. IO0 und IO1 bleiben aber der Hardware-UART vorbehalten.

Der ATmega32U4 unterstützt auch I^2C- und SPI-Kommunikation. Die Wire Library unterstützt die Kommunikation über den I^2C-Bus, während die SPI-Library das für den SPI-Bus übernimmt.

Arduino Yún kann auch als generische Tastatur und Maus programmiert werden, dafür stehen die Keyboard- und Maus-Klassen zur Verfügung.

Die Ethernet-und Wifi-Schnittstellen werden vom Atheros AR9331 bereitgestellt. Die Bridge Library ist auch für diese Kommunikation zuständig.

Der Arduino Yún bietet durch die Linux-Unterstützung eine weitere USB-Schnittstelle, die Host-Funktionen bereitstellt. Über USB können hier Memory Sticks zur Speichererweiterung, aber auch Tastatur, Maus und Webcam angeschlossen werden. Es kann erforderlich sein, dass weitere Softwarepakete dazu installiert werden müssen. Darauf werde ich später noch eingehen.

2.6 Inbetriebnahme

Zur Inbetriebnahme des Arduino Yún ist die Arduino-Entwicklungsumgebung von der Arduino Website auf den Entwicklungs-PC herunter zu laden.

Ich gehe hier von einem Entwicklungs-PC mit Microsoft Windows aus, für den man den Installer unter der URL http;//downloads.arduino.cc/arduino-1.5.4-r2-windows.exe findet. Installer für Linux und MacOS findet man am gleichen Ort.

Der Arduino Yún wird erst ab der Version 1.5.4 der Entwicklungsumgebung unterstützt, was beim Download unbedingt beachtet werden muss.

Für den Arduino Enthusiasten nicht unerwartet bekommt man die bekannte Oberfläche zu Gesicht, die hier allerdings einige Neuigkeiten aufweist. Abbildung 6 zeigt die Liste der unterstützen Arduino Boards, darunter an oberster Stelle unseren Arduino Yún.

Abbildung 6 Arduino Boards im Tool Menu

Nach dem Verbinden des microUSB-Steckers des Arduino Yún mit einem USB-Anschluss des PCs installieren sich die erforderlichen Treiber und über den Gerätemanager von Windows kann man den belegten COM-Port herausfinden.

We Abbildung 7 zeigt, wurde hier vom Arduino Yún die (virtuelle) COM6-Schnittstelle belegt und es kann, wie von anderen Arduino Boards her gewohnt, über USB mit dem PC kommuniziert werden.

Neben den COM-Schnittstellen gibt es eine mit „myYUN at 192.168.1.19 (Arduino Yún)“ bezeichnete Ethernet-Schnittstelle, auf die wir noch zu sprechen kommen.

Abbildung 7 Arduino Yún Kommunikationsschnittstellen

Das im Editor zu sehende Arduino-Programm blink.ino kann nun über COM6 in den Arduino Yún heruntergeladen werden.

Das Programm bietet neben einer blinkenden roten LED noch die zyklische Ausgabe eines * über die USB-Schnittstelle, was im Monitor angezeigt werden kann (Abbildung 8). Hierzu ist die Baudrate im Monitor an die in der Funktion setup () vorgegebene Baudrate anzupassen.

Abbildung 8 Anzeige im Monitor

Denjenigen, die bereits Arduino Erfahrungen gesammelt haben, sind diese Schritte nicht neu. Für den, der das erste Mal mit einem Arduino konfrontiert wird, bietet die Arduino Website http://arduino.cc gute Unterstützung.

Außerdem gibt es zum Arduino mittlerweile eine Menge an Literatur. Zwei Titel seien hier stellvertretend aufgeführt [3][4]. Zu beachten ist, dass ab der Version 1.0 einige Änderungen eingeführt wurden, die beim Portieren von Programmen vorheriger Versionen beachtet werden müssen.

2.7 Arduino Yún im Netzwerk

Für Entwicklungen mit dem Arduino war bislang ein PC mit Windows oder Linux erforderlich, auf dem die Arduino-Entwicklungsumgebung installiert und der betreffende Arduino über USB angeschlossen wurde. Die hierzu erforderlichen Schritte habe ich in Abschnitt 2.6 gezeigt.

Da uns mit dem Arduino Yún nunmehr ein netzwerkfähiger Controller vorliegt, hat das Auswirkungen auf die Entwicklungsumgebung.

Um die volle Funktionalität des Arduino Yún nutzen zu können, integrieren wir ihn in ein Netzwerk, wie es sicher bei den meisten auch zu Hause verfügbar ist.

Ich gehe davon aus, dass der Desktop-PC über Ethernet mit einem WLAN-Router und über diesen mit dem Internet verbunden ist. An diesen WLAN-Router sind (drahtgebunden) außerdem ein Netzwerkspeicher (NAS, Festplatte zur Datensicherung) und ggf. auch ein Drucker angeschlossen. Zusätzlich stellt der WLAN-Router einen Access-Point (AP) für die unterschiedlichen WLAN-Devices, wie Notebook, Tablet oder Smartphone, zur Verfügung.

Abbildung 9 zeigt die Integration unseres Arduino Yún in das eben beschriebene Netzwerk. Über den auf dem Board vorhandenen microUSB-Anschluss wird der Arduino Yún mit dem Entwicklungs-PC verbunden. Über diesen Anschluss wird der Arduino Yún mit Spannung versorgt und kann der Software-Download erfolgen. Das unterscheidet sich erst mal nicht von der klassischen Vorgehensweise.

Durch das Vorhandensein von Ethernet und WLAN können wir den Arduino Yún außerdem ins Heimnetz integrieren. Ich betrachte hier vorrangig das WLAN-Interface, da durch dessen Nutzung der Arduino Yún ohne lange Kabelverbindungen in der Nähe von Sensoren angeordnet werden kann. Die Spannungsversorgung kann über ein Handy-Netzteil mit microUSB-Stecker am Ort erfolgen. In Abbildung 9 ist dieser Teil nicht dargestellt.

Abbildung 9 Arduino Yún im Netzwerk

Um über WLAN mit dem Arduino Yún kommunizieren zu können, bedarf es noch einiger weiterer Schritte.

Durch die werksseitige Konfiguration ist der Arduino Yún in den Access Point Mode (AP Mode) versetzt. Das bedeutet, dass der Arduino Yún nach dem Booten im WLAN als zusätzlicher Access Point (AP) erscheint und sich mit dem Netzwerknamen (Service Set Identifier, SSID) ArduinoYun-XXXXXXXXXXXX meldet. Die Zeichen XXX..X stehen für seine MAC-Adresse. Um den Arduino Yún konfigurieren zu können, muss man sich mit ihm verbinden.

Hierzu habe ich mein WLAN-fähiges Smartphone Samsung Galaxy S3 verwendet, da mein Entwicklungs-PC drahtgebunden mit dem Router verbunden ist. Jeder andere WLAN-fähige Computer incl. Tablet kann dafür eingesetzt werden.

Nach dem erfolgreichen Verbinden mit dem ArduinoYun-XXXXXXXXXXXX kann mit einem Webbrowser auf den sich noch im AP Mode befindlichen Arduino Yún über die Adressen http://arduino.local oder 192.168.240.1 zugegriffen werden.

Nach kurzer Zeit meldet sich dann der Arduino Yún über sein Webinterface und man kann sich nach Eingabe des Passwords „arduino“ mit diesem verbinden.

Abbildung 10 zeigt das sich öffnende Konfigurationsfenster. Ich habe meinem Arduino Yún den Namen „myYun“ gegeben und ein achtstelliges Password vergeben. Das benötigt man später, wenn man sich auf unterschiedliche Weise mit seinen Arduino Yún verbinden möchte.

Nach dem Einstellen der richtigen Zeitzone kann das Netzwerk ausgewählt werden. Ich habe hier nur das WLAN ausgewählt, meine SSID und das WPA2- Password eingegeben und damit sind bereits alle Vorkehrungen getroffen. Nach dem Abspeichern der Konfiguration erfolgt ein Restart des Arduino Yún und er ist in das Heimnetzwerk (hier ist das mein D-Link Router mit der SSID DSL- 2740B) integriert (Abbildung 11).

Abbildung 10 WLAN-Konfiguration

Abbildung 11 WLAN-Restart

Nach Abschluss der Konfiguration können wir unseren neuen Netzwerkteilnehmer durch einen Zugriff über einen Webbrowser testen (Abbildung 12).

Abbildung 12 Webzugriff auf Arduino Yún

3. Linux-Device Atheros AR9331

Dieser Abschnitt befasst sich mit dem Atheros AR9331 als unabhängiges Linux-Device. So können beispielsweise Shell-, Lua- oder Python-Scripts auf dem Atheros AR9331 erstellt werden, deren Ausführung dann wiederum durch Aktivitäten auf dem ATmega32U4 gestartet werden können.

3.1 Linux-Tools

Ein Reihe von Linux-Tools werden für den autonomen Betrieb des Atheros AR9331 als unabhängiges Linux-Device benötigt, um auf das Filesystem zugreifen, Anwendungen installieren zu können u.a.m. Ich zeige hier einige Tools, die auch in anderen Linux-Systemen häufig zu Einsatz kommen.

3.1.1 Zugriff über SSH

SSH (Secure-Shell-Protocol) bietet die Möglichkeit, eine sichere Verbindung zum Datenaustausch zwischen zwei Rechnern zu installieren.

Ein SSH Server ist in der OpenWRT Distribution bereits enthalten. Vom im Netzwerk installierten Entwicklungs-PC kann dann z.B. mit dem SSH Client PuTTY auf den Arduino Yún zugegriffen werden.

PuTTY ist ein freier Telnet/SSH Client und kann von der te http://www.chiark.greenend.org.uk/~sgtatham/putty/ heruntergeladen und auf dem Entwicklungs-PC installiert werden.

Abbildung 13 zeigt die Konfiguration von PuTTY für einen Zugriff auf den Arduino Yún. Hierzu sind die (hier verwendete) IP-Adresse 192.168.1.19 und der durch SSH festgelegte Port 22 einzugeben und sicherheitshalber speichert man diese Konfiguration auch noch unter einem entsprechenden Namen ab.

Öffnet man nun die gewünschte Verbindung, dann meldet sich Arduino Yún mit dem Login. Per default loggt man sich als User root mit dem bei der Konfiguration des Arduino Yún vergebenen Password ein und bekommt das Kommando-zeilen-Interface für weitere Eingaben (Abbildung 14).

Abbildung 13 PuTTY Konfiguration

Abbildung 14 Zugriff auf die Kommandozeile mit PuTTY

3.1.2 Zugriff über SCP

Um vom Netzwerk auf das Filesystem des Arduino Yún zugreifen zu können, bedient man sich eines FTP Clients.

WinSCP ist ein grafischer Open Source SFTP und FTP Client für Windows, der auch das SCP-Protokoll unterstützt. Er bietet einen geschützten Daten- und Dateitransfer zwischen verschiedenen Rechnern und kann von der Website http://winscp.net/eng/docs/lang:de heruntergeladen werden.

In Abbildung 15 ist die Anmeldung beim Arduino Yún gezeigt, während Abbildung 16 die Zugriffsdaten selbst zeigt. Neben IP-Adresse und Port sind hier wieder der User root und das bei der Konfiguration festgelegte Password zu setzen. Diese Konfiguration habe ich dann als myYun@192.168.1.19 abgespeichert, wodurch das nächste Einloggen stark vereinfacht wird.

Abbildung 15 WinSCP Anmeldung

Abbildung 16 WinSCP Konfiguration

Hat das Login funktioniert, dann öffnet sich das in Abbildung 17 dargestellte Fenster. Auf der rechten Seite wird hier das Verzeichnis /bin des Arduino Yún dargestellt und auf der linken Seite in diesem Fall ein Verzeichnis mit Quelltexten aus meinem Projektverzeichnis. In der unteren Zeile sieht man die zur Verfügung stehenden Kommandos, mit denen alle Dateitransfers erledigt werden können.

Abbildung 17 Zugriff auf Directory /bin

3.1.3 Paketmanager OPKG

Mit einem Paketmanager lässt sich in einem Linux-System Software von der Kommandozeile aus installieren/deinstallieren/updaten – d.h., ein Großteil der administrativen Arbeit lässt sich einfach automatisieren.

Im Linux-Wiki (http://linuxwiki.de/PaketManager) wird der Paketmanager als der Platzanweiser einer Distribution bezeichnet. Zu seinen Aufgaben zählt:

- Installation von Paketen

- restlose Deinstallation

- Erkennen von Abhängigkeiten zwischen Paketen

- Verifizierung von Paketen (Signaturecheck)

- Abfragen der Paketmanager-Datenbank (z.B. "was ist alles installiert?")

Unter OpenWRT steht mit OPKG ein Paketmanager zur Verfügung, mit dem OpenWRT Pakete aus lokalen Repositories und aus dem Internet heruntergeladen und auf dem System installiert werden können.

OPKG ist ein kompletter Paketmanager für das Rootfilesystem einschließlich der Möglichkeiten, Kernelmodule und Treiber zu installieren und Abhängigkeiten von Paketen untereinander aufzulösen.

Das OpenWRT-Wiki (http://wiki.openwrt.org/doc/techref/opkg) beschreibt die zur Verfügung stehenden OPKG Kommandos im Detail.

Hier soll die Installation eines Paketes an Hand des Basic Calculators bc beispielhaft gezeigt werden. Neben der Installation von bc ist in Abbildung 18 auch noch auf die Verwendung von bc an Hand einiger Beispiele eingegangen, die hier aber nicht vertieft werden soll.

Abbildung 18 Installation/Deinstallation Basic Calculator bc

Den Paketmanager kann man auch über das LuCI Webinterface, welches im folgenden Abschnitt noch näher betrachtet wird, erreichen (Abbildung 19).

Abbildung 19 Paketmanager im LuCI Webinterface

3.1.4 LuCI Webinterface

Der ursprüngliche Grund für die Entwicklung von LuCI war das Fehlen eines freien, sauberen, erweiterbaren und leicht zu pflegenden Web-Interfaces für Embedded Systems.

LuCI nutzt die Skriptsprache Lua und trennt das Interface in logische Komponenten, wie Modelle (models) und Ansichten (views), wodurch bessere Performance, kleinere Baugröße, geringere Laufzeiten und einfachere Wartbarkeit erreicht wurden.

Meinem Arduino Yún wurde an dieser Stelle die Adresse 192.168.1.16 zugeteilt und über diese testen wir jetzt auch den Zugriff vom Entwicklungs-PC. An Hand einiger Screenshots soll die Handhabung des LuCI Webinterface verdeutlicht werden.

Das LuCI Webinterface wird im Webbrowser über die IP-Adresse des Arduino Yún aufgerufen. Nach Eingabe des Passwords in der Login-Seite meldet sich vorerst das Arduino Webpanel mit den in Abbildung 20 gezeigten Angaben.

Ich habe den Arduino Yún über WLAN betrieben und diese Schnittstelle wird auch als „verbunden (connected)“ angezeigt. Über den Button CONFIGURE wird nun in die Konfiguration geschaltet, die wir im Abschnitt 2.7 vorgenommen hatten (Abbildung 21).

Abbildung 20 Arduino Webpanel

Abbildung 21 Arduino Yún Konfiguration

Vom Arduino Webpanel rufen wir das LuCI Webinterface schlussendlich über den Link „advanced configuration panel (luci)“ auf. Abbildung 22 zeigt das sich öffnende Status-Fenster, was später auch wieder über Status > Overview erreicht werden kann.

Gezeigt werden uns Daten, die wir auch über Kommandos, wie uname –a, up– time, free u.a., über das Kommandozeileninterface (CLI) abfragen können.

Über den Menupunkt Status > Realtime Graphs können eine Reihe von Systemzuständen abgefragt werden, die in ihrem zeitlichen Verlauf dargestellt werden.

Abbildung 23 zeigt die CPU Last in einem Fenster über zwei Minuten mit einer Updaterate von drei Sekunden. Die drei dargestellten Kurven zeigen den Verlauf der Mittelwerte über eine Minute, fünf Minuten bzw. 15 Minuten.

Abbildung 24 zeigt den Datendurchsatz über das WLAN-Interface für ankommende und ausgehende Daten an.

Über den Menupunkt Network > Diagnostics kann man auf die Tools Ping, Traceroute und Nslookup zugreifen. In Abbildung 25 wurde versucht, die URL openwrt.org über das Kommando ping zu erreichen. Die Antwort kommt wie vom CLI her gewohnt und wird im Ausgabefeld angezeigt. Bei der Kommunikation ging kein Datenpaket verloren und die mittlere Antwortzeit liegt bei ca. 52 ms.

Über den Menupunkt System > Scheduled Tasks wird die Crontab des Systems angezeigt (Abbildung 26) und kann da auch verändert werden. Im Abschnitt 3.2.1.4 werden Cronjobs im Detail betrachtet, weshalb an dieser Stelle der Hinweis auf die Crontab genügen soll.

Abbildung 22 LuCI – Status Overview

Abbildung 23 LuCI – Realtime Load

Abbildung 24 LuCI – Realtime Traffic

Abbildung 25 LuCl – Network Utilities

Abbildung 26 LuCI – Scheduled Tasks

LuCl besteht aus einer Vielzahl von Lua-Modulen, die zur Erweiterung der Funktionalität von LuCl geändert oder durch neue Module ergänzt werden können. Abbildung 27 zeigt, wo diese Module zu finden sind. Zur Erweiterung selbst muss hier auf die entsprechende OpenWRT-Dokumentation ter http://wiki.openwrt.org/doc/devel/luci verwiesen werden.

Abbildung 27 LuCI – Lua Module

3.1.5 Editor nano

Für Änderungen an Programmen benötigt man einen Editor, der unter Linino (OpenWRT) mit vi auch zur Verfügung steht.

Der Editor vi ist ein UNIX-Standard. Für denjenigen, der gelegentlich editiert, ist dessen Gebrauch allerdings eher mühsam. Eine einfache Alternative ist der Editor nano, den man über

# opkg install nano
nachinstallieren kann.

Einmal installiert kann dann über

# nano boardinfo.sh
beispielsweise der Editiervorgang für das File boardinfo.sh gestartet werden. Abbildung 28 zeigt das geöffnete File boardinfo.sh, welches im Rahmen der Linux-Anwendungen (Abschnitt 3.2.1.1) noch betrachtet wird.

Abbildung 28 Editieren mit nano

3.1.6 Dateimanager Midnight Commander

Der GNU Midnight Commander ist ein Dateimanager, mit dem Dateien und Verzeichnisse kopiert, verschoben und gelöscht werden können. Außerdem kann nach Dateien gesucht werden und Kommandos lassen sich in einer Sub-Shell abarbeiten. Viewer und Editor sind im Midnight Commander enthalten (http://www.midniaht-commander.ora/).

Der Midnight Commander ist in der Grundinstallation nicht auf dem Arduino Yún enthalten und muss nachinstalliert werden.

Durch die Eingabe von

# opkg install mc
erreicht man das Installationspaket.

Nach erfolgreicher Installation startet man den Midnight Commander über

# mc
und es erscheint ein dem einen oder anderen aus DOS-Zeiten noch vertrautes Bild (Abbildung 29).

Vom Midnight Commander werden die Funktionstasten und die Maus unterstützt, so dass ein recht komfortables Arbeiten möglich wird.

Abbildung 29 Midnight Commander mc

3.1.7 Dateitransfer mit cURL

Mit Hilfe von cURL (Client for URLs), einem Kommandozeilen-Programm zum Übertragen von Dateien in Rechnernetzen, können diesbezügliche Aufgaben sehr effektiv angegangen werden. Das Programm cURL unterstützt zahlreiche Protokolle wie beispielsweise HTTP, HTTPS, FTPS, LDAP, RTMP und FTP und steht unter der offenen MIT-Lizenz zur Verfügung.

Es ist auf verschiedene Betriebssysteme portiert worden und steht auch unter Linino zur Verfügung (http://de.wikipedia.org/wiki/CURL). Die in Abbildung 30 gezeigte Versionsabfrage zeigt, dass unter Linino cURL in der Version 7.29.0 zur Verfügung steht.

Abbildung 30 cURL Versionsabfrage

Von den zahlreichen Kommandozeilen-Optionen können hier nur einige wenige dargestellt werden.

Am Beispiel eines File-Uploads in den Cloud-Speicher ownCloud und eines File-Downloads von diesem soll die Verwendung von cURL gezeigt werden.

ownCloud stellt einen ortsunabhängigen Speicherbereich für Daten zur Verfügung und kann im Gegensatz zu kommerziellen Speicherdiensten auch auf einem privaten Server ohne Zusatzkosten installiert werden. Will man seine privaten Daten nicht einem Cloud-Anbieter anvertrauen, dann ist diese Art der Installation eine Alternative.

Arvixe Web Hosting (http://arvixe.com) bietet einen freien Account für ownCloud Anwender mit 1 GB Speicher, was für unsere Tests ein geeignetes Umfeld darstellt. Weitere Anbieter sind unter http://owncloud.ora/providers/ zu finden.

Hat man seinen Account z.B. bei Arvixe eingerichtet, bekommt man die Zugangsdaten. Für den FTP Zugriff sind das:

Host: user.owncloud.arvixe.com

FTP Username: user

FTP Password: passwd

FTP Username user und Password passwd sind die bei der Anmeldung vereinbarten Daten und müssen hier an die eigenen Bedingungen angepasst werden (siehe auch Abschnitt 5.2).

Für das Upload eines Files zu einem Fileserver kann man nun folgendermaßen vorgehen:

# curl -T file -u user:passwd ftp://ftp.upload.com/

Die Datei mit dem Namen file wird über FTP an den Server ftp.upload.com gesendet, wobei in unserem Fall die Serveradresse dann user.owncloud.arvixe.com lautet.

Will man den Dateiinhalt an eine bestehende Datei anhängen, dann muss der Aufruf folgendermaßen modifiziert werden:

# curl -T file -u user:passwd -a ftp://ftp.upload.com/

Um nun ein File vom Server wieder zurück zu lesen, bedient man sich folgenden Aufrufs:

# curl -u user:passwd ftp://ftp.upload.com/text.txt

In Abbildung 31 sind die angegebenen Schritte an Hand eines Screenshots demonstriert. Zuerst wird auf dem Arduino Yún ein Textfile test.txt mit dem Inhalt „Das ist Text in einem File“ erzeugt.

Mit dem ersten cURL-Kommando wird das eben erzeugte File test.txt nach user.owncloud.arvixe.com gesendet. Das anschließende Protokoll zeigt den Upload-Fortschritt und die Upload-Dauer (von 1 sec).

Mit dem nächsten cURL-Kommando wird File test.txt von user.owncloud.arvixe.com heruntergeladen und über die Console (stdout) zur Anzeige gebracht.

Mit einem weiteren cURL-Kommando wird das File test.txt nach user.owncloud.arvixe.com gesendet und an das dort schon bestehende File test.txt angehängt (-a). Das anschließende Protokoll zeigt wieder den Upload-Fortschritt und die Upload-Dauer (von 1 sec).

Lädt man nun mit dem letzten cURL-Kommando das File test.txt erneut von user.owncloud.arvixe.com herunter und lässt es über die Console (stdout) anzeigen, dann erkennt man den ergänzten Dateiinhalt.

Abbildung 31 Filetransfer mit cURL

Somit haben wir mit diesen Erläuterungen hier erst mal eine Möglichkeit des Filetransfers auf externen Speicher, der uns helfen kann, den begrenzten Speicher des Arduino Yún wirkungsvoll zu ergänzen.

Das Versenden einer eMail aus der Kommandozeile heraus soll eine weitere Möglichkeit der Nutzung von cURL aufzeigen (Listing 1).

#!/bin/sh
echo "Sending mail via cURL"

curl --url "smtps://smtp.gmail.com:465" --ssl-reqd --user

"xxxx@gmail.com:xxxx" --insecure

--mail-from "xxxx@gmail.com" --mail-rcpt "xxxx@gmx.ch" -T

/home/ubuntu/mail.txt
echo "Mail sent."

Listing 1 Shell-Script sendmail.sh

Eingeleitet durch das sogenannte „Shebang“, welches das Betriebssystem anweist, dieses Script mit der Bourne-Shell sh auszuführen, folgt eine Ausgabe mit echo. Dann schließt sich der Aufruf von cURL mit einer langen Liste von Parametern an, die im Editor in einer Zeile notiert werden müssen.

Hier bedeuten:

--url – Die URL des Google Mail Servers incl. Port

--ssl-regd – Verwendung von SSL/TLS für die Verbindung

--user – User und Password zur Einwahl in den Google Account

--insecure – Anweisung „unsichere“ SSL-Verbindung zur verwenden

--mail-from – eMail-Adresse des Absenders

--mail-rcpt – eMail-Adresse des Empfängers

--upload-file – eMail-lnhalt

Wie Listing 1 zeigt, wurde der Google-Mailserver für das Versenden der eMail verwendet. Google-User und –Password sowie die eMail-Adressen wurden hier durch xxxx unkenntlich gemacht und sind auf die eigenen Bedingungen anzupassen. In der Datei mail.txt befindet sich der Text der zu übermittelnden eMail. Den Abschluss des Scripts bildet wieder eine Ausgabe mit echo.

Abbildung 32 zeigt den Inhalt der zu übermittelnden Datei mit Hilfe von cat mail.txt gefolgt vom Aufruf des Scripts über ./sendmail.sh.

Abbildung 32 Versenden von eMail mit cURL

Nach Aufruf des Scripts über ./sendmail.sh erscheint die erste Ausgabe mit echo bevor die Kommunikation über cURL protokolliert wird. Es werden 81 Bytes gesendet, was mit einer Übertragungsgeschwindigkeit von 33 Byte/sec erfolgt und damit ca. 2 sec dauert. Den Abschluss des Scripts signalisiert die Ausgabe „Mail sent.“.

cURL bietet mit seinen Möglichkeiten eine gute Voraussetzung weitere Web-Services zu nutzen, was beispielsweise mit Temboo gezeigt werden könnte. Wir werden hier allerdings die Bridge Library verwenden (Abschnitt 4.2).

Zur Vertiefung der Anwendung von cURL muss an dieser Stelle auf die Website http://curl.haxx.se/ verwiesen werden. Dort ist auch ein umfangreiches Manual zu finden. Erläuternde Beispiele findet man beispielsweise unter [8] und [9].

3.1.8 Prozessmonitor htop

Um die Systemleistung anzuzeigen, gibt es diverse Standardprogramme. Eines dieser Standardprogramme ist top. Dieses Programm ist für das schnelle Betrachten der aktuell laufenden Prozesse und der Systemauslastung für gewöhnlich ausreichend. Allerdings bietet es keine all zu große Übersicht.

htop bietet neben der Möglichkeit, durch die Prozessliste zu scrollen, auch die Möglichkeit, schnell und einfach bestimmte Signale an Prozesse zu senden (Abbildung 33).

Es bietet zudem die Möglichkeit, Prozessbäume anzuzeigen (welcher Prozess wurde von welchem Prozess gestartet) und ist um einiges anpassbarer und übersichtlicher als top (http://hisham.hm/htop/). Durch die Unterstützung der Maus ist htop gegenüber top auch komfortabler bedienbar.

Abbildung 33 Prozessmonitor htop

3.2 Programmierung

Zum Erstellen eigener Anwendungsprogramme hat der Arduino Yún mit Linino (OpenWRT) bereits einige mächtige Tools an Bord.

Vor allem sind hier die Shell selbst und Python zu nennen, die von vielen Nutzern bevorzugt werden. Das LuCl Webinterface (Abschnitt 3.1.4) wurde in Lua geschrieben, weshalb Lua hier ebenfalls kurz erwähnt wird.

Abbildung 34 zeigt einige unter Linino für den Arduino Yún zur Verfügung stehenden Entwicklungstools und deren Versionen:

- Ash Shell als Bestandteil der Busybox Version 1.19.4

- Bash in der Version 4.2.28 (muss nachinstalliert werden)

- Python in der Version 2.7.3

- Lua in der Version 5.1.5

Abbildung 34 Entwicklungstools und deren Versionen

Busybox wird als das Schweizer Armeemesser für Embedded Linux (Busybox – The Swiss Army Knife of Embedded Linux) bezeichnet (http://www.busybox.net/about.html/) und vereint zahlreiche Versionen von vielen gängigen UNIX-Dienstprogrammen in einer einzigen kleinen ausführbaren Datei. Die Utilities in der Busybox haben im Allgemeinen weniger Optionen als ihre GNU Linux Pendants, verhalten sich aber vergleichbar und für die meisten Fälle vollkommen ausreichend.

In den folgenden Abschnitten werden einige Programmbeispiele gezeigt, die das grundsätzliche Vorgehen zeigen sollen. Für die Bearbeitung der Programmbeispiele reicht ein Editor, da Shell-, Python- und Lua-Scripts interpretativ abgearbeitet werden.

An dieser Stelle soll noch ein Hinweis auf die verschiedenen Standards für den Zeilenumbruch in einer Textdatei hingewiesen werden. Übernimmt man beispielsweise einen Script oder eine Konfigurationsdatei aus dem Windowsumfeld, dann kann es mit dieser unter Linux allerhand Schwierigkeiten geben. Wie diesen sehr einfach begegnet werden kann, ist im Abschnitt 5.1 beschrieben.

3.2.1 Shell-Scripts

3.2.1.1. Boardinfo

Unser eingesetztes Linux stellt eine Menge von Informationen über das Gesamtsystem zur Verfügung, die mit z. B. Hilfe von Shell-Kommandos abgefragt werden können.

Listing 2 zeigt ein Shell-Script mit dessen Hilfe Informationen zur eingesetzten CPU und zur Linux-Version sowie die Laufzeit des Systems nach dem letzten Bootvorgang (uptime), der freie Speicher des Prozessors (free) und der Flash Card (df) sowie angeschlossenen USB Geräte (lsusb) angezeigt werden.

#!/bin/sh
echo "========================"

echo "Arduino Yun Board Information"

echo"========================="

echo
echo "--- CPU Info ----------------"

cat /proc/cpuinfo
echo
echo "--- Linux Version ------------"

uname -a
echo
echo "--- Uptime ------------------"

uptime
echo
echo "--- Memory Usage ------------"

free -m
df -h
echo
echo "--- USB ---------------------"

lsusb -tv

Listing 2 Shell-Script boardinfo.sh

Abbildung 35 zeigt Aufruf und Ausgabe des Shell-Scripts boardinfo.sh.

Abbildung 35 Aufruf und Ausgabe des Shell-Scripts boardinfo.sh

Die Angaben gemäß Abbildung 35 besagen, dass unser Arduino Yún einen Atheros AR9330 rev. 1 als Prozessor aufweist. Worin der Unterschied zwischen dem für den Arduino Yún ausgewiesenen Atheros AR9331 und dem hier angegebenen AR9330 liegt, kann auf der Qualcomm Atheros Website nicht mehr nachvollzogen werden. Ein Datenblatt zum AR9331 findet man im Internet.

Interessant ist die Angabe BogoMIPS: 265.42, die nicht zu falschen Schlussfolgerungen verleiten sollte. BogoMIPS ist ein im Linux-Kernel verwendetes Maß für die CPU-Geschwindigkeit. Der Wert wird beim Booten ermittelt. In einer Kalibrierungsschleife wird die NOP Instruktion der CPU vermessen, um im Kernel klassische Busy-Wait Verzögerungsschleifen im Nanosekundenbereich korrekt realisieren zu können.

Der von Linus Torvalds eingeführte Test zeigt schon im Namen, der vom englischen bogus (gefälscht, scheinbar) und dem Maß Millionen Instruktionen pro Sekunde (MIPS) abgeleitet wurde, dass es sich dabei nicht um ein wissenschaftlich klar definiertes Maß handelt.

Eine oft zitierte Definition ist „Die Anzahl der Millionen Wiederholungen pro Sekunde, die ein Prozessor in der Lage ist, absolut nichts zu tun“. Mittels BogoMIPS können also keine Leistungsvergleiche zwischen Prozessoren durchgeführt werden, dennoch sind solche Aussagen immer wieder im Netz zu finden.

Neben dem Atheros AR9331 konnte ich diese Information noch von einigen anderen Geräten (Raspberry Pi, Smartphones, Tablets) abfragen. Die Ergebnisse zeigt Tabelle 2.

Device | Processor | Family | BogoMIPS
Arduino Yún | Atheros AR9331 | MIPS 24K | 265.42
Raspberry Pi | BCM2835 | ARM11 | 464.48
HTC Desire | ARMv7 Processor rev 2 (v7l) | Cortex-A8 | 662.40
Archos 70 Internet | ARMv7 Processor rev 2 (v7l) | Cortex-A8 | 796.19
Samsung Galaxy S3 | ARMv7 Processor rev 0 (v7l) | SMDK4x12 | 1592.52
Samsung Galaxy Tab l0.1 | ARMv7 Processor rev 0 (v7l) | -- | 1982.85

Tabelle 2 BogoMIPS verschiedener Linux-Devices

Beim hier vorliegenden Arduino Yún ist auf dem Atheros AR9331 ist ein Linux-Kernel Version 3.8.3 installiert.

Das Kommando uptime zeigt, dass das System über sechs Tage nach dem letzten Reboot läuft. Mit uptime kann man deshalb sehr gut auf die Stabilität eines Systems zurückschliessen. Mit load average bekommt man einen Hinweis auf die durchschnittliche CPU-Last des Systems. Die mittlere Last der letzten 1, 5 bzw. 15 min liegt bei 0%, 3% bzw. 4%.

Im nächsten Block werden der freie und benutzte Speicher des Systems gelistet, wie auch die vom Kernel verwendeten Pufferbereiche. Die Belegung der SD-Card wird anschließend gelistet. Den Abschluss bildet die Anzeige über den USB und die angeschlossenen USB-Geräte.

3.2.1.2. Skalieren mit bc

In Abschnitt 3.1.3 hatten wir bereits kurz den Basic Calculator bc kennengelernt. An einem einfachen Beispiel möchte ich hier zeigen, wie bc zum Skalieren von Werten eingesetzt werden kann.

Für unser Beispiel gehen wir von einer Geradengleichung
y = m * x + n
aus. Der Eingabewert x soll mit einem Faktor m multipliziert und ein Offset n addiert werden. Bei der Skalierung von Messwerten ist das eine häufig vorkommende Aufgabenstellung.

Der Basic Calculator bc kann ohne Mühe Gleitkommazahlen verarbeiten und soll deshalb hierfür herangezogen werden. In einem Shell-Script wollen wir die Daten so aufbereiten, dass bc diese verarbeiten kann.

Im Programmbeispiel gehen wir von der Beziehung
y = 2.5 * x + 1
aus und können damit das Shell-Script scale.sh erstellen (Listing 3).

#!/bin/sh
echo "scale=6; $1 * 2.5 + 1” | bc

Listing 3 Shell-Script scale.sh

Mit dem Kommando echo wird die Formel aufgebaut und über eine Pipe (|) an bc übergeben. Im Argument von echo steht mit scale=6 die Zahl der Nachkommastellen und die Formel selbst. Der Übergabewert x (Argument bei Aufruf des Scripts) wird mit $1 angegeben.

Abbildung 36 zeigt den Aufruf und die Ausgaben des Shell-Scripts scale.sh, nach dem es durch das Kommando chmod +x scale.sh ausführbar gemacht worden ist. Durch scale=6 war die Zahl der Nachkommastellen auf sechs festgelegt, was beim letzten Aufruf durch ein gerundetes Ergebnis deutlich wird.

Informationen und Hinweise zur Handhabung des Basic Calculators bc sind u.a. im Beitrag http://www.pro-linux.de/artikel/2/909/der-basic-calculator-bc.html zu finden.

Abbildung 36 Aufruf und Ausgabe Shell-Script scale.sh

3.2.1.3. Integritätstest von Dateien

Für den Test der Unversehrtheit (Integrität) von Dateien werden gern kryptographische Hash-Algorithmen eingesetzt. Linux bietet hier in den meisten Distributionen den MD5 (Message-Digest Algorithm 5) bzw. SHA1 (Secure Hash Algorithm 1) an. Beide Algorithmen berechnen aus beliebigen Dateien einen 128-bit-bzw. 160-bit-Hashwert (Prüfsumme). OpenWRT stellt MD5 zur Verfügung.

Ein verbreiteter Einsatz dieser Algorithmen findet sich beim Dateidownload von einem Fileserver über das Internet. Die Prüfsumme der originalen Datei wird auf dem Server zur Verfügung gestellt und nach dem Download kann die betreffende Prüfsumme erneut berechnet und verglichen werden. Sind die Prüfsummen identisch, dann ist die heruntergeladene Datei unversehrt und der Download war erfolgreich.

Abbildung 37 zeigt den Aufruf des MD5-Algorithmus zur Erzeugung der betreffenden Prüfsumme des Scripts boardinfo.sh (als Beispiel) und die Speicherung der ermittelten Prüfsumme in der Datei boardinfo.md5. Die Ausgabe der ermittelten Prüfsumme erfolgt mit cat boardinfo.md5. Der Check der ermittelten Prüfsumme erfolgt dann mit md5sum -c boardinfo.md5.

Außerdem wird gezeigt, wie eine korrupte Datei erkannt werden kann. Um eine Verletzung der Integrität zu demonstrieren, wird der Datei boardinfo.sh ein Leerzeichen hinzugefügt. Der Test der Prüfsumme weist nun auf einen Fehler hin, da die beim Test berechnete Prüfsumme nicht mit der in der Datei boardinfo.md5 abgespeicherten Prüfsumme der unversehrten Datei boardinfo.sh übereinstimmt. An der Funktionsweise des Shell-Scripts boardinfo.sh ändert das hinzugefügte Leerzeichen nichts.

Abbildung 37 md5sum im Einsatz

3.2.1.4. Cronjobs

Cron ist ein Daemon, mit dessen Hilfe bestimmte Vorgänge zu definierten Zeitpunkten automatisch ausgeführt werden können. Diese Vorgänge können einzelne Befehle, Shell-Scripts, Programme, PHP- und sonstige Scripts sein.

Beispielsweise werden Backups, die täglich oder sogar stündlich geschehen sollen meist per Cronjob ausgeführt. Eine sehr gute Einführung zu Cronjobs ist unter [10] zu finden.

Wir wollen den Mechanismus der Cronjobs an Hand eines einfachen Beispiels betrachten. Über das Kommando uptime kann die Laufzeit des Systems nach dem letzten Bootvorgang und die Systemauslastung ausgegeben werden, wodurch Rückschlüsse auf das Systemverhalten möglich sind. Mit diesem Kommando kann ein einfacher Shell-Script cronscript.sh erstellt werden, welcher die Ausgabe von uptime in ein Logfile cron.log schreibt (Listing 4).

Damit die jeweils aktuelle Ausgabe an das File angehängt wird, muss für die Umleitung in das File die Zeichenfolge „>>“ verwendet werden. Begnügt man sich mit „>>“, dann wird der alte Inhalt des Files stets überschrieben und man hätte immer nur den letzten Eintrag zur Verfügung.

#! /bin/sh
uptime » $HOME/cron.log
exit 0

Listing 4 Shell-Script cronscript.sh

Nach dem das eben erstellte Script ausführbar gemacht ist, kann er von der Kommandozeile aufgerufen werden.

# chmod +x cronscript.sh

# ./cronscript.sh

Wir wollen diesen Vorgang allerdings hier automatisieren und den Script cronscript.sh jeder vollen Stunde ausführen.

Hierzu bedient man sich einer Tabelle, die Crontab genannt wird und unter /etc/crontabs/root abgelegt ist. Die einzelnen Cronjobs werden da definiert und konfiguriert. Die Tabelle enthält pro Zeile den Zeitpunkt und die Befehlsfolge, die ausgeführt werden soll.

Wir erzeugen uns diese Datei durch

# touch /etc/crontabs/root

Die eigentliche Cronjob Definition erfolgt nun nach dem folgenden Format:

Eine Kommentarzeile oder ein Leerzeichen beschließen die Crontab. Abbildung 38 zeigt die hier erstellte Crontab. Weitere Details sind der Cron Man Page (Hilfe zu cron) zu entnehmen.

Abbildung 38 Eintragung in der Crontab

Um nun Cron zur Bootzeit zu starten, erzeugen wir noch einen Initialisierung-Script über

# touch /etc/init.d/S50cron
mit dem Inhalt gemäß Listing 5.

#!/bin/sh

# start crond

/etc/init.d/start

/etc/init.d/enable

Listing 5 Shell-Script S50cron

Auch dieses Script wird ausführbar gemacht und von der Kommandozeile gestartet.

# chmod +x /etc/init.d/S50cron

# /etc/init.d/S50cron

Ob crond erfolgreich gestartet wurde, kann nun durch Aufruf von logread gemäß Abbildung 39 überprüft werden.

Abbildung 39 Crond gestartet?

Wenn Änderungen an der Crontab vorgenommen wurden, dann muss ein Restart erfolgen, der in der Form

# killall crond

# /etc/init.d/S50cron
vorgenommen werden kann.

3.2.1.5. USB-Webcam steuern mit fswebcam

Als Webcam wird in der Regel eine einfache Kamera bezeichnet, die über USB mit einem Rechner verbunden wird. An vielen Stellen werden diese Webcams durch definierte Ereignisse getriggert (ausgelöst) oder senden einen Videostream. In die Bilder können außerdem zusätzliche Textinformationen eingeblendet werden.

USB-Webcams sind heute in einer großen Typenvielfalt zu haben. Trotz der Vielzahl vorhandener Treiber kann es da zu unliebsamen Inkompatibilitäten kommen, zumal die Angaben zur Installation unter Linux bei den Kameras häufig fehlen.

fswebcam ist eine einfache Webcam-Applikation, mit der Bilder ausgelöst und von einer Webcam abgerufen werden können. Die Bilder können als PNG- oder JPG-File abgespeichert werden (http://www.firestorm.cx/fswebcam/).

Ich habe hier mit einer USB-Webcam C270 von Logitech experimentiert, die an den USB-Port des Arduino Yún angeschlossen wurde.

Zuvor wurde der Messagebuffer mit

$ sudo dmesg –c
gelöscht, um die Mitteilungen beim Einstecken der USB-Webcam einfacher sichtbar zu machen. Abbildung 40 zeigt die Installationsmitteilungen nach Aufruf der Kommandos dmesg und lsusb.

Abbildung 40 Installation einer USB Webcam

Das erste Kommando zeigt an, dass eine Kamera gefunden wurde und der Treiber UVC zugeordnet wurde.

In der Ausgabe des zweiten Kommandos kann man sehen, dass es sich beim gefunden USB-Device (mit der Device No. 004) um eine Logitech Webcam C270 handelt.

Zum Test der installierten USB-Webcam installieren wir das Paket fswebcam. Mit dem Aufruf fswebcam wird hier ein Bild ausgelöst und in der Datei webcamtest.jpg abgespeichert.

$ opkg install fswebcam

$ fswebcam -v -S 1 -r 1280x960 -d /dev/videoO -v /webcamtest. jpg

Abbildung 41 zeigt den Aufruf des Programms fswebcam zur Auslösung der Webcam.

Zur Anzeige des aufgenommenen Bildes muss dieses vom Arduino Yún beispielsweise auf den Entwicklungs-PC im Netzwerk heruntergeladen werden, bevor es mit einem Bildbetrachter, wie Paint o.a. betrachtet werden kann.

Abbildung 41 Auslösen der Webcam

Die Konfigurationsdaten der Kamera lassen sich in einem separaten Konfigurationsfile abgelegen, so dass sich der Aufruf des Programms fswebcam weniger komplex gestaltet. Mit einem Editor wird die Datei fswebcam.cfg gemäß Abbildung 42 erstellt.

Abbildung 42 Konfiguration der Webcam

Die Einträge in der Datei fswebcam.cfg bedeuten dabei folgendes.

Die ersten beiden Einträge adressieren die angeschlossene Webcam und werden auch als Default-Einstellungen verwendet.

Der Parameter skip l bewirkt, dass der erste Frame übersprungen und erst der zweite abgespeichert wird. Diese Option ist immer dann hilfreich, wenn der erste Frame noch Störungen o.ä. aufweist.

Mit dem Parameter resolution kann die Auflösung der Webcam vorgegeben werden.

Der Parameter jpeg beeinflusst die Kompressionsrate des JPG-Bildes und damit auch die Qualität des Bildes. Mit 95 wird das Bild nahezu verlustfrei komprimiert.

Der Parameter save gibt schlussendlich noch Pfad und Dateinamen an, wo das Bild abgelegt wird.

Es gibt zahlreiche weitere Konfigurationsparameter, die aber unter man fswebcam abgefragt werden müssen.

Abbildung 43 zeigt den Aufruf des Programms fswebcam -c fswebcam. cfg zur Auslösung der Webcam.

Abbildung 43 Auslösen der Webcam mit Konfigurationsfile

Wenn wir mit der Webcam periodisch Bilder aufnehmen, dann ist ein Bezug zum Aufnahmedatum meist von Interesse. Ich möchte hier beispielsweise Datum und Uhrzeit der Aufnahme mit im Dateinamen unterbringen.

Die ursprünglich als webcamtest.jpg abgespeicherte Bilddatei wird einen Dateinamen in der Form webcamtest_YYYYMMDD-HHMM.jpg (also z.B. webcamtest_20140208-1947.jpg) erhalten. Mit dem Shell-Script tr_image.sh (Abbildung 44) wird nach Ausgabe einer Mitteilung ein Bild ausgelöst und abgespeichert und anschließend durch einen Kopiervorgang mit Datum und Uhrzeit der Aufnahme versehen.

Abbildung 44 Shell Script tr_image.sh

Abbildung 45 zeigt nun den Aufruf des Shell Scripts tr_image.sh nach dem dieser mittels chmod +x tr_image. sh ausführbar gemacht wurde.

Abbildung 45 Auslösen der Webcam und Datieren des Imagefiles

Von der Webcam wird das aktuelle Bild hier immer als Datei webcamtest.jpg abgelegt. Durch den Kopiervorgang entstehen die datierten Imagefiles. Die Datei webcamtest.jpg ist damit immer mit der neuesten datierten Datei identisch. Anhand der Dateigrößen in Abbildung 46 kann man das leicht nachvollziehen.

Abbildung 46 Datierte Imagefiles

Nutzt man die Webcam für periodische Aufnahmen, dann können schnell umfangreiche Daten entstehen, die den Arduino Yún speichermäßig überfordern. Hier kann ein angeschlossener Memory-Stick Abhilfe schaffen oder man schickt die Daten sofort in einen Cloud-Speicher.

3.2.1.6. USB-Memory-Stick

Der vorhandene USB-Anschluss kann auch zur Speichererweiterung mit einem Memory-Stick genutzt werden. Da nur ein USB-Anschluss am Arduino Yún vorhanden ist, hilft bei Verwendung von USB-Webcam und USB-Memory-Stick ein zwischengeschalteter USB-Hub.

Folgende Pakete werden zur Installation benötigt, die ggf. nachinstalliert werden müssen:

- kmod-usb-storage – Kernelmodul, welches USB-Massenspeicher unterstützt

- kmod-fs-<file_system> – Kernelmodule, die bestimmte Filesysteme unterstützen (kmod-fs-ext4, kmod-fs-hfs, kmod-fs-hfsplus, kmod-fs-ntfs, kmod-fs-reiserfs, kmod-fs-vfat)

- block-mount – Scripts zum Mounting und Check von Block Devices

Die Installation wird folgendermaßen vorgenommen:

# opkg update

# opkg install kmod-usb-storage block-mount block-hotplug kmod-fs-ext4 kmod-fs-vfat kmod-nls-cp437 kmodnls-iso8859-1

# mkdir -p /media/usb

# mount -t vfat /dev/sdb1 /media/usb

Nach einem Update werden die gewünschten Kernelmodule installiert und das Verzeichnis /media/usb erzeugt. Schließlich kann der erkannte USB-Memory-Stick gemountet werden.

Abbildung 47 zeigt, dass der eingesteckte USB-Stick als sdb1 erkannt wurde. Da hier gleichzeitig mit einer SD-Card gearbeitet wird, wurde dieser bereits sda1 vergeben. Das Kommando ls /dev/sd* zeigt uns auch die beiden Speichererweiterungen.

Abbildung 47 Detektion eines USB-Memory-Sticks

Der Zugriff auf unseren USB-Memory-Stick erfolgt nun über den Pfad /media/usb, wie uns Abbildung 48 zeigt.

Als erstes habe ich die Datei test.txt dort erzeugt und zwei Zeilen Text in diese Datei geschrieben. Danach habe ich Webcam-Bilder aus dem Verzeichnis /home/images/ nach /media/usb kopiert und schließlich das Verzeichnis noch zur Anzeige gebracht.

Möchte man den Memory-Stick entfernen, dann sollte dies über unmount /media/usb erfolgen.

Abbildung 48 Dateizugriff Memory-Stick

Mit diesen durch den USB-Memory-Stick hinzugewonnenen Speichermöglichkeiten kann das Shell-Script tr_image.sh erweitert werden (Listing 6). Durch Aufruf des Scripts in der Form

# ./tr_image1.sh USB
wird das aufgenommene Bild in das Verzeichnis /media/usb kopiert und belastet damit nicht mehr die Ressourcen des Arduino Yún. Wird in der Kommandozeile kein Parameter übergeben, dann ist das Verhalten des Scripts unverändert.

#!/bin/sh

DATE_="$(date)"

echo -n "$DATE_"

echo " – Trigger image and save…"

fswebcam -c fswebcam.cfg
case $1 in

USB) echo "Save image on /media/usb/"

cp /home/images/webcamtest.jpg /media/usb/webcamtest_$(date +%Y%m%d-%H%M).jpg

;;

*) echo -n "Save image on "

pwd
rm /home/images/webcamtest_*.jpg
cp /home/images/webcamtest.jpg /home/images/webcamtest_$(date +%Y%m%d-%H%M).jpg
esac

Listing 6 Shell-Script tr_image1.sh

3.2.2 Python

3.2.2.1. Pseudo-Zufallszahlen

Zufallszahlen benötigt man in den unterschiedlichsten Bereichen der Informatik. Für unsere Belange hier sind vor allem die Simulation von Sensorsignalen sowie der Test von Algorithmen von Interesse.

Nahezu jede Programmiersprache bietet mehr oder minder gute Pseudo-Zufallszahlengeneratoren. Da es sich nicht um echte Zufallszahlen handelt, die von einem stochastischen Prozess abgeleitet wurden, spricht man von Pseudo-Zufallszahlen.

Im Python-Script RandomNumbers.py (Listing 7) werden 100 Pseudo-Zufallszahlen im Bereich von 0 bis 100 erzeugt und in einem CSV-File (comma separated values) randomnunbers.txt abgespeichert.

Neben der Erzeugung einer Zufallszahl durch die Anweisung r = random, randint (0, 100) ist hier auch die Handhabung von Files unter Python zu sehen.

Um einen einführenden Text in das File zu schreiben, wird das File im Mode w(rite) geöffnet, d.h. neu angelegt. Um später die Zufallszahlen in diesem File abzuspeichern, wird es im Mode a(ppend) geöffnet, d.h. die Daten werden an das File „angehängt“. Durch das Format „%d, “ wird dafür gesorgt, dass nach der Zahl ein Komma und ein Leerzeichen abgespeichert werden.

#RandomNumbers.py
import random
random.random( )

print('Generate 100 Random Numbers in Range (0,100) > randomnumbers.txt')

file = open('randomnumbers.txt', 'w')

file.write('100 Random Numbers in Range (0, 100)\n')

file.close()

#file = open('randomnumbers.txt').readlines()

#print file
for i in range(l,100):

r = random.randint(0, 100)

# print ('%d ' % r)

file = open('randomnumbers.txt', 'a')

file.write('%d,' % r)

file.close()

#file = open('randomnumbers.txt').readlines()

#print file

Listing 7 Python-Script RandomNumbers.py

Abbildung 49 zeigt Aufruf und Ausgabe des Python-Scripts RandomNumbers.py.

Abbildung 49 Aufruf und Ausgabe Python-Script RandomNumbers.py

Um die erzeugten Pseudo-Zufallszahlen visualisieren zu können, kann das Textfile auf dem Entwicklungs-PC mit einer Tabellenkalkulation geöffnet werden. Hier erfolgt das mit Hilfe von Microsoft Excel, wie Abbildung 50 bis Abbildung 52 zeigen. Die Dialogtexte in den Abbildungen lassen weitere Erläuterungen überflüssig erscheinen. Bei anderen Tabellenkalkulationen ist die Vorgehensweise vergleichbar.

Abbildung 50 Textkonvertierung beim CSV-File mit Excel (1)

Abbildung 51 Textkonvertierung beim CSV-File mit Excel (2)

Abbildung 52 Textkonvertierung beim CSV-File mit Excel (3)

Zur Visualisierung bleibt nun nur noch die grafische Darstellung der Pseudo-Zufallszahlen, die in Abbildung 53 gezeigt ist.

Abbildung 53 Generierte Pseudo-Zufallszahlen

3.2.2.2. Bildverarbeitung

Die Python Imaging Library (PIL) ist eine freie Library für Python und bietet Support zur Bearbeitung zahlreicher Bilddateiformate.

Die Python Imaging Library unterstützt zahlreiche Standardverfahren zur Bildverarbeitung, wie

- pixelbezogene Manipulationen

- Maskierungen

- Filter (Weichzeichnen (blurring), Konturen verstärken (contouring), Glätten (smoothing), Kanten finden(edge finding))

- Bildverbesserung (Schärfen (sharpening), Helligkeit, Kontrast und Farben anpassen (adjusting brightness, contrast or color)

- Text einbetten (adding text to images) u.a.m.

Unterstützt werden verschieden Bilddatenformate, wie PPM, PNG, JPEG, GIF, TIFF und BMP.

Das Python Imaging Library Handbook (http://effbot.org/imagingbook/) erläutert die Verwendung der Library im Detail.

Die PIL wird durch das folgende Kommando nachinstalliert

# opkg install python-imaging-library

Das folgende Beispiel zeigt die Anwendung der PIL im Python-Interpreter (Abbildung 54).

Abbildung 54 Rotation ArduinoYun.jpg

Als erstes wird aus der PIL das Image Modul importiert bevor die Bilddatei ArduinoYun.jpg geöffnet werden kann. Die Methode rotate () erzeugt eine Bilddatei mit einem, um den angegebenen Winkel gegen den Uhrzeigersinn rotierten Bildinhalt. Diese Datei wird schließlich unter dem Namen ArduinoYun_45.jpg abgespeichert. In Abbildung 55 ist die Ausgangsdatei gezeigt, während Abbildung 56 das Ergebnis der Rotation des Bildinhalts zeigt.

Abbildung 55 ArduinoYun.jpg

Abbildung 56 ArduinoYun_45.jpg

Dieses sehr einfach gehaltene Beispiel soll verdeutlichen, wie einfach komplexe Aufgaben unter Verwendung geeigneter Bibliotheken gelöst werden können.

3.2.3 Lua

3.2.3.1. Datumsfunktionen

Listing 8 zeigt den Quelltext des Lua-Scripts date.lua und soll vor allem die Möglichkeiten der formatierten Ausgabe demonstrieren.

---------------------------------------------------------------------

-- Reads Date & Time from Linino (Atheros AR9331)

---------------------------------------------------------------------
io.write ("Date & Time from Linino:\n")

date = os.date ("%Y-%m-%d")

time = os.date ("%X")

io.write ("Today is "..date.." ..time.."\n")

Listing 8 Shell-Script date.lua

Abbildung 57 zeigt Aufruf und Ausgabe Lua-Scripts date.lua.

Abbildung 57 Aufruf und Ausgabe Lua-Script date.lua

3.2.3.2. Wifi-Info

Mit pretty-wifi-info.lua steht uns auf unserem Linino-System ein Lua-Script zur Verfügung, welches alle Wifi-relevanten Daten ausgibt (Listing 9).

Gesteuert durch die Funktion collect_wifi_info () werden durch die beiden Funktionen get_basic_net_info() und get_wifi_info() alle Daten über das aktuelle Netzwerk gesammelt. Eine Reihe von print ()-Anweisungen sorgt dann für die Ausgabe der gesammelten Eigenschaften. Abbildung 58 zeigt schließlich noch den Aufruf und die Ausgaben des Lua-Scripts pretty-wifi- info.lua.

#!/usr/bin/lua
local function get_basic_net_info(network, iface, accumulator)

local net = network:get_network(iface)

local device = net and net:get_interface()

if device then
accumulator["uptime"] = net:uptime()

accumulator("iface"] = device:name()

accumulator("mac”) = device:mac()

accumulator["rx_bytes"] = device:rx_bytes()

accumulator["tx_bytes"] = device:tx_bytes()

accumulator["ipaddrs"] = {}

for _, ipaddr in ipairs(device:ipaddrs()) do
accumulator.ipaddrs[#accumulator.ipaddrs + 1] = {
addr = ipaddr:host():string(),
netmask = ipaddr:mask():string()

}

end
end
end
local function get_wifi_info(network, iface, accumulator)

local net = network:get_wifinet(iface)

if net then
local dev = net:get device()

if dev then
accumulator["mode"] = net:active_mode()

accumulator["ssid"] = net:active_ssid()

accumulator["encryption"] = net:active_encryption()

accumulator["quality"] = net:signal_percent()

end
end
end
local function collect_wifi_info()

local network = require"luci.imodel.network". init()

local accumulator – {}

get_basic_net_info(network, "lan", accumulator)

get_wifi_info(network, "wlan0", accumulator)

return accumulator
end
local info = collect_wifi_info()

print("Current WiFi configuration")

if info.ssid then
print("SSID: " .. info.ssid)

end
if info.mode then
print("Mode: " .. info.mode)

end
if info.quality then
print("Signal: " .. info.quality .. "%")

end
if info.encryption then
print("Encryption method: " .. info.encryption)

end
if info.iface then
print("Interface name: " .. info.iface)

end
if info.uptime then
print("Active for: " .. math.floor(info.uptime / 60) .. " minutes")

end
if #info.ipaddrs < 0 then
print("IP address: " .. info.ipaddrs[1].addr .. "/" .. info.

ipaddrs[1].netmask)

end
if info.mac then
print("MAC address: " .. info.mac)

end
if info.rx_bytes and info.tx_bytes then
print("RX/TX: " .. math.floor(info.rx_bytes / 1024) .. "/" ..

math.floor(info.tx_bytes / 1024) .. " KBs")

end

Listing 9 Lua-Script pretty-wifi-info.lua

Abbildung 58 Aufruf und Ausgaben von pretty-wifi-info.lua

3.2.4 C

In den vergangenen Abschnitten haben wir verschiedene Anwendungsbeispiele betrachtet, die als Shell-, Lua- oder Python-Script erstellt worden waren. Auf den meisten Linux-Devices hat man außerdem den GNU-C-Compiler gcc zur Compilierung von Anwendungsprogrammen direkt auf dem Target zur Verfügung.

Das ist hier unter Linino (OpenWRT) nicht der Fall. Es braucht also in jedem Fall einen entsprechend ausgestatteten Entwicklungs-PC, der einen C/C++ Quelltext für unser Target compilieren kann. Hier soll auf einen weiterführenden Beitrag [12] verwiesen werden, da sonst der Rahmen dieser einführenden Betrachtungen gesprengt würde.

4. Mikrocontroller ATmega32U4
ln diesem Abschnitt sollen einige Arduino-Programme vorgestellt werden. Zuerst werden klassische Programme, ohne Anbindung an das Netz, aber mit der aktuellen Version der Arduino IDE 1.5.4 vorgestellt. Darauf folgen Programme, die die Bridge Library zur Kommunikation mit dem Atheros AR9331 nutzen.

4.1 Klassische Arduino-Entwicklung

Bei den eigenständigen Arduino-Programmen sind unter Einsatz der aktuellen Arduino IDE 1.5.4 Neuerungen zu berücksichtigen.

Seit November 2011 gibt es bereits die Arduino IDE Version 1.0, mit der einige Änderungen eingeführt wurden, die vor allem bei der Portierung älterer Arduino-Programme berücksichtigt werden müssen.

Die bisher verwendete Dateiendung .pde wurde zur deutlichen Abgrenzung von Processingdateien auf .ino geändert. Alte pde-Dateien werden durch IDEs ab 1.0 geöffnet, werden dann aber als ino-Datei abgespeichert. Der umgekehrte Weg funktioniert nicht.

Viele Arduino Libraries sind für IDE Versionen vor 1.0 geschrieben worden. Diese Libraries nutzen wiederum andere Libraries, die bei Bedarf eingefügt werden. Ab der IDE Version 1.0 wurden wiring.h, WProgram.h, WConstants.h und pins_arduino.h in Arduino.h zusammengefasst.

Dadurch empfiehlt es sich, folgenden Code in die Libraries einzutragen:

#if ARDUINO >= 100

#include "Arduino. h"

#else

#include "WProgram.h"

#endif

Diese Hinweise sollen an dieser Stelle genügen. Mehr Details zur Portierung sind u.a. in [3] zu finden.

Neben den Änderungen bzgl. der IDE gibt es auch hardwareseitige Änderungen durch den Einsatz des ATmega32U4 gegenüber den ATmega328 u.a. Abbildung 59 zeigt in Ermangelung eines offiziellen PinOuts des Arduino Yún derzeit (November 2013) ein sehr ordentliches inoffizielles (https://forum.sparkfun.com/viewtopic.php?f=32&t=36783).

Abbildung 59 PinOut Arduino Yún

Neben vielen Details ganz wichtig ist, dass die Leitungen des I^2C-Busses nicht mehr an A5 und A4 sondern an IO2 und IO3 bzw. eigenen Anschlüssen zu finden sind. Der SPI-Bus ist nur noch über den sechspoligen ICSP-Header (ICSP-Stiftleiste) zu erreichen. Beim Einsatz von Arduino-Shields ist diesen Änderungen unbedingt Beachtung zu schenken.

Aus diesem Grund wurde von der australischen Firma GorillaBuilderz das LeoShield (https://www.aorilladistribution.com.au/product/leoshield/) entwickelt, um ältere Shields an das neue Arduino Leonardo/Yún 10 Pin Mapping anzupassen

Ältere Shields wurden für den Arduino UNO, Duemilanove oder anderen Boards auf Basis des ATmega168/328 entwickelt und passen nicht mehr zu den ATme- ga32U4, die auf dem Arduino Leornardo und Yún eingesetzt sind. (Abbildung 60).

Abbildung 60 LeoShield

Mit Hilfe des LeoShields kann die große Auswahl an älteren Shields auch auf Arduino Leonardo und Yún eingesetzt werden. Im Allgemeinen ist dies ohne Code-Änderungen oder neue Bibliotheken möglich.

4.1.1 Hello World

Zur Inbetriebnahme einer neuen oder neu installierten Entwicklungsumgebung bedient man sich oft eines „Hello World”-Programms.

Bei einem Mikrocontroller hingegen zeigt eine blinkende LED und/oder eine Ausgabe auf einem Display, dass die Entwicklungsumgebung vollständig installiert ist, der Programmdownload funktioniert und das Programm auf dem Mikrocontroller auch noch fehlerfrei arbeitet und übernimmt damit die „Hello World“ – Funktion.

Listing 10 zeigt den Quelltext des Programms blink.ino. Die an Io13 angeschlossene LED wird für 20 ms eingeschaltet und für 2 s ausgeschaltet, gefolgt von der serielle Ausgabe des Zeichens „*“.

/*

Blink

Turns on an LED on for short time, then off for two seoonds, repeatedly.

This example code is in the public domain.

*/

// Pin 13 has an LED connected on most Arduino boards.

int led = 13;

// the setup routine runs once when you press reset:

void setup()

{

// initialize the digital pin as an output.

pirMode(led, OUTPUT);

// initialize serial port

Serial.begin(9600);

}

// the loop routine runs over and over again forever:

void loop()

{
digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)

delay(20); // wait for a second
digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
delay(2000); // wait for a second

Serial.write("*");

}

Listing 10 Quelltext blink.ino

4.1.2 Interruptgetriebene digitale Eingabe

Für die digitale Ein-/Ausgabe stehen die Funktionen digitalwrite () und digitalRead () zur Verfügung. Wenn wir Ereignisse von einem Tastendruck o.ä. ableiten wollen, dann müssen wir berücksichtigen, dass mechanische Kontakte prellen.

In den Arduino Tutorials (http:V/arduino.cc/en/Tutorial/Debounce) wird eine Tastenentprellung durch zeitlich nacheinander angeordnete Abfragen und deren Vergleich beschrieben. Die interruptgetriebene digitale Eingabe ist eine weitere Möglichkeit, die zusätzliche Verzögerungen vermeidet und den Programmablauf nur dann beeinflusst, wenn ein Schaltvorgang einen Interrupt auslöst. Die Inter- rupt-Service-Routine (ISR) behandelt diesen Interrupt und ändert den betreffenden Status.

Wir wollen hier die beiden externen Interrupts INT0 (IO3) und INT1 (IO2) zur Abfrage von zwei Tasten verwenden. Will man weitere Tasten abfragen, dann kann das mit Hilfe der Interrupts PCINTx erfolgen. In [4] ist die betreffende Vorgehensweise beschrieben.

Für die Behandlung der Interrupts INT0 und INT1 gibt es im Arduino-Sprachumfang bereits die Funktionen attachInterrupt (interrupt, function, mode) und detachInterrupt(interrupt, function, mode), die das Registerhandling verbergen.

Im Programmbeispiel Externallnterrupt.ino (Listing 11) wird die serielle Datenausgabe sowie der Schaltzustand der angeschlossenen LED durch die beiden Interrupts gesteuert.

//

// Title : External Interrupt

// Author : Claus Kuehnel

// Date : 2014-02-09

// Id : ExternalInterrupt.ino

// Version : Arduino Yún 1.5.4

// based on :

//

// DISCLAIMER:

// The author is in no way responsible for any problems or damage caused by

// using this code. Use at your own risk.

//

// LICENSE:

// This code is distributed under the GNU Public License

// which can be found at http://www.gnu.org/licenses/gpl.txt

//
const int pLED = 13; // LED at Pin13
const int pINT0 = 3; // INT0 at Pin3
const int pINT1 = 2; // INT1 at Pin2
volatile boolean iflag;
int idx = 0;
void setup()

{

Serial.begin(19200);
pinMode(pLED, OUTPUT);
pinMode(pINT0, INPUT);
digitalWrite(pINT0, HIGH); // Pullup active
pinMode(pINT1, INPUT);
digitalWrite(pINT1, HIGH); // Pullup active
delay(4000);
attachInterrupt(0, stop_serial, FALLING); // INT0 stops serial output

Serial.print("EICRA: "); Serial.println(EICRA, HEX);
attachInterrupt(1, resume_serial, FALLING); // INT1 resumes serial output

Serial.print("EICRA: "); Serial.println(EICRA, HEX);

Serial.println("Setup finished.");
resume_serial();

}

void loop()

{
if (iflag) Serial.println(idx); // iflag controls serial output
idx++;
delay(1000);

}

void stop_serial()

{
iflag = false;
digitalWrite(pLED, HIGH);

}

void resume_serial()

{
iflag = true;
digitalWrite(pLED, LOW);

}

Listing 11 Quelltext ExternalInterrupt.ino

Die Interrupts INT0 und INT1 sind fest mit den beiden Eingängen IO3 und IO2 des Arduino Yún verknüpft. Die betreffenden Pins werden als Konstanten vereinbart.

Im der Routine setup () werden diese beiden Pins als Eingang mit PullUp-Widerstand gesetzt. Mit dem Interrupt INT0 wird die Routine stop_serial () verknüpft, mit INT1 resume_serial (). Durch die Initialisierung ist der Global Interrupt bereits enabled, so dass das hier nicht explizit vorgenommen werden muss.

Das Register EICRA zeigt am Ende des Setups den Wert 0x0A, wodurch beide Eingänge auf eine fallende Flanke hin den entsprechenden Interrupt anfordern.

In der Hauptschleife loop() des Programmbeispiels wird ein Index hochgezählt. Die Ausgabe des Indexwertes kann durch INT0 gestoppt und durch INT1 wieder aufgenommen werden. Die angeschlossene LED signalisiert den jeweiligen Zustand.

Abbildung 61 zeigt die Terminalausgaben des Programmbeispiels. Zu Beginn wird die Initialisierung der involvierten Register ausgegeben. Beim Stand des Indexwertes von 3 wurde die Ausgabe unterbrochen. Bei der Fortsetzung der Ausgabe war der Indexwert bereits auf 9 erhöht.

Will man also durch eine Zustandsänderung durch Taster auslösen, dann bietet sich die hier gezeigte Interruptmethode an.

Abbildung 61 Terminalausgabe ExternalInterrupt.ino

4.1.3 Abfrage von Sensoren

Zur Bereitstellung von Informationen werden in vielen Fällen Sensoren abgefragt, die die erfassten Zustände in unterschiedlicher Weise repräsentieren.

In vielen Fällen wir das erfasste Signal als analoger Spannungswert zur Verfügung stehen und kann mit dem internen oder einem externen AD-Umsetzer in eine für den Arduino Yún bearbeitbare Form gewandelt werden.

Die Temperatursensoren der LM135-Serie stellen eine temperaturproportionale Ausgangsspannung von +10 mV/°K bereit. Mit einem dynamischen Innenwiderstand von weniger als 1 Ω arbeiten diese Sensoren in einem Strombereich von400 μA bis 5 mA praktisch ohne Genauigkeitsverlust. Eine Kalibrierung bei 25°C zeigt einen Fehler von typisch 1°C über einen Temperaturbereich von 100 grd (http://www.ti.com/lit/ds/symlink/lm135.pdf).

Die TMP35/TMP36/TMP37-Temperatursensoren weisen eine Ausgangsspannung, die proportional zur Celsius-Temperaturskala ist. Die Sensoren benötigen keine externe Kalibrierung, um Genauigkeiten von typisch ±1°C bei +25°C und ±2°C über einen Temperaturbereich von -40°C bis +125°C zu erreichen.

Durch eine Stromaufnahme von weniger als 50 μA (0.5 μA im Shut-Down) sowie eine niedrige Eigenerwärmung sind diese Sensoren für den Automotive Bereich qualifiziert.

Tabelle 3 zeigt die Ausgangscharakteristik der drei Sensoren. Die Ausgangsspannung des TMP35 ist direkt proportional zur Temperatur in 1/10 °C ohne Offset und damit für unsere Zwecke hier geradezu ideal (http://www.analog.com/static/imported-files/data_sheets/TMP35_36_37.pdf.

Sensor | Offset Voltage (V) | Output Voltage Scaling (mV/°C) | Output Voltage at 25°C (mV)
TMP35 | 0 | 10 | 250
TMP36 | 0.5 | 10 | 750
TMP37 | 0 | 20 | 500

Tabelle 3 TMP3x Output Characteristics

Die Temperatursensoren gibt es in unterschiedlichen Gehäusevarianten. Entscheidet man sich für das TO-92-Gehäuse, dann bekommt man sehr einfache Anschlussmöglichkeiten im experimentellen Umfeld. Tabelle 4 zeigt die Anschlussbedingungen für LM335 und TMP35.

Tabelle 4 Anschlussbedingungen LM335/TMP35

Kann man beim LM335 auf die Kalibrierung verzichten, dann bekommt man folgende Anschlussmöglichkeiten am Arduino Yún (Tabelle 5).

Hier werden die neben den analogen Eingängen liegenden Anschlüsse als digitaler Ausgang betrieben. Um den Sensor mit Spannung zu versorgen, wird der betreffende Ausgang eingeschaltet (HIGH) und um einen GND zur Verfügung zu stellen, wird der betreffende Ausgang ausgeschaltet (LOW).

Die dadurch erreichbaren Genauigkeiten der Temperaturmessung werden wegen der nicht idealen Eigenschaften dieser Art der Versorgung allerdings etwas reduziert.

| TMP35 | IO | LM335 | IO
A0 | Vs | DOUT, HIGH | | DOUT, HIGH *)
A1 | AOUT | AIN | Vs | AIN *)
A2 | GND | DOUT, LOW | GND | DOUT, LOW
A3 | | | |
A4 | | | |
A5 | | | |

*) Vs über 4.7 kΩ an +5V

Tabelle 5 Anschlussmöglichkeiten an der Buchsenleiste direkt

Im Programmbeispiel LM335A_test.ino (Listing 12) wurde von dieser Beschaltungsart kein Gebrauch gemacht. Der Anschluss Vs des Sensors wurde mit dem Eingang AIN0 und +5 V bzw. GND direkt verbunden.

Das Programmbeispiel selbst ist denkbar einfach. Nach der Initialisierung der seriellen Schnittstelle erfolgt in der Endlosschleife die Abfrage des AD-Umsetzers (Kanal AIN0) und die anschließender Skalierung des Messwertes und Korrektur des Offsets (CORR). Dann erfolgt die Ausgabe des Messwertes in K und nach Umrechnung (OFS) auch noch in °C. Nach einer Wartezeit von 3 sec wiederholt sich dieser Vorgang.

const int AIN = 0;
const int OFS = 273;
const int CORR = 29;
void setup()

{

Serial.begin (9600);

Serial.println ("starting");

}

void loop ()

{
int value = analogRead(AIN);
float temp = (value * 500.0/1024) – CORR;

Serial.print ("Kelvin: ");

Srial.print (temp); // get temperature in Kelvin

Serial.print ("\tCelsius: ");

Serial.println (temp – OFS); // get temperature in Celsius
delay (3000);

}

Listing 12 Quelltext LM335A_test.ino

Der DHT22 ist ein digitaler Temperatur- und Feuchtigkeitssensor. Die Temperatur wird von einem Thermistor gemessen, während die relative Feuchtigkeit über einen kapazitiven Feuchtigkeitssensor erfasst wird (Abbildung 62)(http://meteobox.tk/files/AM2301.pdf).

Abbildung 62 DHT22

Das Messergebnis wird digital über einen Pin ausgegeben. Das Interface ist sehr empfindlich gegenüber dem Timing, ist aber nicht zum Dallas 1-Wire-Protokoll kompatibel. Unter Verwendung der DHT-Sensor-Library von Adafruit (https://github.com/adafruit/DHT-sensor-library) gestaltet sich der Zugriff allerdings recht einfach, wie das folgende Programmbeispiel DHTtester.ino (Listing 13) zeigt.

Die nachstehenden Kennwerte sind bei Einsatz des DHT22 erreichbar:

- 2.5 mA max. Stromaufnahme während der Umsetzung

- Genauigkeit der Feuchtigkeitsmessung 2-5% bei 0-100% relativer Feuchte

- Genauigkeit der Temperaturmessung ± 0.5°C bei – 40 bis 80°C

- Erfassungsrate 0.5 Hz (eine Messung in 2 Sekunden)

- Spannungsversorgung 3-5 V DC

Die Beschaltung der Pins des DHT22 kann dem Quelltext des Programmbeispiels DHTtester.ino entnommen werden.

// Example testing sketch for various DHT humidity/temperature sensors

// Written by ladyada, public domain

// Modifications by Claus Kühnel 2014-01-25

#include <DHT.h>

// Pin 13 has an LED connected on most Arduino boards.

const int led = 13;

#define DHTPIN 2 // what pin we're connected to

// Uncomment whatever type you're using!

//#define DHTTYPE DHT11 // DHT 11

#define DHTTYPE DHT22 // DHT 22 (AM2302)

//#define DHTTYPE DHT21 // DHT 21 (AM2301)

// Connect pin 1 (on the left) of the sensor to +5V

// Connect pin 2 of the sensor to whatever your DHTPIN is

// Connect pin 4 (on the right) of the sensor to GROUND

// Connect a 10K resistor from pin 2 (data) to pin 1 (power) of the sensor

DHT dht (DHTPIN, DHTTYPE);
void setup() {

// initialize the digital pin as an output.

pinMode(led, OUTPUT);

// initialize serial interface

Serial.begin(9600);
delay(4000);

Serial.print("Test of DHT");

Serial.print(DHTTYPE);

Serial.println(" Sensor");
dht.begin();

}

void loop() {
digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)

// Reading temperature or humidity takes about 250 milliseconds!

// Sensor readings may also be up to 2 seconds 'old' (its a very slow sensor)

float h = dht.readHumidity();
float t = dht.readTemperature();
digitalWrite(led, LOW); // turn the LED off by making the voltage LOW

// check if returns are valid,

//if they are NaN (not a number) then something went wrong!

if (isnan(t) || isnan(h)) {

Serial.println("Failed to read from DHT");

} else {

Serial.print("Humidity: ");

Serial.print(h);

Serial.print(" %\t");

Serial.print("Temperature: ");

Serial.print(t);

Serial.println(" *C");

}

delay(1000);

}

Listing 13 Quelltext DHTtester.ino

Unter Zuhilfenahme der Library DHT gestaltet sich der Zugriff auf den Sensor DHT22 auch sehr unkompliziert. Der Zugriff auf den Sensor ist durch die Methoden dht. readHumidity () und dht. readTemperature () gekapselt. Beide Methoden geben das Abfrageergebnis als Gleitkommazahl (float) zurück. Die beiden Abfragen werden mit dem Einschalten einer LED begonnen und nach Vorliegen der Ergebnisse wird die LED wieder ausgeschaltet. Dann erfolgt die Ausgabe der relativen Feuchtigkeit in % und der Temperatur in °C über das serielle Interface.

4.1.4 Interner ADC und PWM als DAC

Auf dem Arduino Yún stehen nach Außen hin zwölf analoge Eingänge ADCO bis ADC5 und ADC8 bis ADC13 zur Verfügung.

Werden weniger analoge Eingänge benötigt, dann können die nicht benötigten Analogeingänge auch als GPIO (General Purpose I/O) verwendet werden. Abbildung 59 zeigte die Mehrfachbelegungen der Arduino-Anschlüsse in diesem Bereich.

Die analogen Eingänge sind wie alle anderen Pins auch mit zuschaltbaren PullUp-Widerständen versehen. Ein eingeschalteter PullUp-Widerstand beeinflusst aber die AD-Umsetzung, weshalb dieser beim Betrieb als analoger Eingang disabled sein muss. Ebenso sind Fehler zu erwarten, wenn der Anschluss vorher als digitaler Ausgang konfiguriert worden war.

Im folgenden Programmbeispiel adda.ino soll durch PWM eine Ausgangsspannung bereitgestellt werden, die durch ein nachgeschaltetes RC-Glied zu einer Gleichspannung geglättet wird. Diese Gleichspannung wird wiederum dem AD-Umsetzer zugeführt und das Ergebnis der AD-Umsetzung sollte dann den Wert des DA-Umsetzers repräsentieren. Abbildung 63 zeigt die betreffende Beschaltung von PWM-Ausgang und analogem Eingang bei einem Arduino 2009. Die Beschaltung kann beim Arduino Yún identisch erfolgen.

Abbildung 63 AD-DA-Umsetzung mit internen Ressourcen des Arduino

Die PWM Frequenz beträgt beim Arduino Yún ca. 500 Hz. Das RC-Glied (Tiefpass) sollte in der Praxis nach der folgenden Formel dimensioniert werden:

Wählt man die Zeitkonstante τ zu hoch, dann steigt die Einschwingzeit. Wählt man sie hingegen zu gering, dann ist die Filterwirkung zu gering.

Die gemäß Abbildung 63 gewählte Zeitkonstante von 47 ms liegt eher am unteren Ende, weshalb keine optimale Filterwirkung zu erwarten ist. Zum Nachweis des Prinzips der AD-Umsetzung soll das hier aber genügen.

Im Programmbeispiel adda.ino (Listing 14) wird in einer Endlosschleife mit ana- logwrite (AOUT, i) ein PWM Wert an I/O 9 gesetzt und dieser gefiltert über den Analogeingang AIN0 dem internen AD-Umsetzer zugeführt und nach eine Wartezeit von 1 sec (delay(1000)) über analogRead (AIN0) vom AD-Umsetzer ausgelesen.

Die restlichen Instruktionen dienen nur der seriellen Ausgabe bzw. der Konfiguration.

Eine Besonderheit gilt es noch zu beachten. Für die PWM wird der 8-Bit Timerl verwendet, weshalb hier nur Werte zwischen 0 und 255 gesetzt werden können. Der interne AD-Umsetzer weist aber eine Auflösung von 10-Bit auf, weshalb dessen Ergebnisse zwischen 0 und 1024 liegen. Bei der Berechnung der Abweichung ist der Faktor 4 deshalb berücksichtigt (ADC- 4DAC).

const int AOUT = 9; // IO9 ist PWM Ausgang
const int AIN0 = 0; // AIN0 ist Analogeingang
void setup()

{
pinMode(AOUT, OUTPUT); // PWM als Ausgang konfigurieren

Serial.begin(19200);

Serial.println("DAC\tADC\tADC-4DAC");

}

void loop()

{
int i, val;
for (i=0; i<256; i+=8)

{
analogWrite(AOUT, i); // PWM wird mit einem Wert zwischen 0 und 255 gesetzt
delay(1000);

Serial.print(i); // DAC Wert ausgeben

Serial.print("\t");
val = analogRead(AIN0); // Resultat der AD-Umsetzung von Kanal AIN0 lesen

Serial.print(val); // ADC Wert ausgeben

Serial.print("\t");

Serial.println(val – 4*i); // Abweichung berechnen und ausgeben

}

}

Listing 14 Quelltext adda.ino

Nach dem Start des Programms adda.ino kann die Ergebnisausgabe im Monitor betrachtet werden. Abbildung 64 zeigt die serielle Ausgabe der einzelnen Durchläufe. In der dritten Spalte ist die berechnete Abweichung ADC – 4*DAC dargestellt, die wegen der wenig idealen RC-Filterung hier keine typischen Werte für den internen AD-Umsetzer zeigen kann.

Abbildung 64 Ausgaben der AD-DA-Umsetzung

4.1.5 Interner ADC im Free Running Mode

Der interne AD-Umsetzer der Arduinos kann nicht nur im Single-Conversion Mode sondern auch im Free Running Mode betrieben werden. Für die Initialisierung des Free Running Modes und das Auslesen der Resultate der AD-Umsetzung muss man sich aber des direkten Registerzugriffs bedienen. Weitere Beispiele für Zugriffe auf Registerebene, wie sie auch bei der Nutzung von Interrupts erforderlich sind, sind in [4] zu finden.

Für den Betrieb des AD-Umsetzers sind mehrere Register zuständig. An dieser Stelle kann nur die vorgenommene Initialisierung betrachtet werden. Um alle Optionen zu untersuchen, muss man sich des umfangreichen Datenblatts des ATmega32U4 bedienen [5].

| 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0
ADCSRA | ADEN | ADSC | ADATE | ADIF | ADIE | ADPS2 | ADPS1 | ADPS0

Im Register ADCSRA wird der AD-Umsetzer enabled (ADEN), eine (die erste) AD-Umsetzung gestartet (ADSC) und der für den Free Running Mode notwendige Autotrigger enabled (ADATE). Mit den Bits ADPS2-ADPS0 wird der Prescaler für den ADC-Clock eingestellt.

Um eine maximale Auflösung des AD-Umsetzers zu erreichen, sollte die interne Schaltung mit einem ADC-Clock zwischen 50 und 200 kHz betrieben werden. Werden die Prescalerbits alle gesetzt, dann wird aus dem 16 MHz Systemclock durch einen Teiler von 128 ein ADC-Clock von 125 kHz eingestellt.

Aus dem Timing Diagram (Abbildung 65) kann man sehen, dass nach 13 Taktzyklen die AD-Umsetzung abgeschlossen ist und bei diesem Prescaler somit eine Umsetzzeit von ca. 100 ps erreicht wird.

Abbildung 65 Timing Diagram Free Running Mode

| 7 | 6 | 5 | 4 | 3 | 2 | 1 | 0
ADMUX | REFS1 | REFSO | ADLAR | MUX4 | MUX3 | MUX2 | MUX1 | MUXO

Über das Register ADMUX kann die analoge Referenzspannung (REFS1, REFSO) selektiert werden. Wir arbeiten hier mit AVcc = 2.56 V als Referenzspannung. Das Datenformat kann linksbündig oder rechtsbündig eingestellt werden (ADLAR) und der Analog-Multiplexer wird über die Bits MUX4-MUX0 eingestellt. Im Register ADCSRB befindet sich noch das Bit MUX5, welches bei einigen Einstellungen, wie der Funktion setADC (), berücksichtigt werden muss (Tabelle 6).

MUX5-0 | Single Ended Input
000000 | ADC0
000001 | ADC1
000100 | ADC4
000101 | ADC5
000110 | ADC6
000111 | ADC7
011110 | 1.1 V (Band Gap)
011111 | 0 V (GND)
100000 | ADC8
100001 | ADC9
100010 | ADC10
100011 | ADC11
100100 | ADC12
100101 | ADC13
100111 | Temperature Sensor

Tabelle 6 Multiplexereinstellung Single Ended Input

Wie Tabelle 6 zeigt, sind die analogen Eingänge nicht auf die herausgeführten Eingänge ADCx beschränkt. Für die Inbetriebnahme noch interessant, sind die interne Bandgap-Referenz, der interne Ground und der Temperatursensor. Diese werden im Programmbeispiel auch als bekannte Eingangsspannungen abgefragt.

Das Setup der beiden Register kann am Einfachsten aus dem Quelltext des Programmbeispiels free_running_adc.ino (Listing 15) entnommen werden.

//

// Title : Interner ADC im Free Running Mode

// Author : Claus Kühnel

// Date : 2013-09-18

// Id : free_running_adc.ino

// Version : 1.5.4

// Micro : Arduino Yún

//

// DISCLAIMER:

// The author is in no way responsible for any problems or damage caused by

// using this code. Use at your own risk.

//

// LICENSE:

// This code is distributed under the GNU Public License

// which can be found at http://www.gnu.org/licenses/gpl.txt

//

// ----------------------------------------------------------------------------

//

// ADMUX with internal 2.56 V VREF

#define ADC0 0xC0

#define ADC1 0xC1

#define ADC4 0xC4

#define ADC5 0xC5

#define BANDGAP 0xDE

#define GND 0xDF

#define TEMP 0xC7
const int T1 = 25; // °C
const int C1 = 313; // ADC count @ 25°C

// ADCSRA

#define FREE_RUNNING_MODE ((1<<ADEN), | (1<<ADSC) | (1<<ADATE) | (1<<ADPS2) |

(1<<ADPS1) | (1<<ADPS0))

#define PURPOSE "Test of Free Running ADC"

const byte LED = 13;
word adc_value;
void setADC(byte config)

{

ADCSRA &= ~(1<<ADEN);

ADMUX = config;

ADCSRA = FREE_RUNNING_MODE;
if (config==TEMP)

ADCSRB | = (1<<MUX5);
else

ADCSRB &= ~(1<<MUX5);

}

word getADC(void)

{
return (ADCL | (ADCH << 8));

}

void printResult(void)

{
digitalWrite(LED, 1); // LED ein
delay(100);
adc_value = getADC();
digitalWrite(LED, 0); // LED aus

Serial.print(adc_value, HEX); // ADC Wert ausgeben

Serial.print("\t");

Serial.print((float) adc_value*2.56/1023); // Spannungswert berechnen und ausgeben

Serial.println(" V");

}

void setup()

{
delay(2000);
pinMode(LED, OUTPUT);

Serial.begin(9600);
delay(4000);

Serial.println(PURPOSE);

}

void loop()

{

Serial.print("Bandgap-Referenz ");
setADC(BANDGAP);
printResult();

Serial.print("GND ");
setADC(GND);
printResult();

Serial.print("Temperature ");
setADC(TEMP);
printResult();

Serial.print(" Temperature approx. ");

Serial.print(adc_value-C1+T1);

Serial.print(" grd C\n");
delay(2000);

}

Listing 15 Quelltext free_running_adc.ino

In einer Reihe von Defines werden die unterschiedlichen Initialisierungen der ADC-Register festgehalten. Die Funktion setADC () dient der Konfiguration des Analog-Multiplexers gemäß Tabelle 6. Bevor der Multiplexer gesetzt oder verändert wird, erfolgt ein Disable des AD-Umsetzers. Nach der Konfiguration wird dann der ADC wieder enabled und die erste AD-Umsetzung gestartet. Nach diesem Start läuft der ADC dann im Free Running Mode, d.h. nach einer AD-Umsetzung wird das Ergebnis der Umsetzung in die Register ADCH und ADCL geschrieben und eine neue Umsetzung gestartet. Die beiden Register können dann, wie in der Funktion getADC () vorgenommen, in der Reihenfolge ADCL gefolgt von ADCH gelesen werden.

In der Hauptschleife loop() werden nacheinander die Eingänge Bandgap Reference, Ground (GND) und Temperatur Sensor abgefragt und ausgegeben.

Um zuverlässige Messwerte vom internen Temperatursensor zu erhalten, muss dieser kalibriert werden. Hier wurde nur ein sehr einfacher Offsetabgleich vorgenommen. Um die Genauigkeit der Temperaturmessung zu steigern, ist eine komplexere Kalibrierung erforderlich. Beschrieben sind diese beispielsweise in [6] und [7].

Die Ausgabe des Ergebnisses der AD-Umsetzung erfolgt in der Funktion printResult (). Abbildung 66 zeigt die Ausgaben des Programmbeispiels.

Abbildung 66 Ausgaben des Programms free_running_adc.ino

4.1.6 AD/DA-Module PCF8591

Der Arduino Yún hat selbst einen 12-kanaligen 10-Bit ADC, der sich aber teilweise die Pins mit der digitalen IO teilen muss. Ein externes AD/DA-Subsystem kann für einfache Aufgaben hier Entlastung bieten.

Der PCF8591 (http://www.nxp.com/documents/data sheet/PCF8591.pdf) ist ein einfaches 8-Bit-AD/DA-Modul mit vier analogen Eingängen und einem analogen Ausgang, welches über ein I^2C-Interface verfügt.

Abbildung 67 zeigt das kompakte Modul mit Potentiometer zur Analogeingabe, Temperatur- und Lichtsensor, sowie einer LED am Analogausgang. Durch Jumper können Sensoren und LED vom PCF8591 auch getrennt werden, so dass die Anschlüsse im Bedarfsfall zur freien Verwendung zur Verfügung stehen.

Abbildung 67 PCF8591 Module

Das Modul verfügt über drei Adressleitungen, wodurch bis zu acht dieser Module am I^2C-BUS betrieben werden können.

In Übereinstimmung mit den I^2C-Spezifikationen hat der PCF8591 eine 7-Bit Slaveadresse. Die oberen 4 Bit sind intern festgelegt, während die unteren drei Bits durch die Belegung der Adresspins A2-A0 bestimmt werden. Somit ergibt sich je nach Belegung der Bits A2-A0 ein Adressbereich von 72 (0x48) bis 79 (0x4F).

1 | 0 | 0 | 1 | A2 | A1 | A0
MSB | LSB

Per default liegen die Adresspins beim Modul auf GND, wodurch folglich im Programmbeispiel PCF8591_Moduletest.ino (Listing 16) die Deviceadresse 72 verwendet wird.

Die Ansteuerung des I^2C-Busses ist in der Wire-Library gekapselt, die deshalb zu Beginn über #include <Wire.h> eingebunden wird. In der Funktion setup () werden Wire und Serial initialisiert.

In der Endlosschleife loop() erfolgt nun über readWire (72, channel) die Abfrage von Potentiometer, Temperatursensor und Fotowiderstand mit anschließender Ausgabe der ermittelten Werte.

Als letzte Aktion folgt über writeWire(72, Aout) die Ausgabe eines Analogwertes Aout, der bei jedem Schleifendurchlauf um 10 erhöht wird solange er unter 250 ist. Nach einer Wartezeit von 100 ms beginnt der nächste Schleifendurchlauf.

Die Funktionen readWire () und writeWire () realisieren das I^2C-Bus-Protokoll gemäß Datenblatt. In der Funktion readWire () werden vom PCF8591 insgesamt sechs Byte angefordert. Das richtige Ergebnis steht mit dem zweiten Byte bereits zur Verfügung.

Die sich treppenförmig ändernde Ausgangsspannung kann am Anschluss OUT mit einem Multimeter oder bei gestecktem Jumper an Hand der wechselnden Helligkeit der angeschlossenen LED verfolgt werden.

#include <Wire.h>
void setup()

{

Wire.begin();

Serial.begin(9600);

}

int Aout = 0;
void loop()

{
int pot = readWire(72,0x41);
int temp = readWire(72,0x42);
int light = readWire(72,0x43);

Serial.print(pot,DEC);

Serial.print("\t");

Serial.print(temp,DEC);

Serial.print("\t");

Serial.println(light,DEC);

if (Aout < 250) Aout += 10;
else Aout = 0;

writeWire(72,0x40,Aout);

delay(100);

}

int readWire(int device, int channel)

{
int retval;

Wire.beginTransmission(device);

Wire.write(channel);

Wire.endTransmission();

Wire.requestFrom(device, 6);

while (Wire.available()) {
retval = Wire.read();

}

return retval;

}

void writeWire(int device, int channel, int value)

{

Wire.beginTransmission(device);

Wire.write(channel);

Wire.write(value);

Wire.endTransmission();

}

Listing 16 Quelltext PCF8591 Moduletest.ino

4.1.7 LCD

Einfache Anzeigefunktionen können mit sehr preiswerten Text-LCDs umgesetzt werden, die mit verschiedenen Schnittstellen verfügbar sind. Für die hier vorgesehene Anzeigefunktion wird ein Text-LCD vom Typ LCD2041 (4 Zeilen á 20 Zeichen) mit I^2C-Bus-Interface eingesetzt. Abbildung 68 zeigt verschiedene Anzeigemöglichkeiten dieses recht komfortablen Text-LCDs.

Abbildung 68 Anzeigemöglichkeiten LCD2041 (Matrix Orbital)

Für die Ansteuerung des LCD2041 durch einen Arduino existiert die Library MatrixOrbitali2c, die von https://github.com/bkonosky/Arduino-Matrix-Orbital-i2clibrary heruntergeladen und im Verzeichnis Library installiert werden kann.

Auf die Kommandos soll hier nicht im Einzelnen eingegangen werden. Das Programmbeispiel LCD2041_Test.ino (Listing 17) zeigt die Verwendung der Kommandos. Weitere Details sind in den Library-Files zu finden.

Im setup () werden die Baudrate der serielle Schnittstelle (9600 Baud) und das LCD bzgl. Anzahl der Zeilen und Zeichen und des Kontrasts initialisiert. Der Kontrast kann Werte zwischen 0 und 255 einnehmen, wobei hohe Werte einen hohen Kontrast bedeuten. Die Default-Initialisierung nach dem Einschalten liegt bei 128.

In der Endlosschleife loop () werden nach dem Löschen des Displays nacheinander die vier Funktionen Textoutput (), BigDigits (), WideVBargraph () und HBargraph () aufgerufen.

In der Funktion Textoutput () kann man sehen, wie das Positionieren des Cursors und die Ausgabe von Text vorgenommen werden.

Mit der Funktion BigDigits () werden große Ziffern in der Anzeige positioniert, was für von weiten ablesbare Anzeigen eine Option sein kann.

Die Funktion wideVBargraph () ermöglicht einen vertikalen Bargraph (Balkendiagramm). Auf der Abszisse gibt es maximal 20 Positionen (20 Säulen) mit einer Höhe von maximal 32 Einheiten. Die anzuzeigenden Werte werden entsprechend skaliert. An geeigneter Stelle kann in diese Darstellung dann auch noch ein Text eingefügt werden.

Mit der Funktion HBargraph () wird ein maximal vier Säulen umfassender horizontaler Bargraph erzeugt. Hier beträgt die horizontale Auflösung 100 Einheiten.

//

// Title : Controlling LCD2041 via I2C

// Author : Claus Kühnel

// Date : 2013-10-08

// Id : LCD2041_Test.ino

// Version : 1.5.4

//

// DISCLAIMER:

// The author is in no way responsible for any problems or damage caused by

// using this code. Use at your own risk.

//

// LICENSE:

// This code is distributed under the GNU Public License

// which can be found at http://www.gnu.org/licenses/gpl.txt

//

#include <Wire.h>

#include <MatrixOrbitali2c.h>
const int LED = 13; // LED at Pin13

MatrixOrbitali2c lcd(0x5C >> 1);
void TextOutput()

{
lcd.home();
lcd.print("Arduino Yun");
lcd.setCursor(1,2);
lcd.print("writes text");
lcd.setCursor(1,3);
lcd.print("by I2C to LCD2041.");
lcd.setCursor(1,4);
lcd.print("www.arduino.cc");

}

void BigDigits()

{
byte pos = 2;
lcd.clear();
lcd.initLargeDigits();
for (int i=0; i<6; i++)

{
lcd.placeLargeDigit(pos,char(i));
pos=pos + 3;
delay(200);

}

}

void WideVBargraph()

{
lcd.clear();
lcd.initWideVertical();
for (int i=1; i<21; i++)

{
int j = i * 32;
j = j / 20;
lcd.drawVertical(i, j);
delay(10);

}

lcd.setCursor(1,1);
lcd.print("Bargraph");

}

void HBargraph()

{
lcd.clear();
lcd.initHorizontal();
lcd.drawHorizontal(1,1,0,100);
lcd.drawHorizontal(1,2,0,55);
lcd.drawHorizontal(1,3,0,27);
lcd.drawHorizontal(1,4,0,13);
lcd.setCursor(12,4);
lcd.print("Bargraph");

}

void setup()

{

Serial.begin(9600);
delay(4000);

Serial.println("LCD2041 SETUP");
lcd.begin(4,20); // 4 lines 20 characters
lcd.setContrast(180); // 0 – 255

}

void loop()

{
lcd.clear();

TextOutput();
delay(2000);

BigDigits();
delay(2000);

WideVBargraph();
delay(2000);

HBargraph();
delay(2000);

}

Listing 17 Quelltext LCD2041_Test.ino

Eine weitere Möglichkeit für ein solches LCD ist sein Einsatz als Debugging-Display. Das Programmbeispiel Debug_LCD.ino zeigt diese Möglichkeit (Listing 18).

//

// Title : Debugging LCD with I2C Interface

// Author : Claus Kühnei

// Date : 2013-10-08

// Id : Debug LCD.ino

// Version : 1.5.4

//

// DISCLAIMER:

// The author is in no way responsible for any problerns or damage caused by

// using this code. Use at yaur own risk.

//

// LICENSE:

// This code is distributed under the GNU Public License

// which can be found at http://www.gnu.org/licenses/gpl.txt

//

#include <Wire.h>

#include <MatrixOrbitali2c.h>

#define DEBUG 1
const int LED = 13; // LED at Pin13
unsigned int count = 65536;

MatrixOrbitali2c lod(0x5C »1);
void flash()

{
static boolean output – HIGH;

digitalWrite(LED, output);
output = !output;

}

void setup()

{

Serial.begin(9600);
delay(4000);

Serial.println("Application running ");
lcd.begin(4,20); // 4 lines 20 characters
lcd.setContrast(180); // 0 – 255
lcd.clear();
lcd.autoScroll();
lcd.lineWrap();

if (DEBUG) lcd.print("DEBUG LCD\n");
else lcd.print("No Debug Info");

}

void loop()

{
flash();
delay(200);
if (DEBUG)

{
lcd.print("Count = ");
lcd.print(count);
lcd.print("\n");
count++; }

}

Listing 18 Quelltext Debug_LCD.ino

Die Debugging-Ausgaben werden durch #define DEBUG l gesteuert. Setzt man DEBUG auf 0, dann werden die Debugging-Ausgaben unterdrückt.

Die Funktion flash() lässt hier die an IO13 angeschlossene LED blinken, steht aber für eine beliebige Funktion, die in der Hauptschleife loop () aufgerufen wird.

In der Funktion setup () werden wieder die Baudrate der seriellen Schnittstelle (9600 Baud) und das LCD initialisiert. Die Initialisierung des LCDs ist hier etwas umfangreicher, da noch die AutoScroll- und die LineWrap-Funktion aktiviert werden.

Bei eingeschaltetem Autoscroll wird der Anzeige nach dem Füllen der letzten Zeile wieder von oben begonnen. Das LineWrap bewirkt die Zeichenausgabe in der nächsten Zeile, wenn die vorangegangene gefüllt ist. Noch im setup () wird im Debug-LCD ausgegeben, ob das Debugging aktiviert ist oder nicht.

In der Hauptschleife wird die Funktion flash() aufgerufen gefolgt von einer kurzen Wartezeit (delay (200)), die die LED in jedem Zyklus umschaltet und somit zum Blinken bringt. Im Debug-Mode wird schließlich eine Countervariable angezeigt und incrementiert (hochgezählt). Diese Ausgabe hat natürlich an sich wenig Sinn, soll aber stellvertretend für eine Debugging-Ausgabe in der Hauptschleife stehen.

4.2 Bridge Library

We in Abschnitt 2.1 bereits beschrieben, weist der Arduino Yún zwei Prozessoren auf. Die Bridge Library sorgt dafür, dass der ATmega32U4 und der Atheros AR9331 nicht isoliert voneinander arbeiten müssen.

Die Bridge Library (http://arduino.ee/en/Reference/YunBridqeLibrarv) vereinfacht die Kommunikation zwischen den beiden Prozessoren. Sie wurde aus der Stream Library abgeleitet und viele der Methoden sind von der Serial Library her schon bekannt.

Bridge Kommandos vom ATmega32U4 werden auf dem Atheros AR9331 von Python interpretiert. Initiiert vom ATmega32U4 werden so Kommandos auf der Linux-Seite ausgeführt. Über Shared-Memory (gemeinsam genutzter Speicher) erfolgt der Austausch der Daten.

Die Bridge Library beinhaltet verschiedene Klassen, die in Tabelle 7 beschrieben sind. Die Anwendung der verschiedenen Klassen wird im Folgenden durch mehrere Programmbeispiele verdeutlicht.

Class | Beschreibung
Process | Process wird verwendet, um Prozesse auf dem Linux-Prozessor (Shell-Scripts etc.) zu starten.
Console | Console leitet die serielle Ausgabe der Arduino IDE auf den Linux-Prozessor um.

FilelO

FilelO bildet ein Interface zum Linino-Dateisystem und kann zum Lesen & Schreiben von Dateien von der/auf die SD-Karte verwendet werden.

HttpClient | HttpClient erstellt eine HTTP-Client auf Linino, erweitert Process und dient als Wrapper für cURL-Befehle.
Mallbox | Mailbox erstellt ein Kommunikationsinterface zwischen den beiden Prozessoren (ATmega32U4 und Atheros AR9331).
YunClient | YunClient stellt einen HTTP Client auf dem Arduino Yún zur Verfügung.
YunServer | YunServer stellt einen HTTP Server auf dem Arduino Yún zur Verfügung.

Temboo

Temboo stellt ein Interface zu Temboo.com zur Verfügung, wodurch eine einfache Verbindung zu verschiedenen Online-Tools möglich wird.

Spacebrew | Spacebrew ermöglicht die Verbindung von Komponenten über WebSockets.

Tabelle 7 Bestandteile der Bridge Library

4.2.1 Ausführen von Linux-Kommandos

Die Process Library kann verwendet werden, um vom ATmega32U4 aus Prozesse auf dem Atheros AR9331 zu starten.

Im Programmbeispiel process.ino (Listing 19) erfolgt in der Funktion runCurl () ein Download eines ASCII-Files von der URL http://arduino.cc/asciiloao.txt und in der Funktion runcpuInfo () der Aufruf des Kommandos cat /proc/cpuinfo.

Da beide Funktionen je nur einmal aufgerufen werden, wurden sie in der Funktion setup () platziert. Die Funktion loop () bleibt dementsprechend leer.

Das Muster für die Aufrufe der Methoden der Klasse Process ist dabei immer gleich. Mit p.begin ("command") wird das betreffende Linux-Kommando eingetragen, während mit p.addParameter ("parameter") das Kommando durch weitere Parameter ergänzt wird. Schließlich startet p. run () die Abarbeitung des übergebenen Linux-Kommandos. Die Antwort des Linux-Kommandos kann dann solange gelesen werden, wie die Bedingung p.available () > 0 wahr ist.

/*

Running process using Process class.

This sketch demonstrate how to run linux processes
using an Arduino Yún.

created 5 Jun 2013
by Cristian Maglie

This exanple code is in the public domain.

*/

#include <Process.h>
void setup()

{

// Initialize Bridge

Bridge.begin();

// Initialize Serial

Serial.begin(9600);

// Wait until a Serial Monitor is connected.

while (!Serial);

// run various example processes
runCurl();
runCpuInfo();

}

void loop()

{

// Do nothing here.

}

void runCurl()

{

// Launch "curl" comnand and get Arduino ascii art logo from the network

// curl is command line program for transferring data using different internet protocols

Process p; // Create a process and call it "p"

p.begin ("curl"); // Process that launch the "curl" command p.addParameter("http://arduino.cc/asciilogo.txt"); // Ad the URL parameter to "curl"

p.run (); // Run the process and wait for its termination

// Print arduino logo over the Serial

// A process output can be read with the stream methods
while (p.available()>0) {
char c = p.read();

Serial.print(c);

}

// Ensure the last bit of data is sent.

Serial.flush();
void runCpuInfo()

// Launch "cat /proc/cpuinfo" command (shows info on Atheros CPU)

// cat is a command line utility that shows the content of a file

Process p; // Create a process and call it "p"

p.begin("cat"); // Process that launch the "cat" command
p.addParameter("/proc/cpuinfo"); // Add the cpuinfo file path as parameter to cut
p.run(); // Run the process and wait for its termination

// Print command output on the Serial.

// A process output can be read with the stream methods
while (p.available()>0) {
char c = p.read();

Serial.print(c);

}

// Ensure the last bit of data is sent.

Serial.flush();

}

Listing 19 Quelltext process.ino

Der Filedownload wird durch das Kommando curl http://arduino.cc/asciilogo.txt initiiert. Abbildung 69 zeigt die Ausgabe des gelesenen Textfiles von der URL http://arduino.cc/asciilogo.txt. was durch einen Aufruf von einem Webbrowser aus verifiziert werden kann.

Abbildung 70 zeigt die Ausgabe der im File cpuinfo abgelegten Daten, wie sie durch das Linux-Kommando cat /proc/cpuinfo erzeugt werden kann.

Abbildung 69 Ausgabe der Funktion runCurl ()

Abbildung 70 Ausgabe der Funktion runCpuInfo()

cURL kann auch dazu verwendet werden, Mails von der Kommandozeile aus zu versenden. Im Programmbeispiel sendMail.ino wird ein Shell-Script sendmail.sh auf dem Atheros AR9331 unter Linino aufgerufen, der den betreffenden cURL-Aufruf aufweist. Abschnitt 3.1.7 behandelt den Shell-Script sendmail.sh, der mit Hilfe von Google Mail eMails versendet.

Listing 20 zeigt den Aufruf des Shell-Scripts sendmail.sh über das p.runShellCommand(command). Hier kann das gewünschte Kommando komplett eingetragen werden. Durch das anschließende while (p.running ()) wird der Abschluss des Linux-Kommandos abgewartet, bevor die Ausgabe des Kommandos ausgewertet wird.

//

// Title : Send Mail via cURL

// Author : Claus Kuehnel

// Date : 2013-10-19

// Id : sendMail.ino

// CPU : Arduino Yun

// Version : 1.5.4

//

// DISCLAIMER:

// The author is in no way responsible for any problems or damage caused by

// using this code. Use at your own risk.

//

// LICENSE:

// This code is distributed under the GNU Public License

// which can be found at http://www.gnu.org/licenses/gpl.txt

//

#include <Process.h>
void setup()

{

Bridge.begin(); // Initialize the Bridge

Serial.begin(9600); // Initialize the Serial

// Wait until a Serial Monitor is connected.

while(!Serial);

Serial.println("Sending Mail…");

Process p; // Create a process and call it "p"

p.runShellCommand("/$HOME/sendmail.sh"); // Call the shell script sendmail.sh
while(p.running());
while (p.available()>0)

{
char c = p.read();

Serial.print(c);

}

Serial.flush();

Serial.println("End.");

}

void loop()

{

// nothing to do

}

Listing 20 Quelltext sendMail.ino

Abbildung 71 zeigt die Ausgaben des Programms sendMail.ino. Die erste und die letzte Zeile der Ausgabe kommen vom ATmega32U4 aus Listing 20, während die zweite und dritte Zeile vom Shell-Script zurückgemeldet werden. Die empfangene eMail ist in Abbildung 72 gezeigt.

Abbildung 71 Ausgabe des Programms sendMail.ino

Abbildung 72 Empfangene Mail

Das Programmbeispiel runShellCommands.ino (Listing 21) zeigt, wie Lua- und Python-Skripte auf dem Atheros AR9331 unter Linino ausgeführt werden können. Hier werden die Scripts date.lua, zur formatierten Ausgabe von Datum und Uhrzeit, und RandomNumbers.py, zur Erzeugung von 100 Pseudo-Zufallszahlen zwischen 0 und 100 und Speichern ins File randomnumbers.txt, aufgerufen. Die Skripte selbst waren in den Abschnitten 3.2.3.1 und 3.2.2.1 schon näher betrachtet worden. Abbildung 73 zeigt die Ausgaben des Programmbeispiels runShellCommands.ino.

//

// Title : Running Shell Commands

// Author : Claus Kuehnel

// Date : 2013-10-18

// Id : runShellCommands.ino

// CPU : Arduino Yun

// Version : 1.5.4

//

// DISCLAIMER:

// The author is in no way responsible for any problems or damage caused by

// using this code. Use at your own risk.

//

// LICENSE:

// This code is distributed under the GNU Public License

// which can be found at http://www.gnu.org/licenses/gpl.txt

//

#include <Process.h>
unsigned int runShellCmd(const String &cmd)

{

Process p;

p.runShellCommand(cmd);
while(p.running());
while (p.available() > 0)

{
char c = p.read();

Serial.print(c);

}

Serial.flush();

}

void setup()

{

Bridge.begin(); // Initialize the Bridge

Serial.begin(9600); // Initialize the Serial

// Wait until a Serial Monitor is connected.

while(!Serial);

Serial.println("Running Shell Commands…");
runShellCmd("lua /$HOME/date.lua");

Serial.println();
runShellCmd("python /$HOME/RandomNumbers.py");

Serial.println();
runShellCmd("cat /$HOME/randomnumbers.txt");

Serial.println("\nEnd.");

}

void loop()

{

// nothing to do

}

Listing 21 Quelltext runShellCommands.ino

Abbildung 73 Ausgaben Programmbeispiel runShellCommands.ino

4.2.2 Dateien schreiben und lesen

Der Atheros AR9331 besitzt eine wesentlich bessere Ausstattung an Speicher als der ATmega32U4 und kann darüber hinaus durch eine SD-Card oder einen Memory-Stick auch noch erweitert werden. Deshalb ist es von Interesse, diesen Speicher auch von der Arduino-Seite aus zu nutzen.

FilelO ist die Basis-Klasse, um in den Speicherbereich des Arduino Yún (Atheros AR9331) zu schreiben bzw. von diesem zu lesen. Auf der SD-Karte kann auf oberster Ebene (root) ein leeres Verzeichnis Arduino angelegt werden, von dem der Arduino Yún dann einen Link nach /mnt/sd einrichtet.

Zwei einfache Programmbeispiele sollen das Schreiben und Lesen eines Textfiles zeigen. Mit dem Verständnis dieses Mechanismus können dann die folgenden Beispiele einfacher verstanden werden.

Listing 22 zeigt das Schreiben von Daten in ein Textfile (write_file.ino). Da der Schreibvorgang nach Aufruf des Programmbeispiels nur einmal erfolgen soll, sind alles Aktionen in der Funktion setup () zusammengefasst. Die Funktion loop () bleibt leer.

Zu Beginn des Programmbeispiels write_file.ino laden wir über #include <FileIo.h> die FilelO Library. Zu Beginn erfolgen die Initialisierung von Bridge und Serial und eine erste Ausgabe zur Console.

Nun beginnt der interessantere Teil mit der Initialisierung des Filesystems durch FileSystem.begin ().

Der Schreibvorgang beginnt mit dem Öffnen des Files mit Pfad und Filenamen und Art des Zugriffs als Argument (File txt = FileSystem. open ("/tmp/test.txt", FILE_WRITE) ;). Der Schreibvorgang selbst wird durch txt. print () bewirkt und txt. close () schließt in diesem Fall das File.

#include <FileIO.h>
void setup()

{

Bridge.begin();

Serial.begin(9600);
while(!Serial); // wait for Serial port to connect.

Serial.println("Write text file…");

FileSystem.begin();

File txt = FileSystem.open("/tmp/test.txt", FILE_WRITE);
txt.print("Das ist Text in einem Textfile");
txt.close (); // close the file

Serial.println("Text file written.");

}

void loop()

{

// nothing to do here

}

Listing 22 Quelltext write_file.ino

Listing 23 zeigt nun noch das Lesen von Daten aus einem Textfile (read_file.ino). Das Lesen eines Files gestaltet sich sehr ähnlich, nur dass beim Öffnen des Files hier die Art des Zugriffs FILE_READ sein muss.

War das Öffnen des Files nicht erfolgreich, weil es möglicherweise nicht vorhanden war, dann erfolgt die Ausgabe „File open error über die Console und das Programm geht in die Endlosschleife.

Anderenfalls wird der Inhalt des Files zeichenweise gelesen (c = txt.read ()), über die Console ausgegeben und zu einem String zusammengeführt (text. concat (c);).

Ist das File gelesen, dann folgt eine entsprechende Ausgabe über die Console und das Schließen des Files.

#include <FileIO.h>
void setup()

{

Bridge.begin();

Serial.begin(9600);
while(!Serial); // wait for Serial port to connect.

Serial.println("Read text file…");

FileSystem.begin();

File txt = FileSystem.open("/tmp/test.txt", FILE_READ);
if (!txt) Serial.print("File open error");
else

{

String str = "";
while(txt.available())

{
char c = txt.read();

Serial.print(c);
str += c;

}

txt.close();

Serial.println("\nText file read.");

}

}

void loop()

{

// nothing to do here

}

Listing 23 Quelltext read_file.ino

Im etwas komplexeren Programmbeispiel FilelO.ino (Listing 24) wird in der Funktion setup () durch die Funktion uploadScript () eine Scriptdatei erzeugt, die dann in der Funktion loop () über den Aufruf von runScript () ausgeführt wird.

In der Funktion uploadScript () wird ein Shell-Script wlan-stats.sh im Verzeichnis /tmp erzeugt. Durch die Instruktionen script.print("#!/bin/sh\n"); und script.print("ifconfig wlan0 | grep ' RX bytes' \n"); wird folgendes Shell-Script erzeugt:

#!/bin/sh
ifconfig wlan0 | grep 'RX bytes'

Anschließend wird das Shell-Script wlan-stats.sh durch
chmod +x /tmp/wlan-stats.sh
ausführbar gemacht, damit es in der Funktion runScript () durch Aufruf von /tmp/wlan-stats.sh gestartet werden kann.

Im String output werden die Rückgaben des Shell-Scripts gesammelt und später ausgegeben. Abbildung 74 zeigt die Ausgaben des Programms FilelO.ino.

/*

Write to file using FileIO classes.

This sketch demonstrate how to write file into the Yun filesystem.

A shell script file is created in /tmp, and it is executed afterwards.

created 7 June 2010
by Cristian Maglie

This example code is in the public domain.

*/

#include <FileIO.h>
void setup()

{

// Setup Bridge (needed every time we communicate with the Arduino Yún)

Bridge.begin();

// Initialize the Serial

Serial.begin(9600);
while(!Serial); // wait for Serial port to connect.

Serial.println("File Write Script example");

// Setup File IO

FileSystem.begin();

// Upload script used to gain network statistics
uploadScript();

}

void loop()

{

// Run stats script every 5 secs.

runScript();
delay(5000);

}

// this function creates a file into the linux processor that contains a shell
script

// to check the network traffic of the WiFi interface
void uploadScript()

{

// Write our shell script in /tmp

// Using /tmp stores the script in RAM this way we can preserve

// the limited amount of FLASH erase/write cycles

File script = FileSystem.open("/tmp/wlan-stats.sh", FILE_WRITE);

// Shell script header
script.print("#!/bin/sh\n");

// Shell commands:

// ifconfig: is a command line utility for ctrl the network interfaces.

// wlan0 is the interface we want to query

// grep: search inside the output of the ifconfig command for "RX bytes"

// and extract the line that contains it
script.print("ifconfig wlan0 | grep 'RX bytes'\n");
script.close(); // close the file

// Make the script executable: chmod +x /tmp/wlan.stats.h

Process chmod;
chmod.begin("chmod"); // chmod: change mode
chmod.addParameter("+x"); // x stays for executable
chmod.addParameter("/tmp/wlan-stats.sh"); // path to the file to make it
executable
chmod.run();

}

// this function run the script and read the output data
void runScript()

{

// Run the script and show results on the Serial

Process myscript;
myscript.begin("/tmp/wlan-stats.sh");
myscript.run();

String output = "";

// read the output of the script
while (myscript.available()) {
output += (char)myscript.read();

}

// remove the blank spaces at the beginning and the ending of the string
output.trim();

Serial.println(output);

Serial.flush();

}

Listing 24 Quelltext FileIO.ino

Abbildung 74 Ausgaben des Programms FileIO.ino

4.2.3 YunServer & YunClient

YunServer ist die Basis-Klasse für alle Aufrufe des Arduino Yún HTTP-Servers, während YunClient die Basis-Klasse für alle Aufrufe eine HTTP-Clients ist.

In den Arduino Yún Programmbeispielen zur Bridge Library ("…/Arduino 1.5.4\libraries\Bridge\examples") ist das Beispiel TemperaturWebPanel.ino (Listing 26) zu finden, welches hier zu Erläuterung herangezogen wird.

Im Programmbeispiel TemperaturWebPanel.ino wird die Umgebungstemperatur mit einem Temperatursensor TMP36 erfasst und an den internen Arduino Yún Webserver weitergeleitet.

Auf der angeschlossenen SD-Karte ist auf oberster Ebene das Verzeichnis arduino und darunter das Verzeichnis www zu erstellen.

Grundsätzlich bedarf es eines Arduino Programms (Sketch) und einer HTML-Seite (Listing 25).

Beim Aufruf der HTML-Seite sendet diese eine Anfrage an den Arduino Yún Webserver, die dieser beantworten wird.

<!DOCTYPE html>

<html>

<head>

<script type="text/javascript" src="zepto.min.js"></script>

<script type="text/javascript">
function refresh() {

$('#content').load('/arduino/temperature');

}

</script>

</head>

<body onload="setInterval(refresh, 1000);">

<span id="content">0</span>

</body>

</html>

Listing 25 HTML-Datei index.html

Um die Anfrage an den Webserver zu senden bedarf es JavaScript, was in diesem Zusammenhang bislang hier noch nicht verwendet wurde. Wr müssen uns darüber aber keine Sorgen machen, denn durch Einsatz der Zepto Library müssen wir uns darum nicht kümmern.

Zepto ist eine kompakte JavaScript Library für moderne Webbrowsers mit weitgehend jQuery-kompatibler API (http://zeptois.com/).

In das auf der SD-Karte angelegte Verzeichnis www kopieren wir nun die HTML-Seite index.html (Listing 25) und die Datei zepto.min.js.

Betrachten wir nun noch das Arduino-Programm TemperatureWebPanel.ino (Listing 26).

Zu Beginn des Programms werden die erforderlichen Libraries geladen. In diesem Fall benötigen wir

#include <Bridge.h>

#include <YunServer.h>

#include <YunClient.h>

Im Initialisierungsteil werden das YunServer Objekt server und die Variablen startString und hits initialisiert

YunServer Server;

String startString;
long hits = 0;

In der Funktion setup () werden nun die serielle Kommunikation und die Bridge gestartet. Eine leuchtende LED (an IO13) zeigt, den vollzogenen Start der Bridge an. Danach folgt die Konfiguration der IO für den Anschluss des Temperatursensors TMP36 (siehe hierzu Abschnitt 4.1.3). Schließlich wir dem Server noch mitgeteilt, dass er nur auf Anfragen über localhost reagieren soll und dieser gestartet. Zum Schluss wird mit startTime noch eine Instanz von Process erzeugt und durch Aufruf des Shell-Kommandos date die aktuelle Zeit abgefragt und in der Variablen startString gespeichert.

In der Funktion loop () wird zuerst das YunClient Object dient erzeugt. Ist ein neuer Client verbunden (if (client)), dann kann das Kommando gelesen, durch trim () von Leerzeichen befreit und über die Konsole ausgegeben werden.

War das übertragene Kommando identisch zu „temperature“, dann wird erneut die aktuelle Zeit über das Shell-Kommando date abgefragt und in der Variablen timeString abgspeichert,

Die Abfrage der Umgebungstemperatur erfolgt durch Auslesen des Sensorwertes über den Eingang AIN1 und anschließende Umrechnung in einen Spannung- und Temperaturwert (°C).

int sensorValue = analogRead(Al);

// convert the reading to millivolts:

float voltage = sensorValue * (5000/ 1024);

// convert the millivolts to temperature celsius:

float temperature = (voltage – 500)/10;

Mit einer Reihe von Anweisungen client. print () werden die Inhalte an die HTML-Seite zurückgeschickt.

client.print("Current temperature: ");
client.print(temperature);
client.println(" degrees C");

Ist die Anfrage vom Webserver beantwortet, dann können die Client-Verbindung getrennt und die benutzten Ressourcen freigegeben werden.

Die Variable hits wird zum Schluss noch inkrementiert, um die Anzahl der Anfragen dokumentieren zu können.

Den beschriebenen Abruf der Umgebungstemperatur von einem Webbrowser zeigt Abbildung 75.

/*

Temperature web interface

This example shows how to serve data from an analog input
via the Arduino Yún's built-in webserver using the Bridge library.

The circuit:

* TMP36 temperature sensor on analog pin A1

* SD card attached to SD card slot of the Arduino YÃºn

Prepare your SD card with an empty folder in the SD root
named "arduino" and a subfolder of that named "www".

This will ensure that the Yún will create a link
to the SD to the "/mnt/sd" path.

In this sketch folder is a basic webpage and a copy of zepto.js, a
minimized version of jQuery. When you upload your sketch, these files
will be placed in the /arduino/www/TemperatureWebPanel folder on your SD card.

You can then go to http://arduino.local/sd/TemperatureWebPanel
to see the output of this sketch.

You can remove the SD card while the Linux and the
sketch are running but be careful not to remove it while
the system is writing to it.

created 6 July 2013
by Tom Igoe

This example code is in the public domain.

*/

#include <Bridge.h>

#include <YunServer.h>

#include <YunClient.h>

// Listen on default port 5555, the webserver on the Yun

// will forward there all the HTTP requests for us.

YunServer server;

String startString;
long hits = 0;
void setup() {

Serial.begin(9600);

// Bridge startup
pinMode(13,OUTPUT);
digitalWrite(13, LOW);

Bridge.begin();
digitalWrite(13, HIGH);

// using A0 and A2 as vcc and gnd for the TMP36 sensor:

pinMode(A0, OUTPUT);
pinMode(A2, OUTPUT);
digitalWrite(A0, HIGH);
digitalWrite(A2, LOW);

// Listen for incoming connection only from localhost

// (no one from the external network could connect)

server.listenOnLocalhost();
server.begin();

// get the time that this sketch started:

Process startTime;
startTime.runShellCommand("date");
while(startTime.available()) {
char c = startTime.read();
startString += c;

}

}

void loop() {

// Get clients coming from server

YunClient client = server.accept();

// There is a new client?

if (client) {

// read the command

String command = client.readString();
command.trim(); //kill whitespace

Serial.println(command);

// is "temperature" command?

if (command == "temperature") {

// get the time from the server:

Process time;
time.runShellCommand("date");

String timeString = "";
while(time.available()) {
char c = time.read();
timeString += c;

} Serial.println(timeString);
int sensorValue = analogRead(A1);

// convert the reading to millivolts:

float voltage = sensorValue * (5000/ 1024);

// convert the millivolts to temperature celsius:

float temperature = (voltage – 500)/10;

// print the temperature:

client.print("Current time on the Yun: ");
client.print(timeString);
client.print("Current temperature: ");
client.print(temperature);
client.println(" degrees C");
client.print("This sketch has been running since ");
client.print(startString);
client.print("Hits so far: ");
client.print(hits);

}

// Close connection and free resources.

client.stop();
hits++;

}

delay(50); // Poll every 50ms

}

Listing 26 Quelltext TemperatureWebPanel.ino

Abbildung 75 Temperaturabfrage

4.3 Temboo

Temboo ist eine Schnittstelle zu zahlreichen Applikationen, die über das Cloud Computing erreichbar sind. Über 2000 Choreos genannte cloud-basierte und task-spezifische Codekomponenten werden von Temboo bereitgestellt (https://temboo.com).

Für den Arduino Yún wurde die Temboo-Technologie zur Nutzung web-basierter Ressourcen und Services ausgesucht. Abbildung 76 zeigt den Datenfluss vom Sensor in die Temboo-Cloud, der allerdings auch in umgekehrter Reihenfolge (hier nicht dargestellt) verlaufen kann.

Abbildung 76 Datenfluss in die Temboo-Cloud

Sensordaten u.ä. werden durch den ATmega32U4 erfasst und über die Bridge in den Atheros AR9331 übertragen. Von da überträgt der Temboo-Client die Daten zur betreffenden Applikation in der Temboo-Cloud, wo Daten abgelegt, verarbeitet oder abgefragt werden können. Bei der Abfrage werden die Daten den gleichen Weg zurück an den ATmega32U4 gesendet und können dort beispielsweise IO-Pins beeinflussen, Aktoren steuern oder auf dem Monitor zur Anzeige gebracht werden. Die Verteilung der Temboo-Komponenten zeigt Abbildung 77.

Abbildung 77 Temboo-Komponenten

Bevor wir Temboo nutzen können, muss unter https://temboo.com ein Benutzerkonto eingerichtet werden.

Die Temboo-Zugangsdaten sind im File TembooAccount.h (in Abbildung 77 als Temboo.h bezeichnet) ausgelagert, so dass das zu erstellende .ino-File ohne diese nicht-öffentlichen Daten weitergegeben werden kann.

Über 2000 Choreos aus den verschiedensten Bereichen, wie Werbung, Entwicklung, Gesundheit, Marketing, Produktivität, Suche, Speicherung, Wetter u.a.m., stehen für Programmierumgebungen, wie iOS, Android, Java, PHP, Python, Ruby, Node.js, cURL und Arduino Yún zur Verfügung.

Für Google und Twitter Applikationen benötigt es auch da ein Benutzerkonto. Für viele anderen Choreos bzw. die dahinterliegenden Applikationen ist das genauso. In Abschnitt 5.2 können diese Daten zusammengefasst notiert werden.

Abbildung 78 zeigt die Einstiegsseite Arduino Yún mit einigen Applikationen.

Abbildung 78 Temboo Einstiegsseite für Arduino Yún

Anhand einiger Beispiele soll der Zugriff auf die Temboo-Cloud verdeutlicht werden. Im ersten Beispiel werde ich zeigen, wie ein ausgewählter Choreo bereits in der Library getestet werden kann, bevor die Implementierung auf dem Arduino Yún erfolgt.

4.3.1 Daten in einer Google Tabellenkalkulation
ln unserem Programmbeispiel wollen wir vom Arduino Yún erfasste Daten in einer Google Tabellenkalkulation zur weiteren Auswertung ablegen.

Hierzu habe ich in Google Docs die Tabelle TembooTable erstellt, die aus zwei Spalten bestehen soll, die in der ersten Zeile beschriftet sind (Abbildung 79).

Abbildung 79 Tabelle TembooTable

Nach dem Login auf der Website https://temboo.com kann nun durch Aufruf von Library > Google > Spreadsheet das AppendRow Choreo (Hinzufügen einer Zeile) aufgerufen werden. Das AppendRow Choreo übergibt eine Zeile von kommagetrennten Daten an die Google Tabellenkalkulation.

Abbildung 80 zeigt nun wie der AppendRow Choreo in der Library getestet werden kann. Hierzu ist darauf zu achten, dass der RunMode aktiv ist (Run Mode is on). Im Bereich Input sind nun zuerst die Google Zugangsdaten (Password & Username) einzugeben. Diese Daten können abgespeichert werden und lassen sich dann über „Insert Credentials“ jederzeit wieder aufrufen.

Im Feld „Raw Data“ sind durch Komma getrennt, die in der Tabelle einzutragenden Daten zu übergeben. In unserem Fall ist das also ein Wertepaar (hier 500, 600). Als letztes ist noch der Name der Tabelle einzugeben (hier TembooTable).

Ein Klick auf das Feld sendet nun die aufbereiteten Daten über Temboo an die Google Tabellenkalkulation.

Durch die Rückmeldung „success“ im Feld „Response“ können wir von einer ordnungsgemäßen Funktion ausgehen. Besser ist es aber allemal, sich in der Tabellenkalkulation selbst vom Erfolg zu überzeugen (Abbildung 81).

Abbildung 80 Test AppendRaw Choreo

Abbildung 81 TembooTable nach dem Library Test

Nach diesem erfolgreichen Test können wir von einer erwartungsgemäßen Funktion dieses Choreos ausgehen und können uns den Arduino Code generieren lassen. Nach dem Selektieren der Programmiersprache für den Arduino Yún wird ein Sketch generiert, der in die Arduino IDE übernommen werden kann (Abbildung 82).

Abbildung 82 Code Generation für Arduino Yún

Zusätzlich wird das Headerfile TembooAccount.h mit den Temboo Zugangsdaten (Credentials) generiert. Dieses Headerfile ist in das Verzeichnis zu kopieren, in dem sich auch unser Sketch *.ino befindet. Die Temboo Zugangsdaten sind damit in diesem File gekapselt und vom Anwendungsprogramm *.ino getrennt.

In Abbildung 80 waren aber auch noch die Google Zugangsdaten einzugeben. Auch diese sollten wir natürlich „verstecken“. Hier sind zwei verschiedene Möglichkeiten gegeben.

Durch die Eingabe gemäß Abbildung 80 wird der spezifische Code in nachstehender Form generiert. Google Password und Username erscheinen im Klartext und wurden hier nachträglich durch xxx unkenntlich gemacht. Password und Username kann man wiederum in ein Headerfile auslagern, wodurch sie bei einer Weitergabe des Codes in Form des ino-Files verborgen bleiben.

// set choreo inputs

AppendRowChoreo.addInput("Password", "xxxxxxxx");

AppendRowChoreo.addInput("Username", "xxxx@gmail.com");

AppendRowChoreo.addInput("RowData", "900,900");

AppendRowChoreo.addInput("SpreadsheetTitle", "TembooTable");

Eine weitere Möglichkeit besteht im Abspeichern der Credentials. Werden diese dann eingefügt, dann stehen die Google Zugangsdaten nicht mehr im Klartext im Code sondern werden durch den vergebenen Namen adressiert.

// Set credential to use for execution

AppendRowChoreo.setCredential("CKGoogle");

// set choreo inputs

AppendRowChoreo.addInput("RowData", "900,900");

AppendRowChoreo.addInput("SpreadsheetTitle", "TembooTable");

Listing 27 zeigt nun den Quelltext des Programmbeispiels TembooTable.ino. Hier wurde die erste Variante für die Google Zugangsdaten gewählt, wodurch auch Includes für beide Header-Files mit den Zugangsdaten vorzusehen waren.

#include <Bridge.h>

#include <Temboo.h>

#include "TembooAccount.h& // contains Temboo account information

#include "GoogleAccount.h& // contains Google account information
int numRuns = 1; // execution count, so this doesn't run forever
int maxRuns = 2; // maximum number of times the Choreo should be executed
void setup() {

Serial.begin(9600);

// For debugging, wait until a serial console is connected.

delay(4000);
while(!Serial);

Bridge.begin();

}

void loop()

{
if (numRuns <= maxRuns) {

Serial.println("Running AppendRow – Run #& + String(numRuns++));

TembooChoreo AppendRowChoreo;

// invoke the Temboo client

AppendRowChoreo.begin();

// set Temboo account credentials

AppendRowChoreo.setAccountName(TEMBOO_ACCOUNT);

AppendRowChoreo.setAppKeyName(TEMBOO_APP_KEY_NAME);

AppendRowChoreo.setAppKey(TEMBOO_APP_KEY);

// set choreo inputs

AppendRowChoreo.addInput("Password", GOOGLE_PW);

AppendRowChoreo.addInput("Username", GOOGLE_USER);

AppendRowChoreo.addInput("RowData", "111, 222");

AppendRowChoreo.addInput("SpreadsheetTitle", "TembooTable");

// identify choreo to run

AppendRowChoreo.setChoreo("/Library/Google/Spreadsheets/AppendRow");

// run choreo; when results are available, print them to serial

AppendRowChoreo.run();

while(AppendRowChoreo.available()) {
char c = AppendRowChoreo.read();

Serial.print(c);

}

AppendRowChoreo.close();

}

Serial.println("Waiting…");
delay(30000); // wait 30 seconds between AppendRow calls

}

Listing 27 Quelltext TembooTable.ino

Vom Aufbau her bietet das Programmbeispiel TembooTable.ino nichts wesentlich Neues. Die Variable maxRuns legt fest, wie viele Male das Wertepaar zur Google Tabellenkalkulation geschickt wird.

Nach der Initialisierung des AppendRow Choreos werden die Temboo Zugangsdaten und anschliessend die Google Zugangsdaten sowie die eigentlichen Daten (das Wertepaar) und der Tabellenname bereitgestellt, um den so vorbereiteten Choreo dann schlussendlich aufzurufen. Die zurückgegebenen Daten werden in einer Schleife ausgelesen und ausgegeben und können, wie Abbildung 83 zeigt, im Monitor angezeigt werden.

Abbildung 83 Rückmeldung bei fehlerfreier Übertragung

Definitionsgemäß werden zwei Datensätze zur Google Tabellenkalkulation geschickt, dann läuft die Schleife bis auf die Ausgabe von „Waiting…“ und die Wartezeit von 30 s ohne weitere Aktivitäten endlos. In einer realen Anwendung macht da sicher wenig Sinn. Wchtig hier ist aber, die Bausteine kennen zu lernen, die dann in einer realen Applikation sinnvoll eingesetzt werden können.

Abschließend wollen wir uns wieder in der Tabellenkalkulation selbst vom Erfolg zu überzeugen. Abbildung 84 zeigt die Erweiterungen der Tabelle, die durch den Aufruf des AppendRow Choreos vom Arduino Yún aus vorgenommen wurden.

Abbildung 84 TembooTable nach dem Upload über den AppendRow Choreos

4.3.2 eMail über Google Mail versenden
ln Abschnitt 4.2.1 hatte ich bereits gezeigt, wie über den Aufruf eines Shell-Scripts eine eMail versendet werden kann.

Gmail ist Google’s kostenloser eMail-Dienst und gilt seit Mitte 2012 als der weltweit meistgenutzte. Über Temboo können wir diesen Dienst auf sehr einfache Weise nutzen.

Ich habe das Versenden einer eMail in das Programmbeispiel StatusMonitor.ino (Listing 28) eingebaut. Das Programm überwacht einen digitalen Eingang. Wenn sich der Pegel am Eingang pIn ändert, dann ändert sich auch die Variable state und es erfolgt eine am Monitor nachfolgbare Ausgabe „State is 0“ oder „State is 1“ und das entsprechende Ansteuern einer LED.

Bevor ich zu der durch MAIL gesteuerten eMail-Ausgabe komme, soll noch das umfangreichere Setup betrachtet werden.

An IO13 ist beim Arduino Yún, wie bei den meisten anderen Arduinos auch, eine LED angeschlossen, die wir hier verwenden (pLED). Die Wahl von IO9 als digitaler Eingang ist willkürlich (pIn).

In der Funktion setup () erfolgt nun die Initialisierung der beiden lOs. Durch das Setzen von I09 auf Hi (digitalWrite(pIn, HIGH)) wird der interne PullUp-Wderstand eingeschaltet, so dass bei offenem Eingang dieser immer als Hi gelesen wird.

Bevor die Initialisierung der seriellen Schnittstelle erfolgt, wird noch IO9 abgefragt, in der Variablen old_state gespeichert und die LED entsprechend ein- oder ausgeschaltet.

In der Endlosschleife loop() wird der noch zu verwendende String msg (string msg = „state is ") als Variable deklariert und initialisiert. Es folgt die Abfrage von IO9. Nur wenn sich der aktuelle Status vom alten unterscheidet, dann werden der alte Status überschrieben, eine Meldung über die serielle Schnittstelle ausgegeben und die LED entsprechend gesetzt.

Nun kommt unser Schalter MAIL ins Spiel. War Mail bei der Compilation auf 0 gesetzt, dann wurde der zwischen #if und #endif stehende Quelltext nicht compiliert.

Durch die bedingte Compilierung existiert der betreffende Code dann im auszuführenden Programm nicht. In diesem Fall kann man im unteren Feld der IDE die Ausgabe „Sketch uses 12,672 bytes (44%) of program storage space. Maximum is 28,672 bytes.“ lesen.

Wollen wir hingegen auf die Ausgabe der eMail nicht verzichten, was ja das ursprüngliche Ziel war, dann ist MAIL auf 1 zu setzen und der komplette Quelltext wird compiliert. Nun kann man im unteren Feld der IDE die Ausgabe „Sketch uses 15,584 bytes (54%) of program storage space. Maximum is 28,672 bytes.“ lesen. Der durch Temboo generierte eMail-Quelltext erzeugt also 2912 Byte an Code.

Die Eingabe der Credentials erfolgt in der gewohnten Weise. Bei den Google Credentials wurde nach der zweiten im Abschnitt 4.3.1 gezeigten Variante (abgespeicherte Credentials) verfahren, weshalb hier auf das zweite Header-File verzichtet werden konnte.

Der Aufbau der eMail selbst wird aus dem Quelltext ersichtlich. Hier kann auch ein Subject (Betreff) eingegeben werden, so dass diese eMail die gewohnte Form aufweist. Die eMail-Adressen von Sender und Empfänger wurden hier durch xxxx unkenntlich gemacht. Das muss vor dem Compilieren noch an die vom Anwender gewünschten Daten angepasst werden.

Nach einer Wartezeit von einer Sekunde wiederholt sich die Abfrage von I09 und allen nachgeschalteten Aktivitäten.

//

// Title : Status Monitor for digital Input

// Author : Claus Kühnel

// Date : 2013-10-24

// Id : StatusMonitor.ino

// Version : 1.5.4

// Micro : Arduino Yún

//

// DISCLAIMER:

// The author is in no way responsible for any problems or damage caused by

// using this code. Use at your own risk.

//

// LICENSE:

// This code is distributed under the GNU Public License

// which can be found at http://www.gnu.org/licenses/gpl.txt

//

// ----------------------------------------------------------------------------

//

#include <Bridge.h>

#include <Temboo.h>

#include "TembooAccount.h& // contains Temboo account information, as described
below

#define MAIL 1 // set 0 to avoid mailing

// Pin 13 has an LED connected on most Arduino boards.

const int pLed = 13;

// Selection of input pin is arbitrarely
const int pIn = 9;
boolean old_state;
boolean state;
void setup() {

// initialize the digital IO pins.

pinMode(pLed, OUTPUT);
pinMode(pIn, INPUT);
digitalWrite(pIn, HIGH); //PullUp active
old_state = digitalRead(pIn);
digitalWrite(pLed, old_state);

// initialize serial port

Serial.begin(9600);
delay(4000);
while(!Serial);

Serial.println("Monitoring state on IO9…");

Serial.print("State after initialization is ");

Serial.println(old_state);

Bridge.begin();

}

// the loop routine runs over and over again forever:

void loop()

{

String msg = "State is ";

state = digitalRead(pIn);
if (state != old_state)

{
old_state = state;
digitalWrite(pLed, state);

Serial.println(msg + state);

#if (MAIL)

{

TembooChoreo SendEmailChoreo;

// invoke the Temboo client

SendEmailChoreo.begin();

// set Temboo account credentials

SendEmailChoreo.setAccountName(TEMBOO_ACCOUNT);

SendEmailChoreo.setAppKeyName(TEMBOO_APP_KEY_NAME);

SendEmailChoreo.setAppKey(TEMBOO_APP_KEY);

// Set credential to use for execution

SendEmailChoreo.setCredential("CKGoogle");

// set choreo inputs

SendEmailChoreo.addInput("MessageBody", msg + state);

SendEmailChoreo.addInput("Subject", "IO8 State");

SendEmailChoreo.addInput("FromAddress", "xxxx@gmail.com"); // eMail from

SendEmailChoreo.addInput("ToAddress", "xxxx@gmx.ch"); // eMail to

// identify choreo to run

SendEmailChoreo.setChoreo("/Library/Google/Gmail/SendEmail");

// run choreo; when results are available, print them to serial

SendEmailChoreo.run();
while(SendEmailChoreo.available()) {
char c = SendEmailChoreo.read();

Serial.print(c);

}

SendEmailChoreo.close();

}

#endif
delay(1000);

}

}

Listing 28 Quelltext StatusMonitor.ino

Abbildung 85 Serielle Ausgabe

Abbildung 86 Empfangene eMail

4.3.3 Twitter

Twitter ist eine digitale Echtzeit-Anwendung zum Mikroblogging und wird als Plattform zur Verbreitung von kurzen Textnachrichten (Tweets) im Internet verwendet. Die versendeten Tweets dürfen maximal 140 Zeichen aufweisen.

Zum Erstellen solcher Tweets muss der Verfasser bei Twitter einen Account einrichten. Lesen kann diese Tweets standardmäßig jeder ohne Anmeldung. Tweets werden in erster Linie den Followern eines Benutzers angezeigt. Mit Hilfe von Hashtags (#) oder Verlinkungen (URL) kann aber auch ein breiteres Publikum erreicht werden.

Wr wollen hier Twitter zum Versenden von Statusmitteilungen verwenden. Neben der ohnehin erforderlichen Anmeldung bei Temboo bedarf es einer weiteren Anmeldung bei Twitter unter https://twitter.com/signup.

Dann ist eine neue Anwendung unter https://dev.twitter.com/apps einzurichten, damit man die Twitter ConsumerKey und ConsumerSecret Daten erhält. Auf der Temboo Website findet man unter der Rubrik Twitter > Tweet das Statusupdate, mit dem wir einen Tweet verschicken können.

Abbildung 87 zeigt die Vorbereitung eines Tweets auf der Temboo Website. AccessToken und AccessTokenSecret sind die Zugangsdaten von Temboo und waren in den Credentials abgelegt und hier dann eingefügt worden. Consumer-Key und ConsumerSecret sind die Zugangsdaten für die betreffende Twitter App.

Nun bleibt uns nur noch die zu versendende Mitteilung – den Tweet – ins Feld StatusUpdate einzutragen.

Ein Klick auf das Feld sendet die vorbereiteten Daten von der Temboo Website zum Twitter StatusUpdate Choreo. Im darunter liegenden Output Feld können die Daten direkt betrachtet werden. Hier viel interessanter ist die Angabe „Successful run at…“. Die Mitteilung sagt uns, dass alles wunschgemäß verlaufen ist.

Zur Überprüfung öffnen wir von einem PC aus den betreffenden Twitter Account und können da das Ergebnis in Augenschein nehmen. Der eben erstellt Tweet ist nun über Twitter einsehbar (Abbildung 88).

Wollen wir nun den Tweet nicht auf der Temboo Website sondern auf dem Arduino Yún erstellen, dann ist nur noch der SampleCode in die Arduino IDE zu kopieren und vor dem Download an der einen oder anderen Stelle ggf. etwas anzupassen.

Dieser Teil der Temboo Website liegt unmittelbar unter dem Output Feld und ist hier nicht gezeigt. Der generierte Quelltext TembooTweet.ino ist in Listing 29 angegeben. Fett markiert sind Stellen, die nachträglich eingebaut bzw. angepasst worden sind.

Abbildung 87 Vorbereitung des Tweets auf der Temboo Website

Abbildung 88 Von der Temboo Website gesendeter Tweet

#include <Bridge.h>

#include <Temboo.h>

#include "TembooAccount.h& // contains Temboo account information, as described
below

// Pin 13 has an LED connected on most Arduino boards.

const int led = 13;

int numRuns = 1; // Execution count, so this doesn’t run forever
int maxRuns = 2; // Maximum number of times the Choreo should be executed
void setup() {

Serial.begin(115200);

// initialize the digital pin as an output.

pinMode(led, OUTPUT);

// For debugging, wait until the serial console is connected.

delay(4000);
while(!Serial);

Bridge.begin();

}

void loop()

{
if (numRuns <= maxRuns) {

Serial.println("Running StatusesUpdate – Run #& + String(numRuns++));

TembooChoreo StatusesUpdateChoreo;

// Invoke the Temboo client

StatusesUpdateChoreo.begin();

// Set Temboo account credentials

StatusesUpdateChoreo.setAccountName(TEMBOO_ACCOUNT);

StatusesUpdateChoreo.setAppKeyName(TEMBOO_APP_KEY_NAME);

StatusesUpdateChoreo.setAppKey(TEMBOO_APP_KEY);

// Set credential to use for execution

StatusesUpdateChoreo.setCredential("UDOOTweet");

// Set Choreo inputs

StatusesUpdateChoreo.addInput("StatusUpdate", "This #Arduino #Yun is running " + String(millis()) + " ms.");

// Identify the Choreo to run

StatusesUpdateChoreo.setChoreo("/Library/Twitter/Tweets/StatusesUpdate");

// Run the Choreo; when results are available, print them to serial

StatusesUpdateChoreo.run();
while(StatusesUpdateChoreo.available()) {
char c = StatusesUpdateChoreo.read();

Serial.print(c);

}

StatusesUpdateChoreo.close();

}

Serial.println("Waiting…");
for (int i = 0; i < 6; i++)

{
for (int j = 0; j < 10; j++)

{
digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level)

delay(20); // wait for a second
digitalWrite(led, LOW); // turn the LED off by making the voltage LOW
delay(980); // wait for a second

}

Serial.write("*");

}

Serial.println();

}

Listing 29 Quelltext TembooTweet.ino

Der Aufbau des Programmbeispiels TembooTweet.ino ist vergleichbar zu den vorangegangenen Temboo-Beispielen. Im Header-File TembooAccount.h sind die Temboo Credentials abgelegt.

Die an IO13 angeschlossene LED soll hier benutzt werden, deshalb wurde die Konstante led auch initialisiert.

Ich habe hier die Zahl der Tweets auf Zwei (maxRuns = 2) beschränkt, um nicht unnötig viele praktisch gleichlautende Tweets zu versenden.

Die Baudrate des seriellen Interfaces der Console wurde auf 115200 Baud heraufgesetzt, was aber nicht zwingend notwendig ist.

Das Versenden des ersten Tweets wird mit der Meldung „Running StatusesUpdate – Run 1” kommentiert, bevor der betreffende Choreos aufgerufen wird. Es beginnt mit dem Senden der TembooAccount Credentials gefolgt von den Twitter Credentials, die unter UDOOTweet abgelegt sind. Danach folgt der eigentliche Tweet mit dem Inhalt “This #Arduino #Yun is running xxx ms.” Im Tweet ist den Worten Arduino und Yun ein # vorangestellt, was diese Worte im Tweet speziell markiert (Abbildung 90).

Die vom Choreo zurückgegebenen Zeichen werden gelesen und über die Console (Monitor) ausgegeben. Abbildung 89 zeigt im Terminalmitschnitt die Ausgaben des Programmes.

Die Ausgabe „Waiting…“ signalisiert den Beginn eine Wartezeit von 60 sec, die durch die im Sekundentakt blinkende LED an IO13 und durch einen im 10- Sekunden-Takt ausgegeben „*“ signalisiert wird.

Da nur zwei Tweets im Abstand von einer Minute ausgegeben werden, erfolgt bei weiteren Schleifendurchläufen dann nur noch die Abarbeitung der Wartezeit mit den zugehörigen Ausgaben (Abbildung 89).

Abbildung 89 Terminalausgaben TembooTweetino

Abbildung 90 Tweets in Twitter

4.3.4 Temboo Sketch Builder

Die Erstellung von cloud-basierten Anwendungen war mit Hilfe der Unterstützung durch Temboo schon sehr stark vereinfacht worden.

Temboo zeigt aber nun mit dem Temboo Sketch Builder eine Möglichkeit, komplette Programme zu erzeugen, ohne eine Zeile Code zu schreiben. Ich will die Vorgehensweise hier an einem einfachen Beispiel verdeutlichen.

Den Temboo Sketch Builder erreichen wir über die Temboo Website mit der URL https://temboo.com/library/Library/Devices/. Abbildung 91 zeigt den Einstiegsbildschirm zur Auswahl eines Sensors, dessen Daten eine noch zu definierende Aktion auslösen sollen.

Abbildung 91 Temboo Sketch Builder

Bei den Sensoren wird hier stets davon ausgegangen, dass ein analoger Ausgang vorliegt, dessen Ausgangsspannungsbereich an den 5V-Eingangsspannungsbereich des internen AD-Umsetzers angepasst ist. Hat man einen anderen analogen Spannungsbereich oder gar einen digitalen Sensor, dann muss man die erforderlichen Anpassungen im erzeugten Code selbst vornehmen.

Nach Auswahl des gewünschten Sensors erscheint die Auswahl der betreffenden Anwendung (Abbildung 92). Wir können hier abhängig von Status des betreffenden Sensors eine eMail versenden, eine MySQL-Datenbank mit Daten füttern, uns anrufen lassen oder eine SMS senden, einen Eintrag in eine Google-Tabellenkalkulation vornehmen oder eine Amazon SQS Message senden.

Abbildung 92 Auswahl der Anwendung

Ich möchte in unserem Beispiel hier bei einem bestimmten Ausgangssignal des Sensors angerufen werden. Dazu ist es notwendig einen entsprechenden Provider zu bemühen. Ich habe es mit einem Testaccount bei Nexmo (https://www.nexmo.com) versucht. Nexmo stellt SMS- und Telefon-APIs zur Verfügung, die hier genutzt werden können.

Abbildung 93 zeigt, wie die Aktionen definiert werden, die bei einem vorzugebenden Sensorwert ausgelöst werden sollen.

Wir wollen hier beim Unterschreiten eines Sensorwertes von 128 an Pin A0 via Nexmo die anzugebende Telefonnummer anrufen. Nachträglich wurde die Nummer hier unkenntlich gemacht.

Die Telefonmeldung wird in das Feld GREETING eingetragen und es können durch Tastenbetätigung am Telefon auszulösende Aktionen definiert werden. Hier wurde vereinbart, dass bei Betätigung der Taste „1“ die an IO13 angeschlossene LED eingeschaltet und bei Betätigung der Taste „2“ der Ausgang IO12 auf Hi geschaltet wird.

Durch Drücken des Buttons „Generate Sketch“ wird der komplette Quelltext des Programmbeispiels nexmo.ino gemäß Listing 30 erzeugt.

Abbildung 93 Definieren der auszulösenden Aktion

#include <Bridge.h>

#include <Temboo.h>

#include "TembooAccount.h& // Contains Temboo account information

// The number of times to trigger the action if the condition is met.

// We limit this so you won't use all of your Temboo calls while testing.

int maxCalls = 10;

// The number of times this Choreo has been run so far in this sketch.

int calls = 0;
void setup() {

Serial.begin(9600);

// For debugging, wait until the serial console is connected.

delay(4000);
while(!Serial);

Bridge.begin();

// Initialize pins
pinMode(A0, INPUT);
pinMode(12, OUTPUT);
pinMode(13, OUTPUT);

Serial.println("Setup complete. Waiting for sensor input…\n");

}

void loop() {
int sensorValue = analogRead(A0);

Serial.println("Sensor value: " + String(sensorValue));
if (sensorValue < 128) {
if (calls < maxCalls) {

Serial.println("\nCondition triggered! Calling the

/Library/Nexmo/Voice/CaptureTextToSpeechPrompt Choreo…");

String choice = makeNexmoCall();
if (choice == "1") {
digitalWrite(13, HIGH);

}

if (choice == "2") {
digitalWrite(12, HIGH);

}

calls++;

} else {

Serial.println("\nCondition triggered! Not calling the action this time to save Temboo calls during testing.");

Serial.println("You can adjust or remove the calls/maxCalls if() statement to change this behavior.\n");

}

}

delay(250);

}

String makeNexmoCall() {

String choice = "";

TembooChoreo CaptureTextToSpeechPromptChoreo;

// Invoke the Temboo client

CaptureTextToSpeechPromptChoreo.begin();

// Set Temboo account credentials

CaptureTextToSpeechPromptChoreo.setAccountName(TEMBOO_ACCOUNT);

CaptureTextToSpeechPromptChoreo.setAppKeyName(TEMBOO_APP_KEY_NAME);

CaptureTextToSpeechPromptChoreo.setAppKey(TEMBOO_APP_KEY);

// Set credential to use for execution

CaptureTextToSpeechPromptChoreo.setCredential("Nexmo");

// Set Choreo inputs

CaptureTextToSpeechPromptChoreo.addInput("Text", "Hey, your sensor value triggered an alert! Press 1 to turn on an LED. Press 2 to turn on an LED.");

CaptureTextToSpeechPromptChoreo.addInput("To", "xxxxxxxx");

CaptureTextToSpeechPromptChoreo.addInput("MaxDigits", "1");

CaptureTextToSpeechPromptChoreo.addInput("ByeText", "Ok, your wish is my command. Goodbye!");

// Set Choreo output filters

CaptureTextToSpeechPromptChoreo.addOutputFilter("choice", "/digits", "CallbackData");

// Identify the Choreo to run

CaptureTextToSpeechPromptChoreo.

setChoreo("/Library/Nexmo/Voice/CaptureTextToSpeechPrompt");

// Run the Choreo
unsigned int returnCode = CaptureTextToSpeechPromptChoreo.run();

// A return code of zero means everything worked
if (returnCode == 0) {

Serial.println("Completed execution of the

/Library/Nexmo/Voice/CaptureTextToSpeechPrompt Choreo.\n");

} else {

// A non-zero return code means there was an error

// Read and print the error message
while (CaptureTextToSpeechPromptChoreo.available()) {
char c = CaptureTextToSpeechPromptChoreo.read();

Serial.print(c);

}

Serial.println();

}

// Parse the results
while(CaptureTextToSpeechPromptChoreo.available()) {

// Read the name of the next output item

String name = CaptureTextToSpeechPromptChoreo.readStringUntil('\x1F');
name.trim(); // Use "trim& to get rid of newlines

// Read the value of the next output item

String data = CaptureTextToSpeechPromptChoreo.readStringUntil('\x1E');
data.trim(); // Use "trim& to get rid of newlines

// Parse the user‘s choice out of the response data
if (name == "choice") {
choice = data;

}

}

CaptureTextToSpeechPromptChoreo.close();

// Return the choice that the user made
return choice;

}

Listing 30 Quelltext nexmo.ino

5. Anhang

In den folgenden Abschnitten werden einige Zusatzinformationen gegeben, deren Einordnung in die übrige Darstellung nicht eindeutig war, aber dennoch das Bild etwas abrunden hilft.

5.1 Zeilenumbruch

Es existieren verschiedene Standards, um den Zeilenumbruch in einer Textdatei explizit zu kodieren:

Betriebsystemklasse | Zeichenkombination | ASCII-Repräsentation | ESC
dezimal | oktal | hex
Unix, Linux, Android, Mac OS X, AmigaOS, BSD, u.a. | LF | 10 | 012 | 0x0A | \n
Windows, DOS, OS/2, CP/M, TOS (Atari) | CR LF | 13 10 | 015 012 | 0x0D 0x0A | \r\n
Mac OS bis Version 9, Apple II, C64 | CR | 13 | 015 | 0x0D | \r

Schwierigkeiten bereitet das vor allem, wenn man beispielsweise eine Textdatei aus Windows nach Linux übernehmen möchte. Ein Beispiel soll das Verdeutlichen.

Durch eine Suche mit meinem Windows-Rechner habe ich im Web ein grafisches Pendant zum Kommando df gefunden. Dieses Shell-Script gdf.sh habe ich auf den Arduino Yún übertragen und im Editor geöffnet.

Wie Abbildung 94 zeigt, wird jede Zeile ^M durch abgeschlossen und bei Aufruf dieses Scripts werden Fehler auftreten. Schaut man sich die betreffende Datei in einem Hexeditor an, dann erkennt man sofort, dass ^M für den Windows-Zeilenumbruch CR LF (\r\n) steht.

Um den Zeilenumbruch Linux-konform zu ändern, kann mit dem folgenden Kommando das überflüssige \r entfernt werden:

# cat gdf.sh | tr -d '\r' > gdf

Nun muss noch die erste Zeile angepasst werden, da die Bash als leistungsfähigere Shell verwendet werden muss, und die Datei kann als gdf.sh abgespeichert werden.

Wird dieses Shell-Script nun noch durch

# chmod +x gdf.sh
ausführbar gemacht, dann kann es schließlich gemäß Abbildung 95 gestartet werden.

Abbildung 94 Shell-Script gdf.sh im Editor

Abbildung 95 Aufruf df und gdf.sh

5.2 Zugangsdaten
ln diesem Abschnitt können die verschiedenen Zugangsdaten zentral notiert werden. Das manchmal schier aussichtslose Suchen auf gelben Zetteln oder anderen Ablagen kann so vermieden werden.

Siehe hierzu Abschnitt 2.6 Inbetriebnahme

Arduino Yún Configuration
Hostname: myYun (hier verwendet)
Login: root (hier verwendet)
Password: _____________

S.22

www.putty.org

Hostname: 192.168.x.y
Login: root
Password: _________

S.25

http://winscp.net/eng/docs/lang:de

Rechnername: 192.168.x.y
Benutzername: root
Kennwort: _________

S.27

http://www.arvixe.com/

FTP Information
Host: ________.owncloud.arvixe.com
FTP Username: _________
FTP Password: _________

S.41

www.google.com

eMail: _____________
Password: _____________

S.43
S.120

https://temboo.com/

eMail: _____________
Password: _____________

S.117

https://www.nexmo.com/

eMail: _____________
Password: _____________

S.137

5.3 Python Packages

Beim Einsatz von Python ist es wichtig zu wissen, auf welche Packages (Modules, Libraries) man sich abstützen kann. Mit Hilfe des Kommandos

# opkg list | grep python > python_packages
kann die Anzahl der zu Verfügung stehenden Python Packages ermittelt und in der Datei python_packages abgespeichert werden. Manches der Pakete muss nachinstalliert werden, wie es in Abschnitt 3.2.2.2 für die Python Image Library auch demonstriert wurde.

Hier ist eine Liste der in der eingesetzten Version von Linino (OpenWRT) zur Verfügung stehenden Python Packages (die hier verwendeten sind grau hinterlegt):

ipython – 0.8.2-1 – An enhanced interactive Python shell from the SciPy project logilab-astng – 0.17.2-1 – The aim of this module is to provide a common base representation of python source code for projects such as pychecker, pyreverse, pylint… logilab-common – 0.29.1-1 – a bunch of modules providing low level functionnalities shared among some python projects devel
pyserial - 2.4-1 - serial port python bindings
python – 2.7.3-2 – Python is a dynamic object-oriented programming language that can be used for many kinds of software development. It offers strong support for integration with other languages and tools, comes with extensive standard libraries, and can be learned in a few days. Many Python programmers report substantial productivity gains and feel the language encourages the development of higher quality, more maintainable code.

. This package contains the full Python install.

python-bluez – 0.13-1 – Python wrapper for the BlueZ Bluetooth stack python-bzip2 – 2.7.3-2 – Python support for Bzip2
python-cjson – 1.0.5-1 – Fast JSON encoder/decoder for Python
python-crypto – 2.6-1 – A collection of both secure hash functions (such as MD5 and SHA), and various encryption algorithms (AES, DES, IDEA, RSA, ElGamal, etc.).

python-curl – 7.19.0-1 – Python module interface to the cURL library.

python-cwiid – 0.6.00-2 – Python bindings for the cwiid libs
python-django – 1.3.1-1 – Django is a high-level Python Web framework that encourages rapid development and clean, pragmatic design. python-doc – 2.7.3-2 – Python interactive documentation
python-eeml – 20111202-1 – A python package for generating eeml documents.

python-egenix-mx – 2.0.6-1 – This package contains a set of base packages from Egenix required by other python packages.

python-event – 0.3-1 – Python interface to libevent
python-expat – 2.7.3-2 – Python support for expat
python-flup – 1.0.2-1 – Random assortment of WSGI servers
python-gdbm – 2.7.3-2 – Python support for gdbm
python-gobject – 2.21.5-1 – GLib bindings for python
python-gzip – 2.7.3-2 – Python support for gzip
python-ifconfig – 0.1-2 – Display network interface status.

python-imaging-library – 1.1.7-2 – The Python Imaging Library adds image processing capabilities to your Python Interpreter. This library provides extensive file format support, an efficient internal representation, and fairly powerful image processing capabilities. The core image library is designed for fast access to data stored in a few basic pixel formats. It should provide a solid foundation for a general image processing tool.

python-json – 3_4-1 – json-py
python-kid – 0.9.6-1 – Kid is a simple template language for XML based vocabularies written in Python.

python-mimms – 3.2.1-1 – mimms is an mms (e.g. mms://) stream downloader
python-mini – 2.7.3-2 – Python is a dynamic object-oriented programming language that can be used for many kinds of software development. It offers strong support for Integration with other languages and tools, comes with extensive standard libraries, and can be learned in a few days. Many Python programmers report substantial productivity gains and feel the language encourages the development of higher quality, more maintainable code. . This package contains only a minimal Python install.

python-mysql – 1.2.2-1 – MySQLdb is an thread-ccanpatible interface to the popular MySQL
database server that provides the Python database API.

python-ncurses – 2.7.3-2 – Python support for readline
python-openssl – 2.7.3-2 – Python support for OpenSSL
python-pcap – 1.1-1 – Python interface to lipcap
python-psycopg – 1.1.21-1 – This package contains is a PostgreSQL database adapter for the Python programming language.

python-pydaemon – 0.2.3-1 – Turn python scripts into Unix daemons
python-pyosc – 0.3.5b-5294-l – A simple OpenSoundControl implementation in pure Python
python-rsfile – 1.1-1 – RockSolidTools' file I/O implementation python-shutil – 2.7.3-2 – Python support for shutil python-sip – 4.12.1-1 – Python SIP
python-sqlite – 2.3.5-1 – This package contains an SQLite database adapter for the Python progranuning language.

python-sqlite3 – 2.7.3-2 – Python support for sqlite3
python-webpy – 0.37-2 – python-webpy python-xapian – 1.2.8-1 – xapian python bindings
python-yapsnmp – 0.7.8-1 – This package contains a Python SNMP module based on the netsnmp (formerly known as ucd-snmp) library. It*s composed of a low level interface to the library, created using SWIG, and a higher level python module removing all the complexity out of dealing with SNMP.

python2-chardet – 2.0.1-1 – Character encoding auto-detection in Python, pyusb – 0.4.2-1 – usb port python bindings
pyyaml – 3.08-1 – yaml python bindings

5.4 Arduino Yún Gehäuse

Die englische Fa. SB Components bietet ein speziell für den Arduino Yún entwickeltes Gehäuse an (http://stores.ebay.co.uk/sbcomponentsltd/)

Das zweiteilige Spritzguss-Gehäuse schützt den Arduino Yún, ermöglicht aber dennoch den Zugriff zu allen Steckern des Boards. Das Gehäuse weist sognannte Lightpipes für die auf dem Board befindlichen LEDs auf und ermöglicht den Zugang zum Resettaster. Abbildung 96 zeigt den im Gehäuse untergebrachten Arduino Yún.

Abbildung 96 Arduino Yún Gehäuse von SB Components (UK)

6. Referenzen & Links

- [1] Mark Weiser
The Computer for the 21st Century http://www.ubiq.com/hypertext/weiser/SciAmDraft3.html

- [2] Why Google Choosing Arduino Matters and Is This the End of “Made for iPod” (TM)? Posted by Phillip Torrone, May 12th, 2011
blog.makezine.com/archive/2011/05/why-google-choosing-arduinomatters-and-the-end-of-made-for-ipod-tm.html

- [3] Thomas Brühlmann
Arduino Praxiseinstieg: Behandelt Arduino 1.0
ISBN 978-3-8266-9116-4 (Print); ISBN 978-3-8266-8342-8 (PDF)

- [4] Claus Kühnel
Arduino: Hard- und Software Open Source Plattform
ISBN 978-3 907857-16-8 (Print); ISBN 978-3-8448-9134-8 (eBook)

- [5] ATmega16U4/32U4 Preliminary
(file size: 6 22MB. 433 pages, revision G, updated: 02/2014)
http://www.atmel.com/Images/Atmel-7766-8-bit-AVR-ATmega16U4-32U4_%20Datasheet.pdf

- [6] Internal Temperature Sensor – Using the internal temperature sensor of the AVR Chip
http://playground.arduino.cc/Main/InternalTemperatureSensor

- [7] AVR122: Calibration of the AVR's internal temperature reference
http://www.atmel.com/Images/doc8108.pdf

- [8] cURL mit 6 praktischen Beispielen erklärt
http://blog.thomas-falkner.de/2011/01/25/curl-mit-6-praktischenbeispielen-erklaert/

- [9] 15 Practical Linux cURL Command Examples (cURL Download Examples)
http://www.thegeekstuff.com/2012/04/curl-examples/

- [10] Crontab Tutorial und Syntax:
Cronjobs unter Linux einrichten und verstehen
http://stetix.de/cronjob-linux-tutorial-und-crontab-syntax.html

- [11] OpenWRT – Linux distribution for embedded devices.
https://openwrt.org/

- [12] Writing and Compiling A Simple Program For OpenWrt
http://manoftoday.wordpress.com/2007/10/11/writing-and-compiling-asimple-program-for-openwrt/

Weiterführende Links:

Informationen und Quellcodes zum Beitrag
http://sourceforqe.net/proiects/arduinovnsnippets/

Webseite zum Buch
http://www.ckuehnel.ch/dokuwiki/doku.php?id=arduino_yun

Linux Wiki
https://openwrt.org/
http://de.linwiki.org/wiki/Hauptseite
http://wiki.ubuntuusers.de/Startseite
http://de.wikibooks.org/wiki/Linux-Kompendium
https://wiki.archlinux.de/
http://www.linux-magazin.de/
http://www.linux-fuer-alle.de/

7. Index

A

Abfrage der Umgebungstemperatur →

Access Point Mode →

AD/DA-Modul →

ADCSRA →

ADCSRB →

ADMUX →

AD-Umsetzer →

Ergebnis der Umsetzung →

Timing Diagram →

AP Mode →

AppendRow Choreo →

Arduino Webpanel →

Arduino Boards unterstützte →

Arduino IDE 1.5.4 Neuerungen →

Arduino Yún →

Blockschema →

Eigenschaften →

Gehäuse →

Inbetriebnahme →

PinOut →

Webinterface →

Arduino. h →

Ash →

Atheros AR9331 →,→

ATmega32u4 →
attachlnterrupt →

Ausgabe formatierte →

B

Bash →

Basic Calculator →
bc →,→

Bildverarbeitung Standardverfahren →
block-mount →

BogoMIPS →

Bridge-Library →

BusyBox →

C

C/C++ →
chmod +x →

Choreo →

Client for URLs →

Cloud Computing →

Cloud-Speicher →

Code generieren →

Compilierung bedingte →

COM-Port →

Credentials →,→,→
cron →

Cronjob →

Crontab →
cURL →,→

D

Dateimanager →

Datendurchsatz WLAN-Interface →

DA-Umsetzer →

Debugging-Ausgaben →
detachInterrupt →
df →

DHT22 →

DHT-Sensor-Library →
dmesg →

Interrupt externer →

E
echo →

Editor →

EICRA →

Ein-/Ausgabe digital →

Eingang analog →

Entwicklungsumgebung →

Ethernet-Schnittstelle →

F

Factory Image →

File-Download →

FilelO →

Filesystem initialisieren →

Free Running Mode →
fswebcam. →

G

Gehäuse →

Gmail →

Google eMail →

Google Tabellenkalkulation →

Google-Mailserver →

H

Hardware-UART →

Hash-Algorithmen →

Hashtag →

Hexeditor →

HTML-Datei index.html →
htop →

I

I/O Pins →

Alternativfunktionen →

Interrupt externer →

K
kmod-fs-ext4 →
kmod-fs-hfs →
kmod-fs-hfsplus →
kmod-fs-ntfs →
kmod-fs-reiserfs →
kmod-fs-vfat →
kmod-usb-storage →

Kommandoaufruf →

Kommunikation

I2C →
seriell →

SPI →

USB →

Kommunikationsschnittstellen →

Konfiguration werksseitige →

L

LCD Text- →

LCD2041 →

LeoShield →

Library

Bridge →, →

DHT →

FilelO →

Process →

SoftwareSerial →

SPI →

Wire →,→

Linino →

Linux-Tools →

LM135 →

Logitech C270 →

1s /dev/sd* →
lsusb →

Lua →,→

Lua-Script date.lua →
pretty-wifi-info.lua →

LuCl Webinterface →

M

Mail versenden →

MD5 →

Midnight Commander →

Multiplexereinstellung Single Ended Input →
myYun →

N
nano →

Network Diagnostics →

Netzwerk-Integration →

Nexmo →

O

OpenWRT →

OPKG →
ownCloud →
freier Account →

P

Paketmanager →

PCF8591 →

PIL →

Portieren von Programmen →

Portierung →

Programm
adda.ino →
blink.ino →

Debug_LCD.ino →

DHTtester.ino →

Externallnterrupt.ino →

FileIO.ino →
free_running_adc.ino →

LM335A_test.ino →

PCF8591 Moduletest.ino →
process.ino →
read_file.ino →
runShellCommands.ino →
sendMail.ino →

StatusMonitor.ino →

TembooTable.ino →

TembooTweet.ino →

TemperaturWebPanel.ino →
write_file.ino →

Programml LCD2041_Test.ino →

Pseudo-Zufallszahlen visualisieren →

PuTTY →

PWM Frequenz →

PWM-Ausgang →

Python →,→

Python Imaging Library →

Python Packages →

Python-Script RandomNumbers.py →

S

Schnittstellen →

SCP →

Secure-Shell-Protocol →

SHA1 →

Shared-Memory →

Shell-Script
boardinfo.sh →
cronscript.sh →
gdf.sh →

S50cron →
scale.sh →
sendmail.sh →
tr_image.sh →
tr_imagel.sh →

SourceForge →

Spannungsversorgung →

Speicher →

Speichererweiterung →

SSH →

SSID →

Status Overview →

Realtime Graphs →

Statusmitteilung →

System Scheduled Tasks →

T

Tastenentprellung →

Telefon-API →

Temboo →

Zugangsdaten →

Temboo Sketch Builder →

TembooAccount.h →,→

Temboo-Client →

TembooTable →

Temperatur- und Feuchtigkeitssensor →

Temperatursensor intern →

Temperatursensoren →

Tiefpass →

TMP36 →, →
touch →

Tweet →

Statusupdate →

Twitter →

Twitter StatusUpdate Choreo →

U

Upload eines Files →
uptime →, →

USB-Hub →

USB-Memory-Stick →

USB-Webcam →

V

Verbinden mit ArduinoYún →

Versenden einer eMail →

W

Webcam →
webcam.cfg →

Webzugriff auf ArduinoYun →

WLAN →

WPA2-Password →

Y

YunClient →

YunServer →

Z

Zeitzone →

Zepto Library →

Zufallszahl →

Zugangsdaten →

8. Abbildungsverzeichnis

Abbildung 1 Arduino Ethernet Shieid
Abbildung 2 Arduino Ethernet
Abbildung 3 Arduino Yún Vorderseite
Abbildung 4 Arduino Yún Rückseite
Abbildung 5 Arduino Yún Blockschema
Abbildung 6 Arduino Boards im Tool Menu

Abbildung 7 Arduino Yún Kommunikationsschnittstellen

Abbildung 8 Anzeige im Monitor
Abbildung 9 Arduino Yún im Netzwerk
Abbildung 10 WLAN-Konfiguration
Abbildung 11 WLAN-Restart
Abbildung 12 Webzugriff auf Arduino Yún
Abbildung 13 PuTTY Konfiguration

Abbildung 14 Zugriff auf die Kommandozeile mit PuTTY

Abbildung 15 WinSCP Anmeldung
Abbildung 16 WinSCP Konfiguration
Abbildung 17 Zugriff auf Directory /bin

Abbildung 18 Installation/Deinstallation Basic Calculator bc

Abbildung 19 Paketmanager im LuCI Webinterface

Abbildung 20 Arduino Webpanel
Abbildung 21 Arduino Yún Konfiguration
Abbildung 22 LuCI – Status Overview
Abbildung 23 LuCI – Realtime Load
Abbildung 24 LuCI – Realtime Traffic
Abbildung 25 LuCI – Network Utilities
Abbildung 26 LuCI – Scheduled Tasks
Abbildung 27 LuCI – Lua Module
Abbildung 28 Editieren mit nano
Abbildung 29 Midnight Commander mc
Abbildung 30 cURL Versionsabfrage
Abbildung 31 Filetransfer mit cURL
Abbildung 32 Versenden von eMail mitcURL
Abbildung 33 Prozessmonitor htop

Abbildung 34 Entwicklungstools und deren Versionen

Abbildung 35 Aufruf und Ausgabe des Shell-Scripts boardinfo.sh

Abbildung 36 Aufruf und Ausgabe Shell-Script scale.sh

Abbildung 37 md5sum im Einsatz
Abbildung 38 Eintragung in der Crontab
Abbildung 39 Crond gestartet?
Abbildung 40 Installation einer USB Webcam
Abbildung 41 Auslösen der Webcam
Abbildung 42 Konfiguration der Webcam

Abbildung 43 Auslösen der Webcam mit Konfigurationsfile

Abbildung 44 Shell Script tr_image.sh

Abbildung 45 Auslösen der Webcam und Datieren des Imagefiles

Abbildung 46 Datierte Imagefiles

Abbildung 47 Detektion eines USB-Memory-Sticks

Abbildung 48 Dateizugriff Memory-Stick

Abbildung 49 Aufruf und Ausgabe Python-Script RandomNumbers.py

Abbildung 50 Textkonvertierung beim CSV-File mit Excel (1)

Abbildung 51 Textkonvertierung beim CSV-File mit Excel (2)

Abbildung 52 Textkonvertierung beim CSV-File mit Excel (3)

Abbildung 53 Generierte Pseudo-Zufallszahien
Abbildung 54 Rotation Arduino Yun.jpg
Abbildung 55 ArduinoYun.jpg
Abbildung 56 ArduinoYun_45.jpg

Abbildung 57 Aufruf und Ausgabe Lua-Script date.lua

Abbildung 58 Aufruf und Ausgaben von pretty-wifi-info.lua

Abbildung 59 PinOut Arduino Yún

Abbildung 60 LeoShield

Abbildung 61 Terminalausgabe ExternalInterrupt.ino

Abbildung 62 DHT22

Abbildung 63 AD-DA-Umsetzung mit internen Ressourcen des Arduino

Abbildung 64 Ausgaben der AD-DA-Umsetzung

Abbildung 65 Timing Diagramm Free Running Mode

Abbildung 66 Ausgaben des Programms free_running_adc.ino

Abbildung 67 PCF8591 Module

Abbildung 68 Anzeigemöglichkeiten LCD2041 (Matrix Orbital)

Abbildung 69 Ausgabe der Funktion runCurl ()

Abbildung 70 Ausgabe der Funktion runCpuInfo ()

Abbildung 71 Ausgabe des Programms sendMail.ino

Abbildung 72 EmpfangeneMail

Abbildung 73 Ausgaben Programmbeispiel runShellCommands.ino

Abbildung 74 Ausgaben des Programms FileIO.ino

Abbildung 75 Temperaturabfrage
Abbildung 76 Datenfluss in die Temboo-Cloud
Abbildung 77 Temboo-Komponenten

Abbildung 78 Temboo Einstiegsseite für Arduino Yún

Abbildung 79 Tabelle TembooTable

Abbildung 80 Test AppendRaw Choreo

Abbildung 81 TembooTable nach dem Library Test

Abbildung 82 Code Generation für Arduino Yún

Abbildung 83 Rückmeldung bei fehlerfreier Übertragung

Abbildung 84 TembooTable nach dem Upload über den AppendRow Choreos

Abbildung 85 Serielle Ausgabe

Abbildung 86 Empfangene eMail

Abbildung 87 Vorbereitung des Tweets auf der Temboo Website

Abbildung 88 Von der Temboo Website gesendeter Tweet

Abbildung 89 Terminalausgaben TembooTweet.ino
Abbildung 90 Tweets in Twitter
Abbildung 91 Temboo Sketch Builder
Abbildung 92 Auswahl der Anwendung

Abbildung 93 Definieren der auszulösenden Aktion

Abbildung 94 Shell-Script gdf.sh im Editor

Abbildung 95 Aufruf df und gdf.sh

Abbildung 96 Arduino Yún Gehäuse von SB Components (UK)

Notizen

Ihre Meinung oder Ihre Erkenntnisse können auch anderen von Nutzen sein. Auf der Webseite zum Buch (www.ckuehnel.ch/Arduino_Yún.html) finden Sie einen Link, um uns entsprechende Hinweise mitzuteilen.

Bibliografische Information der Deutschen Nationalbibliothek

Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über http://dnb.d-nb.de abrufbar.

© 2014 Skript Verlag Kühnei, CH-8852 Altendorf

Dieses Buch und die beschriebenen Schaltungen, Verfahren und Programme wurden sorgfältig erstellt und getestet. Trotzdem können Fehler und Irrtümer nicht ausgeschlossen werden.

Verlag und Autor sind dankbar für Hinweise auf Fehler, übernehmen jedoch keinerlei Verantwortung für die uneingeschränkte Richtigkeit und Anwendbarkeit des Buchinhalts. Jegliche juristische Verantwortung und Haftung wird ausgeschlossen.

Die Informationen im vorliegenden Buch werden ohne Rücksicht auf einen eventuellen Patentschutz veröffentlicht. Alle in diesem Buch vorkommenden Marken- und Handelsnamen sind Eigentum ihrer jeweiligen Besitzer und unterliegen den einschlägigen gesetzlichen Bestimmungen. Das Fehlen einer gesonderten Kennzeichnung bedeutet nicht, dass es sich dabei um einen freien Namen handelt.

Dieses Buch ist als Ganzes und in Teilen urheberrechtlich geschützt.

Jede Verwertung ohne schriftliche Genehmigung des Verlags ist unzulässig und strafbar. Dies gilt insbesondere für Vervielfältigungen jeder Art, Übersetzungen, Mikroverfilmungen und für die Einspeicherung in elektronische Systeme.

Alle Rechte Vorbehalten. All rights reserved.

Der Linux-Pinguin ist ein Werk der Autoren Larry Ewing, Simon Budig und Anja Gerwinski.

Herstellung: BoD – Books on Demand, Norderstedt

ISBN 9783907857212