Gnublin Anleitung Starterkit by embedded projects GmbH

D I E E M B E D D E D L I N U X L E R N - U N D A U S B I L D U N G S P L AT T F O R M

[GNUBLIN-KIT FÜR AUTOMATISIERUNG]

t t t t

Y F

t t t t beliebigF Erweiterbarkeit

S F

[GNUBLIN STARTERKIT]

GNUBLIN embedded projects GmbH

Inhaltsverzeichnis Vorwort .......................................................................................................................... vii 1. Erste Schritte ................................................................................................................. 1 Auspacken und Prüfen des Inhalts ................................................................................. 1 Das Gnublin Board ..................................................................................................... 2 Bauteile .................................................................................................................... 4 Breadboard ........................................................................................................ 4 Widerstand ........................................................................................................ 4 Taster ............................................................................................................... 4 LED ................................................................................................................. 5 Potentiometer ..................................................................................................... 5 Transistor .......................................................................................................... 6 Gnublin anschließen .................................................................................................... 6 Mit dem Gnublin verbinden ......................................................................................... 8 Die Konsole ............................................................................................................. 10 Erster Kontakt mit der Konsole ........................................................................... 10 Verzeichnisse ................................................................................................... 11 Dateien anlegen und bearbeiten ........................................................................... 14 Netzwerk ................................................................................................................. 16 WLAN ............................................................................................................ 16 ssh Verbindung zum Gnublin herstellen ................................................................ 19 Cross-Compiler - Programme auf dem eigenem Rechner übersetzen ................................... 20 2. Experimente ................................................................................................................. 22 LED blinken lassen ................................................................................................... 22 Temperatur messen ................................................................................................... 28 Helligkeit messen ..................................................................................................... 32 Die E-Mail-Türklingel ............................................................................................... 36 Gieß mich! .............................................................................................................. 38 Programm verbessern ........................................................................................ 42 Briefkastensensor / Lichtschranke ................................................................................ 43 Anzeige mit LED ............................................................................................. 45 Benachrichtigung per E-Mail .............................................................................. 46 3. Auf zu neuen Projekten .................................................................................................. 49 A. Virtuelles Netzwerk über USB ........................................................................................ 51 Vorbereitungen ......................................................................................................... 51 Modul/Treiber laden .................................................................................................. 51 Internetverbindung von Host-PC nutzen ........................................................................ 51

iii

Abbildungsverzeichnis 1.1. Inhalt Starterkit ............................................................................................................ 2 1.2. Gnublin Aufbau ........................................................................................................... 2 1.3. Übersicht Gnublin Jumper Optionen ................................................................................ 3 1.4. Verbundene Reihen des Breadboards ............................................................................... 4 1.5. Tasterbeschaltung ......................................................................................................... 5 1.6. LED ........................................................................................................................... 5 1.7. Potentiometer ............................................................................................................... 5 1.8. Transistor Anschluss ..................................................................................................... 6 1.9. Gnublin anschließen ...................................................................................................... 7 1.10. Schematischer Aufbau Gnublin am PC ........................................................................... 8 1.11. Gnublin Login .......................................................................................................... 10 1.12. Video: Erste Schritte mit Gnublin ................................................................................ 10 1.13. Gnublin nach dem Login ............................................................................................ 11 1.14. der „ll“ Befehl .......................................................................................................... 12 1.15. der Texteditor nano ................................................................................................... 14 1.16. Übersicht Gnublin Jumper Optionen ............................................................................. 17 1.17. Gnublin mit WLAN Stick ........................................................................................... 18 2.1. LED1 auf dem Board .................................................................................................. 23 2.2. LED-Blinken-Programmablauf ...................................................................................... 25 2.3. Taster an GPIO11 ....................................................................................................... 26 2.4. Taster an GPIO11 — Aufbau ........................................................................................ 27 2.5. Analog-Digital-Comperator Funktionsweise — rote Linie ist die Abtastung des ADCs .............. 29 2.6. Prinzip eines Spannungsteilers ...................................................................................... 29 2.7. PTC-Schaltung ........................................................................................................... 30 2.8. PTC-Schaltung — Aufbau ............................................................................................. 31 2.9. Schaltung mit Helligkeitssensor ..................................................................................... 33 2.10. Schaltung mit Helligkeitssensor — Aufbau ..................................................................... 33 2.11. Abdunkeln des Sensors mit der Hand ........................................................................... 35 2.12. Taster an GPIO11 ..................................................................................................... 36 2.13. Taster an GPIO11 — Aufbau ....................................................................................... 37 2.14. Feuchtigkeitssensor .................................................................................................... 39 2.15. Schaltung Feuchtigkeitssensor ..................................................................................... 40 2.16. Schaltung Feuchtigkeitssensor — Aufbau ....................................................................... 40 2.17. Schema — Lichtschranke-im-Briefkasten (Lichtschranke blockiert) ..................................... 44 2.18. Schaltung Lichtschranke ............................................................................................. 44 2.19. Schaltung Lichtschranke — Aufbau .............................................................................. 45 2.20. Schaltung Lichtschranke mit Reset ............................................................................... 46 2.21. Schaltung Lichtschranke mit Reset — Aufbau ................................................................. 47 A.1. Netzwerkverbindungen bearbeiten ................................................................................. 52 A.2. IPv4-Einstellungen ..................................................................................................... 52

Tabellenverzeichnis 1.1. Inhalt Starterkit ............................................................................................................ 1 1.2. Zusammenfassung cd .................................................................................................. 13 1.3. WLAN in Betrieb nehmen ........................................................................................... 16

Liste der Beispiele 2.1. Spannungsteiler ausprobieren (Multimeter notwendig) ....................................................... 30 2.2. Programm anlegen ...................................................................................................... 38 2.3. Note ......................................................................................................................... 48

Vorwort Embedded Linux – Wie geht das? Was ist das? Und was kann man damit machen? Dieses Starterkit ermöglicht Einsteigern in Kontakt mit Hardware zu kommen. Viele Fragen hat man als Einsteiger, wenn man frisch mit diesem Thema beginnt. Zu den Fragen kommt noch die Ehrfurcht – hoffentlich mach ich nichts kaputt. Am Beispiel GNUBLIN zeigen wir, wie Embedded Linux funktioniert. Das Projekt GNUBLIN ist mit der Hochschule Augsburg gemeinsam entstanden, um eine Lern – und Ausbildungsplattform für Embedded Linux Einsteigern anbieten zu können. Gemeinsam wagen wir den Einstieg in die wichtigsten Komponenten von Hard- und Software. Ziel ist es mit verschiedenen Experimenten die Lust für eigene Anwendungen zu wecken. Wer träumt nicht davon, seine Kaffemaschiene fernzusteuern oder das traute Heim zu automatisieren? Damit das funktioniert muss man die wichtigsten Strukturen und Fachwörter aus den entsprechenden Hardund Softwaredisziplinen kennen. Die Motivation ist es, viele Menschen für Linux auf Mikrocontroller zu begeistern. Einfach soll man sich eigene Anwendungen, Produkte oder Steuerungen bauen können. Der Spaß am Basteln soll und muss im Vordergrund stehen. Viele der hier verwendeten Texte basieren auf unserem großartigen Community Wiki. Wir bedanken uns bei allen, die dazu beigetragen haben!

vii

Kapitel 1. Erste Schritte Sicher willst Du gleich loslegen und deine ersten Experimente mit dem GNUBLIN machen. Bevor wir jedoch damit beginnen können, müssen wir ein klein wenig Vorarbeit leisten. Wir müssen uns mit dem Board vertraut machen und mit den elektronischen Bauelementen, die wir in unseren Experimenten benutzen werden. Ganz wichtig ist es, dass Du das wichtigste Werkzeug in der Embedded Linux Welt überhaupt, die Konsole erstmal kennen lernst. Darüber hinaus musst Du ja wissen, wie du dein PC überhaupt mit dem GNUBLIN verbindest. Es folgt also ein klein wenig Theorie, die aber zwingend notwendig ist, damit du in die faszinierende Welt der Hardwareentwicklung mit Embedded Linux einsteigen kannst. Aber nach der Theorie geht es schon los mit den Experimenten, angefangen beim LED blinken bis hin zu Überwachung deiner Topfpflanzen oder des Briefkastens.

Auspacken und Prüfen des Inhalts Wenn du das Starterkit ausgepackt hast, überprüfe bitte anhand der Tabelle, ob alles vorhanden ist.

Tabelle 1.1. Inhalt Starterkit Menge

Bauteil

GNUBLIN Board

Mini-USB Kabel

USB-Adapter A-Buchse > 5 pol. mini B-Stecker

WLAN-Stick

Taster

PTC

Helligkeitssensor

10x

Kabel

Widerstand

kleines Breadboard

Potentiometer

LED

Transistor

Erste Schritte

Abbildung 1.1. Inhalt Starterkit

Das Gnublin Board Hier findest du eine Übersicht, was sich wo auf dem Gnublin Board befindet.

Abbildung 1.2. Gnublin Aufbau

Das Herzstück des Boards ist der Prozessor in der Mitte. Hier ist ein ARM 926 (LPC3131) mit 180 MHz verbaut. Ihm zur Seite steht ein 32 MB großer Arbeitsspeicher (großes IC auf dem Board). Unterhalb des Prozessors befindet sich der Micro-SD Kartenhalter. Die SD-Karte kann mit dem Programm "Gnublin-Installer" jederzeit wieder neu beschrieben werden, solltest du die Karte einmal bootunfähig oder anderweitig unbrauchbar gemacht haben. Neben dem Kartenhalter findest du den Gnublin Connector. Hier

Erste Schritte

sind einige Anschlüsse herausgeführt, wie z.B. die 3,3V Spannung, der I2C und SPI Bus, eine PWM Leitung, usw. Welche Signale wo genau angeschlossen sind, erkennst du am nachfolgenden Bild. Außerdem siehst du auf dem Gnublin Board auch 2 USB Buchsen. Eine dient als Konsole und Spannungsversorgung für das Board, die andere funktioniert wie eine normale USB Buchse, wie du sie auch aus einem normalen Computer kennst. Rechts siehst du dann verschiedene Anschlussklemmen. Die erste dient zum Anschluss einer externen Spannungsversorgung sowie als 3,3V Spannungsquelle. An der zweiten Buchsenreihe findest du 3 Ein-/Ausgänge, sowie einen analogen Eingang. Über die Jumper auf dem Board lassen sich bestimmte Einstellungen vornehmen. Welche das sind siehst du auf dem nächsten Bild

Abbildung 1.3. Übersicht Gnublin Jumper Optionen

Bei den Bootoptionen hast du die Wahl, ob du von der SD-Karte, der UART Schnittstelle oder von USB (DFU) aus booten willst. Die Standardeinstellung ist hier von der SD-Karte. USB-OTG (OTG = On the go) Jumper legen das Verhalten des Gnublin Boards an der USB-OTG Schnittstelle fest. Der OTG Jumper legt fest, ob sich das Gnublin wie ein Device (z.b. wie eine Maus, Tastatur etc.) verhält, oder wie ein Host (Wie ein Rechner an dem man eine Maus oder Tastatur anschließt). Der USB PWR Jumper bestimmt, ob das Gnublin das angeschlossene USB Gerät mit Spannung versorgt (Jumper auf "Host"), oder ob das Gnublin selbst als Gerät erkannt wird (Jumper auf "Device").

Erste Schritte

Bauteile Bevor wir die verschiedenen Komponenten aus dem Starterkit benutzen können, werfen wir einen kleinen Blick auf ihre Funktionsweise. Dies ist wichtig, damit wir die einzelnen Bauteile in den Experimenten auch richtig anschließen.

Breadboard Das Breadboard, oder auch Steckbrett genannt, bildet die Basis für all unsere Experimente. Auf das Board können die einzelnen Bauteile gesteckt werden, dabei ist immer eine Reihe durchkontaktiert (siehe Bild). Das heißt, dass alle Komponenten, welche in diese Reihe eingesteckt werden, miteinander verbunden sind. Das Tal in der Mitte bildet eine Barriere, es gibt also Rechts und Links des Tals jeweils durchkontaktierte Reihen.

Abbildung 1.4. Verbundene Reihen des Breadboards

Widerstand Dem Kit liegen vier Widerstände bei, dabei haben die Widerstände unterschiedliche Werte. Welchen Wert ein Widerstand hat kann man an den Farbringen ablesen. • 12 kOhm (braun, rot, orange) • 220 kOhm (rot, rot, gelb) • 4,7 kOhm (gelb, violett, rot)

Taster Der Taster hat vier Beinchen, wobei zwei immer miteinander verbunden sind. Beim Tastendruck werden alle vier Beinchen miteinander verbunden. Es ist sehr wichtig den Taster in der richtigen Position in die Schaltung einzubauen. Auf der Seite, wo die Beinchen außen sind, sind sie nicht miteinander durchkontaktiert, sondern mit den gegenüberliegenden.

Erste Schritte

Abbildung 1.5. Tasterbeschaltung

LED Die Leuchtdiode ist nur in eine Richtung leitend. Dort, wo sich am Kopf die flache Seite befindet, ist der Minus-Pol.

Abbildung 1.6. LED

Potentiometer Dem Kit liegt ein 10 kOhm Potentiometer bei. Das Potentiometer ist ein verstellbarer Widerstand. Das Potentiometer hat drei Beinchen, dabei liegt zwischen den äußeren beiden immer der komplette Widerstand, nur am mittleren ist der verstellbare Widerstand abrufbar. Dieser ergibt sich aus einem der äußeren Beinchen und dem Mittleren.

Abbildung 1.7. Potentiometer

Erste Schritte

Transistor Es befinden sich zwei Transistoren im Kit. Dabei handelt es sich um sogenannte NPN-Transistoren. Ein Transistor ist im Prinzip ein Schalter. Mit ihm können über einen Spannungspegel Ströme geschaltet werden. Ein Transistor hat drei Anschlüsse: Kollektor ©, Basis (B), Emitter (E). Bei einem NPN-Transistor ist der Kollektor immer der „Plus“-Pol und der Emitter der „Minus“-Pol. Am Basis wir die Schaltspannung angeschlossen, ist diese hoch genug, schaltet der Transistor von Kollektor nach Emitter durch und wird leitend. Wichtig ist, dass man den Transistor richtig anschließt (siehe Bild).

Abbildung 1.8. Transistor Anschluss

Bauelemente anschließen Damit die Bauelemente in das Steckbrett passen, müssen bei den meisten Bauelementen die Anschlussdrähte verbogen werden. Bei den Widerständen ist es am besten, alle gleich zu einem U zu biegen.

Gnublin anschließen Packe das Gnublin Board aus und schließe es wie auf dem folgenden Bild an:

Erste Schritte

Abbildung 1.9. Gnublin anschließen

Gnublin wird mit einem USB-Kabel an den PC angeschlossen. Die Verbindung hat zwei wesentliche Zwecke: • Stromversorgung des Boards per USB • Konsole für den Zugriff auf das Betriebssystem Gnublin ist ein autonomer "Mini-PC" mit Linux. Das bedeutet es läuft auf dem Board das Betriebssystem. Möchte man jetzt Daten auf dem Board anschauen, oder Programme starten und stoppen, braucht man eine "Konsole". Eine sehr einfache Konsole ist eine serielle Konsole. Auf dem Board befindet sich für diese serielle Konsole ein USB zu Seriell Wandler. Das hat den Vorteil, dass wir jetzt per USB-Kabel das Board zum einem mit Strom versorgen können und zum anderen mit einem PC uns auf das Board verbinden können. Auf dem PC wird anschließend ein sogenanntes Terminal Programm gestartet, welches die Kommunikation mit dem Gnublin erlaubt. Hier ersetzt das Terminal Programm sozusagen den nötigen "Bildschirm" und "Tastatur" direkt am Gnublin.

Erste Schritte

Abbildung 1.10. Schematischer Aufbau Gnublin am PC

Mit dem Gnublin verbinden Je nach Betriebssystem auf dem eigenen Rechner, gibt es verschiedene Vorgehensweisen wie wir uns mit dem Gnublin verbinden. Wir empfehlen dir die Verwendung von Ubuntu (am besten die aktuelle Langzeit Support Version (LTS)). Eine Anleitung zur Installation von Ubuntu findest du hier: http:// wiki.gnublin.org/index.php/Gnublin-Starterkit Wir verwenden picocom als Terminal Programm. Man kann picocom wie gewohnt über die Softwareverwaltung oder über die Konsole mit folgendem Befehl installieren: sudo apt-get install picocom Um sich nun mit dem GNUBLIN-Board zu verbinden, müssen picocom zwei Parameter mitgegeben werden: • die Baudrate • die zu verwendende Schnittstelle (das Device). Normalerweise ist das Device unter /dev/ttyUSB0 zu finden. Es kann aber vorkommen, dass dem Device eine andere Nummer, z.B. ttyUSB1, zugewiesen wird. Um herauszufinden, welche Nummer dem Device

Erste Schritte

zugewiesen wurde, rufst du einfach dmesg in der Konsole auf, nachdem du das GNUBLIN-Board per USB-Kabel mit dem PC verbunden hast: dmesg ... [ 4073.033436] usb 3-1.4: cp210x converter now attached to ttyUSB0 ... Um die Verbindung zum GNUBLIN-Board herzustellen, kann man picocom mit root-Rechten starten: sudo picocom -b 115200 /dev/ttyUSB0 Der Parameter -b 115200 legt eine Baudrate von 115200 bit/s fest. Will man das Terminal beenden, nimmt man hierzu die folgende Tastenkombination: STRG-A-X

picocom mit normalen Rechten Alternativ zum Start von picocom mit root-Rechten ist es möglich, den aktuellen Benutzer zur gleichen Gruppe hinzuzufügen, zu der auch das Device gehört. Dann sind für picocom keine rootRechte erforderlich. Die Schritte 1 bis 4 sind nur einmalig auszuführen. Danach kann picocom immer ohne rootRechte gestartet werden. Schritt 1: Herausfinden, zu welcher Benutzergruppe das Device gehört: ls -l /dev/ttyUSB0 crw-rw---- 1 root dialout 188, 0 Feb 8 15:38 /dev/ttyUSB0 Man sieht, dass das Device ttyUSB0 zur Benutzergruppe dialout gehört. Schritt 2: Den aktuellen Benutzer zur dialout-Gruppe hinzufügen: sudo adduser Benutzer dialout Für Benutzer muss man den aktuellen Benutzernamen einsetzen. Schritt 3: Damit die geänderte Einstellung wirksam wird, muss man sich einmal vom System abund wieder anmelden. Schritt 4: Die eigene Gruppenzugehörigkeit überprüfen: id -n -G ... adm dialout cdrom sudo ... In der Auflistung findet sich jetzt u. a. auch die dialout-Benutzergruppe. Schritt 5: Picocom wird wie oben, nur ohne sudo-Kommando, gestartet: picocom -b 115200 /dev/ttyUSB0

Erste Schritte

Es sollte nun in der Konsole etwas passieren. Falls nicht, drücke einmal die Enter-Taste. Passiert immer noch nichts, drücke einmal den Reset-Taster auf dem Gnublin-Board. Es sollten nun verschiedene Meldungen auftauchen bis du den Gnublin Anmeldeschirm siehst:

Abbildung 1.11. Gnublin Login

Tippe einfach den namen „root“ ein und drücke Enter. Du bist jetzt mit dem Gnublin Board verbunden! Was man mit dieser Konsole so alles machen kann, erfährst du im nächsten Kapitel: Die Konsole

Abbildung 1.12. Video: Erste Schritte mit Gnublin

Die Konsole Wenn man mit dem Gnublin verbunden ist, landet man auf der Konsole. Doch was ist die Konsole? Und was kann man damit machen? Dieses Kapitel gibt einen Überblick über die wichtigsten Befehle um das Gnublin bedienen zu können. Wir haben vorhin, als wir uns mit dem Gnublin verbunden haben, schon eine Konsole zu Gesicht bekommen.

Erster Kontakt mit der Konsole Üben, üben und nochmals üben. Das A und O bei dem Umgang mit Embedded Linux ist ein sicherer Umgang mit der Konsole. In diesem Abschnitt sind einige Befehle oder Anwendungen in der Konsole gezeigt.

Erste Schritte

• Man muss sicher im Verzeichnisbaum navigieren können • Ordner anlegen und wechseln können • Einfach Textdateien anlegen und bearbeiten bzw. ausgeben können Ist man mit dem Gnublin verbunden sehen wir erst einmal so etwas:

Abbildung 1.13. Gnublin nach dem Login

Ist die Konsole geöffnet blinkt normalerweise ein Cursor. Dies bedeutet man kann jetzt Befehle in die Konsole eingeben. Vor dem blinkenden Cursor steht der Benutzername, mit dem man gerade angemeldet ist und der Computername. Beide werden durch das @-Zeichen getrennt. In unserem Fall steht hier root@gnublin:~#

Verzeichnisse Nach dem Anmelden befindet man sich automatisch im eigenen Home-Verzeichnis. In welchem Verzeichnis man sich befindet kann man einfach mit dem Befehl pwd (parent work directory) ermitteln. Dafür gibt man nur pwd beim blinkenden Cursor ein und drückt einmal die Enter-Taste. Ausgabe: root@gnublin:~# pwd /root root@gnublin:~# Man sieht jetzt, wo man ist. In diesem Fall befinde ich mich im Ordner /root.

Inhalt des aktuellen Verzeichnis ausgeben Möchte man wissen, was alles im aktuellen Verzeichnis (/root) liegt, nimmt man einfach den Befehl ls. ls listet alle vorhanden Dateien und Ordner auf:

Erste Schritte

root@gnublin:~# ls deb examples root@gnublin:~# Hier sieht man, dass bei uns zwei Ordner in unserem Home Verzeichnis liegen. Man kann dem Befehl aber noch einen Parameter mitgeben, der die Ausgabe etwas abändert. Wir tippen hierzu ls -l root@gnublin:~# ls -l total 2 drwxr-xr-x 2 root root 1024 May 16 2013 deb drwxr-xr-x 16 root root 1024 May 16 2013 examples root@gnublin:~# Hier sieht man, dass man die Objekte im Verzeichnis als schöne Liste ausgegeben bekommt. Wer nicht jedes mal ls -l tippen will, für den gibt es den Befehl ll. Dieser macht nichts anderes als ls -l

Abbildung 1.14. der „ll“ Befehl

root@gnublin:~# ll total 2 drwxr-xr-x 2 root root 1024 May 16 2013 deb drwxr-xr-x 16 root root 1024 May 16 2013 examples root@gnublin:~# Hier sieht man, dass in unserem aktuellen Verzeichnis /root zwei Ordner liegen mit den Namen deb und examples.

Erste Schritte

Verzeichnis wechseln Von diesem Ort aus kann man sich auch an andere Stellen im Dateisystem bewegen. In den examples Ordner kommt man mit der Eingabe von: root@gnublin:~# cd examples jetzt hat sich auch der sogenannte prompt geändert: root@gnublin:~/examples# so weiß man immer wo man sich gerade befindet. Im Zweifelsfall hilft aber immer pwd weiter.

Wechseln in das Homeverzeichnis Nach den Befehlen zuvor befindet sich jetzt eventuell jeder Leser in einem anderen Ordner. Wir möchten jetzt gezielt wieder in das eigene Homeverzeichnis wechseln. Dies macht man am einfachsten, wenn man den Befehl cd tippt. root@gnublin:~/examples# cd Jetzt ist man wieder im eigenen Home-Verzeichnis. (/root)

Zusammenfassung cd Tabelle 1.2. Zusammenfassung cd Befehl

Wirkung

wechseln ins Homeverzeichnis

cd /Pfad/zum/Ordner

wechselt in das Verzeichnis /Pfad/zum/Ordner

cd Ordner

wechselt in das Verzeichnis “Ordner” im aktuellen Verzeichnis

cd ..

wechselt in ein Verzeichnis höher

Verzeichnisse anlegen Im nächsten Schritt legen wir einen Ordner für unsere Experimente an. root@gnublin:~# mkdir experimente mit ll kann man prüfen ob dies geklappt hat. Es sollte nun ein Ordner experimente auftauchen. root@gnublin:~# ll total 3 drwxr-xr-x 2 root root 1024 May 16 2013 deb drwxr-xr-x 16 root root 1024 May 16 2013 examples drwxr-xr-x 2 root root 1024 Jan 1 00:19 experimente

Erste Schritte

Dateien anlegen und bearbeiten Im nächsten Schritt legen wir eine Datei an. Um eine Datei typischerweise anlegen zu können benötigen wir, wie in der Welt der grafischen Anwendungen, ein Programm. Unter den grafischen Umgebungen würde man jetzt z.B. das Office Paket starten und über den Menüpunkt Neue-Datei ein neues Dokument anlegen. Wie macht man das jetzt auf der Konsole? Bevor wir das machen, muss man wissen, dass man eigentlich nur ganz einfache Textdateien auf der Konsole anlegen und verwalten bzw. editieren kann. Das sind dann primär Programme, Dateien für Messwerte oder Ergebnisse von Programmen bzw. einfache Dokumentationen oder Einstellungen am Betriebssystem. Daher reicht uns auch ein einfacher Texteditor auf der Konsole um Dateien anlegen und bearbeiten zu können. Die einfachste Art und Weise eine leere Textdatei anzulegen ist der Befehl touch. root@gnublin:~# touch test.txt Prüft man mit dem Befehl ll ob die Datei angelegt ist, findet man diese jetzt vor.

Texteditor nano Wir möchten jetzt „Hallo GNUBLIN“ in die Datei schreiben. Dafür öffnen wir einen Editor auf der Konsole root@gnublin:~# nano test.txt

Abbildung 1.15. der Texteditor nano

Der Cursor blinkt genauso wie am Anfang bei der Konsole und wartet auf Texteingaben. Man kann jetzt „Hallo GNUBLIN“ mal eingeben. Jetzt muss die Datei gespeichert werden, damit der Inhalt nachdem beenden des Editors erhalten bleibt. Dies macht man ebenfalls über die Tastatur. Dafür hält man die STRG-Taste gedrückt und drückt parallel

Erste Schritte

einmal kurz auf das o (Buchstabe O wie Otto) STRG-o. Jetzt erscheint unten eine Zeile mit dem Dateinamen. Drückt man jetzt Enter ist der Inhalt gespeichert. Jederzeit kann man jetzt weitere Inhalte in die Datei eingeben. Zum Schluss sollte man nochmal mit STRG-o speichern und Nano mit STRG-x auf gleiche Art und Weise wie beim Speichern beenden. Hat man vor dem Schließen nicht gespeichert, fragt Nano sicherheitshalber nochmal nach, ob man doch nicht noch schnell speichern möchte. Jetzt haben wir unsere erste Datei angelegt. Einfache Programme kann man so später auch auf dem GNUBLIN schreiben, bzw. zumindest Einstellungen am laufenden Betriebssystem vornehmen.

Dateien kopieren / löschen und umbenennen Oft muss man Dateien kopieren, löschen oder umbenennen. Das geht wie folgt. Datei kopieren: root@gnublin:~# cp <Quelldatei> <Zieldatei/Zielpfad> Beispiel: root@gnublin:~# cp test.txt test_sicherung.txt Datei umbenennen: root@gnublin:~# mv <Quelldatei> <Zieldatei/Zielpfad> Beispiel: root@gnublin:~# mv test.txt meintest.txt Datei löschen: root@gnublin:~# rm <Datei> Beispiel: root@gnublin:~# rm meintest.txt

Verzeichnisse kopieren / löschen und umbenennen Das gleiche kann man mit ganzen Verzeichnissen machen. Verzeichnis kopieren: root@gnublin:~# cp -r beispiele beispiele_sicherung Verzeichnis umbenennen: root@gnublin:~# mv beispiele_sicherung beispiele_sicherung_aktuell Verzeichnis löschen: rm -Rf beispiele_sicherung

Erste Schritte

Netzwerk Ein wesentlicher Vorteil bei der Verwendung eines Embedded-Linux-Boards anstelle eines schlichten Mikrocontrollers ist, dass das Betriebssystem einem viel Arbeit bei der Anbindung von Hardware abnimmt. Und da Linux seit jeher ein Netzwerkbetriebssystem ist, gilt dies auch bei der Anbindung an das Netzwerk. Ist das GNUBLIN mit dem Netzwerk verbunden, erlaubt dies zusätzlich weitere Anwendungen. So können Daten an andere Rechner übermittelt werden oder eine Webseite auf dem Board laufen, so wie man es zum Beispiel schon von seinem Router zu Hause kennt. Es gibt verschiedene Wege das Gnublin mit dem Netzwerk zu verbinden und zu administrieren. Hier stellen wir kurz vor, wie wir den beiliegenden WLAN-Stick in Betrieb nehmen können.

Virtuelles Netzwerk Wer die Internetverbindung über das WLAN nicht nutzen möchte oder kann, der findet im Anhang eine Anleitung, wie man über die USB-Verbindung des GNUBLIN ein virtuelles Netzwerk aufbaut. Die Internetverbindung über USB bedarf einer größeren Konfiguration als das WLAN und ist für Anfänger schwieriger nachzuvollziehen.

WLAN Möchte man auf den internen Webserver des Gnublins von einem Smartphone oder Browser aus zugreifen, oder soll Gnublin Daten an einen Server senden, kommt man um eine Internetverbindung nicht herum. Möchte man kein Kabel verwenden bietet sich hier WLAN optimal an. In diesem Starterkit befindet sich bereits ein WLAN-Stick. Wir beschreiben hier nun, wie wir diesen in Betrieb nehmen. Wir brauchen:

Tabelle 1.3. WLAN in Betrieb nehmen Menge

Bauteil

Gnublin-Board

USB WLAN-Stick

USB-Adapter A-Buchse > 5 pol. mini B-Stecker

Bevor man den USB zu WLAN Adapter an Gnublin anschließt, muss der Jumper "Host" gebrückt sein (Zwischen den beiden USB Buchsen) und der Jumper J1 auf Position "H" stecken (neben der 2. USB Buchse). Siehe auch die Beschreibung der Jumper:

Erste Schritte

Abbildung 1.16. Ă&#x153;bersicht Gnublin Jumper Optionen

Dann stecken wir den WLAN Adapter an unser Gnublin Board an:

Erste Schritte

Abbildung 1.17. Gnublin mit WLAN Stick

Für eine einfache Konfiguration der WLAN Schnittstelle existiert das Programm gnublin-wlan. Das Programm wird folgendermaßen aufgerufen: gnublin-wlan -s <SSID> -k <Schlüssel> -t <dhcp/static> Wobei <SSID> der Name des Access-Points ist und <Schlüssel> der WLAN Schlüssel ist (wep/wpa/ wpa2). Nach dem Parameter -t kann man wählen, ob man eine statische IP-Adresse (static) einstellen will oder eine IP-Adresse automatisch beziehen will (dhcp). Will man die IP-Adresse statisch einstellen so kann man mit dem Parameter -i die IP-Adresse bestimmen und mit dem Parameter -g die Gateway-Adresse (IP-Adresse des Routers). Ein kleines Beispiel: Unser Netzwerk heißt "zuhause" und unser WLAN-Passwort lautet "gnublin". Die Netzwerkadresse holen wir uns per DHCP automatisch. gnublin-wlan -s zuhause -k gnublin -t dhcp Zum testen, ob man eine funktionierende Internetverbindung besitzt kann man ganz einfach den Befehl ping benutzen: root@gnublin:~# ping www.gnublin.org Es folgt in etwa so eine Ausgabe: PING www.gnublin.org (46.163.117.240) 56(84) bytes of data. 64 bytes from lvps46-163-117-240.dedicated.hosteurope.de (46.163.117.240): icmp_req=1 ttl=53 time=34.4 ms 64 bytes from lvps46-163-117-240.dedicated.hosteurope.de (46.163.117.240): icmp_req=2 ttl=53 time=34.2 ms

Erste Schritte

64 bytes from lvps46-163-117-240.dedicated.hosteurope.de (46.163.117.240): icmp_req=3 ttl=53 time=40.0 ms 64 bytes from lvps46-163-117-240.dedicated.hosteurope.de (46.163.117.240): icmp_req=4 ttl=53 time=33.9 ms 64 bytes from lvps46-163-117-240.dedicated.hosteurope.de (46.163.117.240): icmp_req=5 ttl=53 time=33.7 ms Wir brechen den Ping mit STRG-c ab. Nun ist der WLAN-Stick eingerichtet und wir sind mit dem Internet verbunden.

ssh Verbindung zum Gnublin herstellen Secure Shell (SSH) ist ein Netzwerkprotokoll mit dem man eine sichere Verbindung zu einem entfernten Rechner herstellen kann. Man verbindet sich dabei mit dem Terminal des anderen Rechners und man kann sich so im Terminal des Rechners bewegen wie wenn man direkt daran angeschlossen wäre. Es ist ebenfalls möglich via SFTP Dateien auszutauschen. Wir zeigen in diesem Kapitel, wie wir uns per SSH auf unser Gnublin-Board verbinden. Damit man sich per SSH mit dem GNUBLIN verbinden kann, muss der SSH-Server auf dem GNUBLIN laufen. Im Regelfall läuft SSH von vornherein. Dies kann man auch schnell überprüfen: root@gnublin:~# ps aux | grep ssh Damit man sich nun von seinem Rechner aus verbinden kann, muss für den Benutzer root auf dem GNUBLIN ein Passwort gesetzt sein. root@gnublin:~ passwd Nun steht einem nichts mehr im Weg sich über das Netzwerk mit dem GNUBLIN zu verbinden. Man braucht lediglich die IP-Adresse des GNUBLINs. Diese kann man mit ifconfig herausfinden. Auf dem Hostrechner muss der ssh-client installiert sein, bei vielen Linux-Distributionen wie Ubuntu ist dieser von vornherein vorhanden. Gibt man dann ein: user@develop-pc:~# ssh root@192.168.0.10 Die IP-Adresse muss man natürlich durch die des Gnublins ersetzen. Beim ersten Mal wird man gefragt ob man den public key des GNUBLINs annehmen möchte, das bestätigt man mit yes. Nach der Passwortabfrage ist man dann mit dem GNUBLIN verbunden. Um die Verbindung wieder zu trennen gibt man exit ein: root@gnublin:~# exit

Dateien vom/auf das Gnublin transferieren SCP dient der Dateiübertragung über eine SSH-Verbindung. Mann muss sich dazu nicht wie oben beschrieben per SSH mit dem GNUBLIN verbinden, lediglich der SSH-Server muss auf dem Board laufen. Der scp-Befehl ähnelt dem cp-Befehl: scp Quelldatei.bsp Benutzer@Host:Verzeichnis/Zieldatei.bsp Das sieht dann so aus: user@develop-pc:~# scp beispiel.txt root@192.168.0.10:

Erste Schritte

Die IP-Adresse muss natürlich wieder durch die des Zielsystems ersetzt werden. Hinter dem Doppelpunkt gibt man das Zielverzeichnis an, gibt man nichts an, wird die Datei automatisch in das Heimverzeichnis des Benutzers abgelegt, hier also /root.

Cross-Compiler - Programme auf dem eigenem Rechner übersetzen Der Quellcode unserer Programme muss in der Regel übersetzt werden, dies nennt man auch kompilieren. Beim Kompilieren wird das Programm in für den Prozessor lesbare Befehle übersetzt. C und C++ sind solche Programmiersprachen, bei denen ein Übersetzungsvorgang nötig ist, bevor man das Programm starten kann. Der Übersetzungsvorgang braucht in der Regel relativ viel Rechenleistung. Da das GNUBLIN nur über einen 180 MHz Prozessor verfügt, braucht der Vorgang entsprechend lange (angefangen bei mehreren Sekunden bis Minuten). Abhilfe schafft hier, die Übersetzung des Programms auf einem normalen Desktoprechner durchzuführen und anschließend die ausführbaren Dateien auf das GNUBLIN zu kopieren. Da sich aber der Prozessor in einem normalem Computer grundlegend von einem ARM-Prozessor, wie er auf dem GNUBLIN verbaut ist, unterscheidet, braucht man hier spezielle Compiler (Übersetzungsprogramme). Diesen sogenannten Cross-Compiler müssen wir zunächst auf unserem Desktoprechner installieren.

Wann brauche ich den Cross-Compiler Ab wann du mit dem Cross-Compiler arbeiten musst, wird in dem Versuchen extra erwähnt. Die ersten Experimente kann man auch ohne Cross-Compiler durchführen. Man kann also das Kapitel erst mal überspringen und dann hierher zurückkommen. Herunterladen der Entwicklungsumgebung http://gnublin.org/downloads/eldk-eglibc-i686-arm-toolchain-qte-5.2.1.tar.bz2 wget http://gnublin.org/downloads/eldk-eglibc-i686-arm-toolchain-qte-5.2.1.tar.bz2 Archiv entpacken: sudo tar xjf eldk-eglibc-i686-arm-toolchain-qte-5.2.1.tar.bz2 -C / Dieser Befehl extrahiert den Inhalt des Archivs eldk-eglibc-i686-arm-toolchain-qte-5.2.1.tar.bz2. Der Cross-Compiler wird in das Verzeichnis /opt/eldk-5.2.1/ kopiert. Der Befehl benötigt root-Rechte, weil das Archiv nach / entpackt wird. Auf Distributionen, die nicht sudo verwenden, muss man zunächst root werden (su) und dann den obigen Befehl ohne sudo ausführen. Skript für Umgebungsvariablen erstellen: Um die Umgebungsvariablen so zu setzen, dass das Hostsystem den Cross-Compiler verwenden kann, muss ein Skript in /opt/eldk-5.2.1/set.sh erstellt werden. Download: wget http://gnublin.org/downloads/set.sh Kopieren an eine geeignete Stelle z.B.: sudo mv set.sh /opt/eldk-5.2.1/ Bevor der Cross-Compiler verwendet werden kann, müssen die Umgebungsvariablen gesetzt werden. Dies erreicht man duch "sourcen" des gerade angelegten Skriptes:

Erste Schritte

. /opt/eldk-5.2.1/set.sh Man beachte, dass das Skript nicht ausgeführt, sondern gesourced wird. Das heißt, man muss den Befehl genau in dieser Form eingeben: Punkt, Leerzeichen, Pfad. Der Cross-Compiler kann jetzt verwendet werden: arm-linux-gnueabi-gcc -v Nun können wir den Cross-Compiler mit einem kleinen Hello-World-Programm in C ausprobieren. Die Datei hallo.c können wir auf unserem Desktoprechner mit einem normalen Editor wie gedit erstellen. #include <stdio.h> int main(void) { printf("Hello World!\r\n"); return 0; } Kompiliert wird die Datei dann mit diesem Befehl: user@dev-pc ~ $ arm-linux-gnueabi-gcc -o hello hello.c Anschließend könnte man die Datei auf das GNUBLIN kopieren, wie wir es im Kapitel zuvor gelernt haben, und ausführen. Bei einem C++ -Programm würde der Befehl natürlich so lauten: user@dev-pc ~ $ arm-linux-gnueabi-g++ -o hello hello.c Noch einmal kurz die Schritte: 1. Programm schreiben auf dem Desktoprechner mit Texteditor und abspeichern 2. Programm Kompilieren mit dem Befehl user@develop-pc:~# arm-linux-gnueabi-g++ 3. Programm auf das GNUBLIN kopieren user@develop-pc:~# root@192.168.0.10:experimente\

scp

programm

Kapitel 2. Experimente Nun aber genug von der trockenen Theorie rund um Linux, wir wollen jetzt endlich loslegen und ein paar Experimente mit unserem Linux-Board machen. Stück für Stück werden wir in den Experimenten die Möglichkeiten mit unserem GNUBLIN-Board kennenlernen und am Ende steht den eigenen Projekten nichts mehr im Weg.

Fertigen Quelltext verwenden Du findest die Dateien mit dem Quelltext zu den einzelnen Experimenten auch auf dem GNUBLIN im Ornder /root/examples/starterkit/. Du kannst bei den Experimenten die fertigen Dateien verwenden. Alle Dateien, die wir in unseren Experimenten erstellen, legen wir im Ordner /root/experimente/ ab. Diesen Ordner haben wir bereits oben bei dem Abschnitt über Ordner anlegen erstellt. root@gnublin:~# cd /root/experimente Optional findest du die neusten Quelltexte auf der Internetseite http://wiki.gnublin.org/index.php/Gnublin-Starterkit bzw die Quelltexte direkt: user@develop-pc:~$ kit-source.tar.gz

wget

http://gnublin.org/downloads/starter-

LED blinken lassen Das LED-Blink-Programm ist das “Hallo Welt“ in der Hardwarewelt, also fangen auch wir hier mit diesem einfachem Schritt an. Stück für Stück sehen wir, wie einfach es ist Hardware unter Linux anzusteuern.

Materialliste • 1x GNUBLIN • 1x Taster • 1x 12 kOhm Widerstand (braun, rot, orange) • 1x Steckbrett Wir wollen die LED1, die schon fest auf dem GNUBLIN verbaut ist, blinken lassen. Die LED1 findet ihr gleich neben der grünen Power-LED auf dem Board.

Experimente

Abbildung 2.1. LED1 auf dem Board

Die LED ist an einem so genannten GPIO (general-purpose input/output) angeschlossen. GPIOs sind digitale Ein- und Ausgänge, d.h. sie können nur zwei Zustände annehmen, 1 und 0, wobei 1 der Systemspannung von 3,3V entspricht und 0 gleich Ground (GND) also 0V ist. Die Ports können sowohl in die Zustände geschaltet werden (Ausgang) oder aber auch einen externen Zustand erkennen (Eingang). Das GNUBLIN Standard, das wir hier im Starterkit verwenden, hat drei GPIO-Ports und einen für die LED1. Zuerst schalten wir die LED einmal per Hand ein und aus. Das schaffen wir indem wir in Linux in die richtigen Dateien ein paar Werte schreiben. In Linux ist der Zugriff auf die Hardware prinzipiell über Dateizugriffe gelöst. Für die verschiedenen Hardwarekomponenten werden Dateien angelegt, in die dann die entsprechenden Befehle geschrieben werden. Nun aber zu unsere LED, die ist am GPIO 3 angeschlossen. Damit wir sie verwenden können müssen wir den Port erst einmal aktivieren: root@gnublin:~/experimente# echo “3” > /sys/class/gpio/export Dieser Befehl schreibt eine 3 in die Datei export, dadurch wird der GPIO 3 aktiviert. Ob das ganze erfolgreich war, können wir jetzt überprüfen: root@gnublin:~/experimente# ll /sys/class/gpio Es sollte nun ein Ordner mit dem Namen gpio3 existieren. Da wir die LED ja schalten wollen, müssen wir den Port noch als Ausgang deklarieren: root@gnublin:~/experimente# echo “out” > /sys/class/gpio/gpio3/direction Nun können wir die LED auch schon einschalten:

Experimente

root@gnublin:~/experimente# echo 1 > /sys/class/gpio/gpio3/value Die rote LED1 sollte nun leuchten, wenn alles geklappt hat. Die LED schaltet man ganz einfach aus, in dem man value auf 0 setzt: root@gnublin:~/experimente# echo 0 > /sys/class/gpio/gpio3/value Wenn wir unsere LED jetzt zum Beispiel immer für zwei Sekunden einschalten wollen, dann ist es mühsam das ganze per Hand zu machen. Stattdessen schreiben wir uns ein Shell-Skript, das die Befehle für uns ausführt, dann müssen wir nur einmal das Skript starten. Shell-Skripte sind kleine Programme, die einfach Kommandozeilenbefehle ausführen, also das was wir vorhin per Hand getippt haben. Natürlich gibt es in den Skripten auch noch ein paar Befehle, die auf einer Kommandozeile nicht verwendet werden, wie etwa Schleifen oder Variablen. Unser Shell-Skript sieht dann so aus: #!/bin/bash GPIO=3 echo $GPIO > /sys/class/gpio/export echo “out” > /sys/class/gpio/gpio3/direction echo 1 > /sys/class/gpio/gpio3/value sleep 2 echo 0 > /sys/class/gpio/gpio3/value Den Quellcode legen wir in der Datei led.sh ab: root@gnublin:~/experimente# nano led.sh Um das Programm ausführen zu können, ändern wir die Rechte der Datei: root@gnublin:~/experimente# chmod +x led.sh Nun können wir das Programm starten: root@gnublin:~/experimente# ./led.sh Im Programm finden wir die Befehle wieder, die wir schon oben verwendet haben um die LED ein- und auszuschalten. Die Zahl Drei wurde jedoch durch die Variable GPIO ersetzt, die in der ersten Zeile mit 3 belegt wurde. Der Variablenwert wird mit $GPIO in den Befehlen wieder abgerufen. sleep 2 sorgt für eine Pause von zwei Sekunden, bis die LED wieder ausgeschaltet wird. Nun wollen wir die LED blinken lassen, also immer wieder an und ausschalten.

Experimente

Abbildung 2.2. LED-Blinken-Programmablauf

Anstelle der Befehle vorhin verwenden wir jetzt die gnublin-tools, das sind Kommandozeilenprogramme, die einem einen einfachen Zugang zu den meisten GNUBLIN-Schnittstellen aus der Kommandozeile heraus geben. Hier verwenden wir das Tool gnublin-gpio. Das Tool verfügt über mehrere Parameter: -o <X>

setzt GPIO als Ausgang mit dem Wert X, 1 = high, 0 = low

-i

setzt GPIO als Eingang

-p <X>

gibt den verwendeten GPIO-Port an

-h

zeigt die Hilfe mit allen verfügbaren Parametern

Das fertige Skript sieht man im folgendem Listing: #!/bin/bash # Onboard-LED blinken GPIO=3

#Variable für den GPIO-Port

# für immer blinken while [ "1" = "1" ]; do gnublin-gpio -o 1 -p $GPIO sleep 1 gnublin-gpio -o 0 -p $GPIO sleep 1 done

#LED an # 1 Sekunde warten #LED aus # 1 Sekunde warten

Experimente

Diesen Quellcode schreiben wir in die Datei blink.sh mit den Editor nano: root@gnublin:~/experimente# nano blink.sh Ob alles funktioniert sehen wir, wenn wir das Programm nun ausführen: root@gnublin:~/experimente# ./blink.sh Die LED sollte nun im Sekundenrhythmus blinken. Mit STRG-c können wir das Programm wieder abbrechen. Das Ein- und Ausschalten der LED erfolgt in einer Endlosschleife, zwischen while und done, in der zwischen den Befehlen jeweils eine Pause von einer Sekunde mit sleep 1 eingelegt wird.

GPIO als Parameter übergeben Anstatt die GPIO Nummer (hier 3) im Quelltext anzugeben ist es auch möglich diese beim Programmaufruf als Parameter zu übergeben. Die Variable $1 steht für den Ersten Parameter nach dem Programmnamen beim Aufruf. Wenn wir unser Programm umbauen, indem wir in Zeile 4 die 3 durch $1 ersetzen, können wir den Port nun ganz einfach variieren. Unser Programmaufruf um die LED anzusprechn sieht dann ganz einfach so aus: root@gnublin:~/experimente# ./blink.sh 3 Wie schon erwähnt, dienen GPIOs auch als Eingang, um z.B. einen Tasterzustand auszulesen, um den Port in diesen Modus zu schalten, müssen wir in die Datei direction den Wert in schreiben, danach kann man den Wert bei value auslesen. root@gnublin:~/experimente# echo “in” > /sys/class/gpio/gpio11/direction root@gnublin:~/experimente# cat /sys/class/gpio/gpio11/value Oder mit dem GNUBLIN-Tool: root@gnublin:~/experimente# gnublin-gpio -i -p 11 Das probieren wir doch gleich einmal aus. Dazu schließen wir den Taster, der im Starterkit liegt, wie im folgendem Bild zu sehen an den GPIO11 des GNUBLINs an.

Abbildung 2.3. Taster an GPIO11

Experimente

Abbildung 2.4. Taster an GPIO11 — Aufbau

Wenn wir den Taster jetzt drücken und gleichzeitig den Wert des GPIO11 abfragen, dann müssten wir den Wert 0 erhalten. Mit dem Taster an unserem Board können wir das Programm oben jetzt so umschreiben, dass die LED solange angeht, wie wir die Taste drücken und beim loslassen wieder ausgeht. So ergibt sich das angepasste Skript: #!/bin/bash # Onboard-LED switching with button LED=3 #Variable für den LED-GPIO-Port BUTTON=11 #Variable für den Taster-GPIO-Port STATUS=`gnublin-gpio -i -p 3 -b` #Status der LED abfragen TASTER=0 STATUS_ALT=0 # Taster abfragen while [ "1" = "1" ]; do TASTER=`gnublin-gpio -i -p $BUTTON -b` #LED aus und Taster gedrückt? if [ "$TASTER" = "0" ]; then #LED aus gnublin-gpio -o 1 -p $LED -b echo "switch pressed" #LED an und Taster gedrückt? else #LED an gnublin-gpio -o 0 -p $LED -b

Experimente

echo "switch not pressed" fi done Ausgeführt wird es wieder, wie zuvor, mit root@gnublin:~/experimente# chmod +x led-taster.sh root@gnublin:~/experimente# ./led-taster.sh

Temperatur messen Bei vielen Bastelprojekten will man auf die Umgebung reagieren, so soll etwa die Heizung angehen, wenn es im Raum zu kalt wird, oder die Heizung soll bei offenem Fenster abgeschaltet werden. In diesem Experiment lernen wir, wie man einen analogen Temperatursensor auslesen kann.

Materialliste • 1x GNUBLIN • 1x 12 kOhm Widerstand (braun, rot, orange) • 1x 10 kOhm Potentiometer • 1x PTC-Widerstand • 1x Steckbrett • 1x Kabel • 1x (Multimeter) Neben den digitalen Werten gibt es auch noch analoge Werte die wir gerne erfassen möchten. Analoge Werte heißt Spannungswerte, diese liefern uns meist Sensoren oder Messschaltungen zurück. So kann unser GNUBLIN erkennen ob es draußen regnet oder wie warm es ist und dann uns benachrichtigen, ob wir die Fenster schließen müssen oder das auch gleich selbst tun. Da wir in einem digitalem System nur digitale Signale verarbeiten können, müssen die analogen Werte übersetzt werden. Dies macht ein ADC, ein Analog Digital Comperator, dieser weist jedem Spannungswert einen digitalen Zahlenwert zu. Der im GNUBLIN verbaute ADC löst den Spannungsbereich von 0 - 3,3V mit 10-bit auf, d.h. er unterteilt den Bereich in 1023 Abschnitte und kann somit mit einer Genauigkeit von 3,3 mV messen.

Experimente

Abbildung 2.5. Analog-Digital-Comperator Funktionsweise — rote Linie ist die Abtastung des ADCs

Das GNUBLIN-Standart hat drei ADC-Ports, an denen wir Messungen durchführen können, GPA0 GPA2. Der ADC misst dabei immer im Bezug auf GND, also die Spannung, die zwischen der Messstelle und GND (0V) anliegt. Um mal schnell einen Wert an einem der Ports in der Kommandozeile abzufragen gibt es ein kleines Tool: root@gnublin:~# gnublin-adcint -c 1 Hier wird die Spannung am GPA1 zurückgegeben. Hinter dem Parameter -c wird der Port angegeben, den man abfragen möchte. Im Starterkit befindet sich ein PTC-Widerstand, dabei handelt es sich um einen Widerstand, der seinen Wert proportional zur Temperatur ändert. Der Wert des Widerstands steigt mit zunehmender Temperatur. Den Widerstand des PTCs und damit indirekt die Temperatur können wir messen, indem wir die Spannung in einem Spannungsteiler messen.

Abbildung 2.6. Prinzip eines Spannungsteilers

Experimente

Ein Spannungsteiler besteht aus mindestens zwei Widerständen (in der weiteren Erklärung gehen wir einfachshalber von nur zwei Widerständen aus). Dabei fällt die angelegte Spannung über beide Widerstände ab entsprechend ihres Wertes ab. Das heißt, wenn R1 = 3 kOhm und R2 = 1 kOhm sind, dass an R1 dreimal so viel Spannung abfällt als an R2 (Verhältnis 3:1). In einem Spannungsteiler können wir nun die Spannung, die über einen Widerstand abfällt, messen. Anhand dieses Wertes ist es dann möglich zu berechnen wie viel Spannung an dem anderen Widerstand abfällt (Uges = U1 + U2 → U1 = Uges - U2). Nach dem Ohmschen Gesetzt ist der Strom durch einen Widerstand gleich Spannung durch Widerstand (I = U2 / R2). Mit den beiden Werten lässt sich jetzt auch der Wert des anderen Widerstands berechnen: R1 = U1 / I Die Gesamtrechnung mit den Widerständen R1 und R2 lautet dann: Messwert: U2 über Widerstand R2 U1 = Uges - U2 I = U2 / R2 R1 = U1 / I

Beispiel 2.1. Spannungsteiler ausprobieren (Multimeter notwendig) Wenn du den Spannungsteiler wie im Bild oben am GNUBLIN aufbaust, kannst du das Prinzip schnell selbst ausprobieren. Als Spannungsquelle nimmst du den 3,3V Anschluss des GNUBLINs. Als R2 kommt hier ein 10 kOhm Potentiometer zum Einsatz, dies ermöglicht den Spannungsteiler variabel zu verändern. Stelle dein Multimeter auf Gleichspannung und auf den nächst größeren Bereich (> 3,3V). Nun kannst du die Spannung zwischen den beiden Widerständen im Bezug zu GND messen. Wenn du nun das Potentiometer veränderst, siehst du auch die sich ändernde Spannung. Ersetzen wir nun einen der beiden Widerstände durch unseren PTC, dann können wir zu jedem Zeitpunkt den Wert des PTC bestimmen und so auch die Temperatur. Wenn wir den PTC nun wie in der Schaltung unten an unser GNUBLIN anschließen, können wir mit dem Kommandozeilentool die Spannung messen und dann mit unserem Taschenrechner die Temperatur ausrechnen. Da wir das System ja programmieren können, lassen wir das lieber gleich unser Programm erledigen. Wir könnten jetzt wieder ein Shell-Skript schreiben, das einfach den Befehl aufruft und die Berechnung vornimmt, aber diesmal schreiben wir das Programm in der Programmiersprache C++. Daher benötigen wir auch ab jetzt und für alle folgenden Experimente den Cross-Compiler, wie wir ihn oben schon kennengelernt haben.

Abbildung 2.7. PTC-Schaltung

Experimente

Abbildung 2.8. PTC-Schaltung — Aufbau

Um die Messwerte des ADCs zu erhalten verwenden wir die GNUBLIN-API, die API erleichtert uns den Zugriff auf die wichtigen Systemkomponenten, also die ganze Arbeit mit den Dateizugriffen. Die API stellt uns hierfür verschiedene Methoden zu Verfügung. Mit diesen ist es einfach auf die Systemschnittstellen von seinem eigenen Programm aus zuzugreifen. Damit wir die API verwenden können, benötigen wir zwei Dateien auf unserem Desktoprechner, gnublin.h und gnublin.cpp. Diese Dateien kann man in der aktuellen Version von der GNUBLIN-Webseite herunterladen. In der Kommandozeile kann man dies ganz einfach wie folgt machen, man sollte sich in dem Ordner befinden, in dem man die Quelltext-Dateien für das GNUBLIN auch abspeichern will: user@develop-pc: ~/experimente$ wget https://raw.github.com/embeddedprojects/gnublin-api/master/gnublin.cpp user@develop-pc: ~/experimente$ wget https://raw.github.com/embeddedprojects/gnublin-api/master/gnublin.h Unser C++ -Programm ptc.cpp sieht dann so aus: #include "gnublin.h" int main() { gnublin_adc adc; float current, voltage, resistor; int temp; //Spannung in V über PTC abfragen voltage = adc.getVoltage(1) / (float)1000; if (adc.fail()){ printf("ADC-Fehler\n"); return -1;

Experimente

} //Strom durch Widerstand berechnen current = voltage / 12000; //Widerstand des PTC berechnen resistor = (3.3 - voltage) / current; //Temperatur if (resistor temp } else { temp }

bestimmen > 1000){ = (resistor - 1000) / 16 + 25;

= (1000 - resistor) / 16 + 25;

printf("PTC Widerstand: %f Ohm\n", resistor); printf("Temperatur: %i\n", temp); } Das Programm muss jetzt noch auf dem Desktoprechner kompiliert werden: user@develop-pc:~/experimente$ gnublin.cpp

arm-linux-gnueabi-g++

-o

ptc

ptc.cpp

Damit dies klappt muss man zuvor die Toolchain in den Umgebungsvariablen bekannt gegeben haben (wieder auf die genaue Schreibweise achten: Punkt, Leerzeichen, Pfad): . /opt/eldk-5.2.1/set.sh Anschließend kopieren wir es mittels scp auf das GNUBLIN. Dafür muss ab jetzt auch eine Netzwerkverbindung mit dem GNUBLIN bestehen. user@develop-pc:~/experimente$ scp ptc root@192.168.0.10:experimente/ Wenn wir das Programm nun auf dem GNUBLIN ausführern, erhalten wir den Widerstand und die Temperatur des PTCs. root@gnublin:~/experimente# ./ptc Überlege dir doch einmal, was du nun mit diesem Ergebnis anfangen könntest. Ein Zimmerthermometer bauen oder gar eine Wetterstation?

Helligkeit messen Natürlich gibt es noch zahlreiche weitere Umgebungsvariablen, auf die wir mit dem richtigen Sensor reagieren können. Je mehr Sensoren wir in unserem Projekt verwenden, desto komplexer wird es, aber wir können auch auf mehrere Ereignisse reagieren. Wir ergänzen nun unsere Sensoren um einen Helligkeitssensor. Mit diesem lässt sich z.B. eine Dämmerungsschaltung oder gar eine Lichtschranke realisieren.

Materialliste • 1x GNUBLIN

Experimente

• 1x 12 kOhm Widerstand (braun, rot, orange) • 1x Fotowiderstand • 1x Steckbrett • 1x Kabel Nachdem wir jetzt die Temperatur messen können, wollen wir uns ansehen, wie wir die Helligkeit messen können. Wir verwenden dazu den Fotowiderstand aus dem Starterkit. Der Sensor funktioniert ähnlich wie der PTC, es handelt sich hierbei um einen Widerstand, der auf Licht reagiert. Je mehr Licht auf den Sensor fällt, umso kleiner wird sein Widerstand. Wir müssen also wieder den Widerstandswert des Sensors bestimmen um die Helligkeit zu bestimmen. Auch hier verwenden wir den Spannungsteiler und schließen ihn wie schon den PTC an unser GNUBLIN an.

Abbildung 2.9. Schaltung mit Helligkeitssensor

Abbildung 2.10. Schaltung mit Helligkeitssensor — Aufbau

Experimente

Im Gegensatz zum vorherigen Experiment wollen wir uns diesmal nicht einfach den Widerstandswert ausgeben lassen, sondern wir wollen anhand der Helligkeit etwas steuern, zum Beispiel, dass unter einem gewissen Helligkeitswert das Licht angeht. Die Lampe simulieren wir hierbei mit der LED1 auf dem Board. Das Programm misst also kontinuierlich die Helligkeit und wenn diese unter einen gewissen Wert f채llt, wird die LED eingeschaltet, wird es wieder hell, so geht die LED auch wieder aus. Die Datei photoresistor.cpp hat dann diesen Inhalt: #include "gnublin.h" int main() { gnublin_gpio gpio; gnublin_adc adc; float voltage, current, resistor; gpio.pinMode(3, OUTPUT); if (gpio.fail()) { printf("GPIO pinMode Fehler\n"); return -1; } while(1) { //Spannung in V ueber Sensor abfragen voltage = adc.getVoltage(1) / (float)1000; if (adc.fail()){ printf("ADC-Fehler\n"); return -1; } //Strom durch Widerstand berechnen current = voltage / 12000; //Widerstand berechnen resistor = (3.3 - voltage) / current; //es ist dunkel -> LED an if (resistor > 2000) { printf("LED an\n"); gpio.digitalWrite(3, if (gpio.fail()) { printf("GPIO return -1; } } else { printf("LED aus\n"); gpio.digitalWrite(3, if (gpio.fail()) { printf("GPIO return -1; } } } }

HIGH); digitalWrite Fehler\n");

LOW); digitalWrite Fehler\n");

Experimente

Wir kompilieren das Programm wieder: user@develop-pc:~/experimente$ arm-linuxgnueabi-g++ -o photoresistor photoresistor.cpp gnublin.cpp Noch einmal zur Erinnerung. Damit dies klappt muss man zuvor die Toolchain in den Umgebungsvariablen bekannt gegeben haben (wieder auf die genaue Schreibweise achten: Punkt, Leerzeichen, Pfad): . /opt/eldk-5.2.1/set.sh Kopieren es auf das GNUBLIN: user@develop-pc:~/experimente$ scp photoresistor root@192.168.0.10:experimente/ Führen es auf dem GNUBLIN aus: root@gnublin:~/experimente# ./photoresistor Wenn wir nun die Helligkeit verändern, z.B. indem wir die Hand über den Sensor halten, dann geht die LED an, wenn wir sie wieder wegtun geht die LED wieder aus.

Abbildung 2.11. Abdunkeln des Sensors mit der Hand

Wenn wir statt der LED nun ein Relais an einen der GPIOs anschließen würden, könnte man mit diesem Programm bereits richtige Lampen steuern, z.B. die Gartenleuchten am Abend einschalten.

GNUBLIN Erweiterung Module-Relay Um Relais am GNUBLIN zu verwenden gibt es eine Erweiterungskarte mit dem Namen GNUBLIN-Module-Relay. Diese Karte wird mit einem Flachbandkabel mit dem GNUBLIN verbunden und stellt acht Relais zu Verfügung.

Netzspanung ist lebensgefährlich ACHTUNG: Das arbeiten mit Netzspannung ist gefährlich und sollte nur von Fachkräfte durchgeführt werden.

Experimente

Die E-Mail-Türklingel Wir haben in den vorherigen Beispielen gesehen, wie wir äußere Faktoren, wie Temperatur und Helligkeit, messen können und dann eine Aktion ausführen. Oftmals möchte man beim Eintreten eines bestimmten Zustandes gerne benachrichtigt werden. Ein sehr einfacher und komfortabler Weg ist es, eine E-Mail zugesand zu bekommen. In diesem Experiment lassen wir uns eine E-Mail zusenden, wenn eine Taste gedrückt wird. Man kann sich das praktisch als E-Mail-Türklingel vorstellen.

Materialliste • 1x GNUBLIN • 1x WLAN-Stick • 1x Taster • 1x 12 kOhm Widerstand (braun, rot, orange) • 1x Steckbrett • 1x Kabel Zunächst müssen wir den Taster wie schon zuvor am Gnublin-Board anschließen. Das sieht man auf folgendem Bild:

Abbildung 2.12. Taster an GPIO11

Experimente

Abbildung 2.13. Taster an GPIO11 — Aufbau

Außerdem sollte der WLAN-Stick im Betrieb sein, wie im Kapitel vorher beschrieben. Wir schreiben hierfür ein kleines C++ Programm und nutzen dabei wieder unsere API. Die API ermöglicht uns auch hier die einfache Realisierung der recht komplexen Aufgabe, eine Mail zu versenden. Wir legen also eine C++ Quell-Datei taster-mail.cpp an und fügen den folgenden Code ein: #include "gnublin.h" int main() { gnublin_gpio gpio; CSmtp mail; mail.SetSMTPServer("mail.domain.tld",587); mail.SetLogin("smtptest@domain.tld"); mail.SetPassword("secretpassword"); mail.SetSenderName("GNUBLIN"); mail.SetSenderMail("smtptest@domain.tld"); mail.SetSubject("Taster gedrueckt"); mail.AddRecipient("recipient@domain.tld"); mail.SetXPriority(XPRIORITY_NORMAL); mail.AddMsgLine("Der Taster wurde gedrueckt"); gpio.pinMode(11, INPUT); while(1){ if(gpio.digitalRead(11) == 0){ mail.Send();

Experimente

} } }

Server Einstellungen Damit das GNUBLIN eine E-Mail versenden kann, benötigt es einen Mailserver. Am besten man nutzt einfach seine eigene E-Mail-Adresse oder man legt für das GNUBLIN extra eine Adresse an. Zum Versenden der Mail benötigt man die SMTP-Einstellungen des Servers. Diese bekommt man von seinem Mailanbieter (meist in der Hilfe). Die SMTP-Daten trägt man dann in das Programm ein (Z. 7-11). Z.7: SMTP-Server Adresse, Port Z.8: SMTP-Benutzername Z.9: Passwort Z.10: Absendername Z.11: Absender-Email-Adresse In Zeile 13 tragen wir dann unsere E-Mail-Adresse ein, an die wir die Mail schicken möchten. Dann speichern wir die Datei und müssen das Programm nur noch übersetzten, das machen wir mit folgendem Befehl: user@develop-pc:~/experimente$ taster-mail.cpp gnublin.cpp

arm-linux-gnueabi-g++

-o

taster-mail

Jetzt liegt das Programm mit dem Namen “taster-mail” im Ordner. Diese schicken wir mit scp an das GNUBLIN: user@develop-pc:~/experimente$ root@192.168.0.10:experimente/

scp

taster-mail

Nun führen wir das Programm nur noch mit root@gnublin:~/experimente# ./taster-mail aus. Nun sollte bei einem Druck auf den Taster eine E-Mail mit dem Inhalt „Taster gedrückt!“ an die angegebene Adresse geschickt werden.

Beispiel 2.2. Programm anlegen In den nachfolgenden Experimenten wird das anlegen, kompilieren und kopieren auf das GNUBLIN nicht mehr extra erwähnt. Die Vorgehensweise ist bei jedem Abschnitt gleich, wie bisher. Lediglich die Dateinamen müssen entsprechend angepasst werden.

Gieß mich! Wer kennt das nicht, man vergisst zu gerne einmal die Blumen zu gießen und bis man es merkt, ist es meistens schon viel zu spät. Wäre es da nicht viel besser, die Blume würde sich melden, wenn es ihr zu trocken wird? Nichts leichter als das, wir messen einfach die Feuchtigkeit und wenn diese unter unseren Schwellwert sinkt, dann schickt uns das GNUBLIN eine „Gieß mich!“ E-Mail. Dazu müssen wir lediglich unser vorheriges Programm leicht umbauen.

Experimente

Abbildung 2.14. Feuchtigkeitssensor

Materialliste • 1x GNUBLIN • 1x WLAN-Stick • 2x 12 kOhm Widerstand (braun, rot, orange) • 1x 220 kOhm Widerstand (rot, rot, gelb) • 1x 4,7 kOhm Widerstand (gelb, violett, rot) • 2x Transistor • 1x Kabel • 1x Steckbrett

Experimente

Als Feuchtigkeitssensor kommt eine kleine Schaltung zum Einsatz. Zwei Drähte der Schaltung werden in den Blumentopf gesteckt und messen die Feuchtigkeit. Wird die Erde zu trocken, wird der Widerstand zwischen den beiden Drähten höher. Durch den hohen Widerstand leitet der Transistor T1 nicht mehr , so dass der Transistor T2 eingeschaltet wird. Dadurch wird unsere Messstelle auf 0V (GND) gezogen, also messen wir am GPIO-Eingang 0. In feuchter Erde messen wir am GPIO 1.

Abbildung 2.15. Schaltung Feuchtigkeitssensor

Aufgebaut sieht die Schaltung wie folgt aus:

Abbildung 2.16. Schaltung Feuchtigkeitssensor — Aufbau

Experimente

• R1 = 12 kOhm (braun, rot, orange) • R2 = 220 kOhm (rot, rot, gelb) • R3 = 4,7 kOhm (gelb, violett, rot) • R4 = 12 kOhm (braun, rot, orange) Es ist wichtig darauf zu achten, dass die Transistoren richtig angeschlossen sind. Die beiden Drähte zu Feuchtigkeitsmessung sollten in einem Abstand von ca. 3 cm in dem Blumentopf gesteckt werden. Außerdem sollte der WLAN Stick im Betrieb sein. Zuerst legen wir also mit eine C++ Quell-Datei mit dem Namen gieß-mich.cpp an und fügen wieder den Code von unserem vorherigen Programm ein, ändern ihn aber ein bisschen ab: #include "gnublin.h" int main(){ gnublin_gpio gpio; CSmtp mail; int mail_flag = 0; mail.SetSMTPServer("mail.domain.tld",587); mail.SetLogin("smtptest@domain.tld"); mail.SetPassword("secretpassword"); mail.SetSenderName("GNUBLIN"); mail.SetSenderMail("smtptest@domain.tld"); mail.AddRecipient("recipient@domain.tld"); mail.SetXPriority(XPRIORITY_NORMAL); gpio.pinMode(14, INPUT); while(1){ if(gpio.digitalRead(14)==0 && mail_flag == 0){ mail.DelMsgLines(); mail.SetSubject("Gieß mich"); mail.AddMsgLine("Die Blumenerde ist trocken"); mail.Send(); mail_flag = 1; } if(gpio.digitalRead(14)==1 && mail_flag == 1){ mail.DelMsgLines(); mail.SetSubject("Erde wieder feucht"); mail.AddMsgLine("Die Blumenerde ist wieder feucht."); mail.Send(); mail_flag = 0; } } } Nun sollte jedes mal wenn der Wert der GPIO-Wert auf 0 schaltet eine E-Mail ankommen mit dem Inhalt „Gieß mich“. Ist der Boden wieder feucht. erhält man eine E-Mail, dass er nicht mehr gegossen werden muss. Eine neue E-Mail erhalten wir erst, wenn der Boden wieder trocken ist.

Experimente

Das Programm übersetzen wir wie gewohnt auf dem Desktoprechner und schicken es mit scp an das GNUBLIN, um es dort auszuführen.

Programm verbessern Es kann während des Austrocknens des Bodens passieren, dass er in einen Zwischenzustand gerät, indem das GNUBLIN nicht genau erkennt ist es nun feucht oder trocken und immer hin und her springt. Dies führt dazu, dass wir mit E-Mails überschüttet werden. Abhilfe schafft hier die Messung des Zustandes über eine längere Zeit und nur wenn sich in dieser Zeitspanne der Wert nicht ändert, wird eine E-Mail geschickt. In unserem Beispielcode wird hier alle 10 Sekunden gemessen und nur wenn bei drei Messungen hintereinander der Wert konstant war, wird eine Aktion ausgeführt. #include "gnublin.h" int main(){ gnublin_gpio gpio; CSmtp mail; int mail_flag = 0; int i = 0; int status; mail.SetSMTPServer("mail.domain.tld",587); mail.SetLogin("smtptest@domain.tld"); mail.SetPassword("secretpassword"); mail.SetSenderName("GNUBLIN"); mail.SetSenderMail("smtptest@domain.tld"); mail.AddRecipient("recipient@domain.tld"); mail.SetXPriority(XPRIORITY_NORMAL); gpio.pinMode(14, INPUT); while(1){ if (gpio.digitalRead(14) == status) { i++; } else { status = gpio.digitalRead(14); i = 1; } sleep(10); if(status==0 && mail_flag == 0 && i >= 3){ mail.DelMsgLines(); mail.SetSubject("Giess mich"); mail.AddMsgLine("Die Blumenerde ist trocken"); mail.Send(); mail_flag = 1; i = 0; } else if(status==1 && mail_flag == 1 && i >= 3){ mail.DelMsgLines();

Experimente

mail.SetSubject("Erde wieder feucht"); mail.AddMsgLine("Die Blumenerde ist wieder feucht."); mail.Send(); mail_flag = 0; i = 0; } } }

Briefkastensensor / Lichtschranke Wer kennt das nicht, man muss immer zum Briefkasten gehen und nachsehen ob der Postbote etwas eingeworfen hat. Wäre es da nicht viel besser, wenn sich der Briefkasten bei einem meldet, wenn etwas da ist? In diesem Experiment wollen wir mit einer Lichtschranke am GNUBLIN erkennen, ob etwas durch den Briefschlitz geschoben wurde und uns gegebenenfalls benachrichtigt, entweder mit einer LED oder per E-Mail.

Materialliste • 1x GNUBLIN • 1x WLAN-Stick • 1x 12 kOhm Widerstand • 1x Leuchtdiode • 1x Fotowiderstand • 1x Steckbrett • 1x Kabel • 1x Taster

Experimente

Abbildung blockiert)

2.17.

Schema — Lichtschranke-im-Briefkasten

(Lichtschranke

Wir bauen unsere Lichtschranke aus dem Fotowiderstand und einer LED auf. Wenn etwas durch den Schlitz geschoben wird, wird der Fotowiderstand verdunkelt und der Widerstandswert steigt. Wir müssen also wie in den Experimenten zuvor, den Widerstandswert berechnen und anhand eines Schwellwerts die Benachrichtigung auslösen. Unser Programm muss also erkennen, ob der Widerstand irgendwann einmal den Schwellwert überschritten hat. Wir schließen die Lichtschranke wie in dem Bild unten an das GNUBLIN an. Dabei muss der Kopf der LED sowie der des Fototransistors um 90° umgebogen werden, so dass sich die beiden Bauteile gegenseitig „ansehen“.

Abbildung 2.18. Schaltung Lichtschranke

Experimente

Abbildung 2.19. Schaltung Lichtschranke â&#x20AC;&#x201D; Aufbau

Anzeige mit LED In unserem ersten Programm wollen wir uns mit Hilfe der LED auf dem GNUBLIN signalisieren lassen, dass etwas eingeworfen wurde. Wir verwenden wieder die API um das Programm zu schreiben, also mĂźssen die Dateien gnublin.h und gnublin.cpp im selben Ordner liegen, indem wir das Programm ablegen. Wir legen mit nano also die Datei post-led.cpp an. Schreiben den Quelltext hinein: #include "gnublin.h" int main() { gnublin_adc adc; gnublin_gpio gpio; CSmtp mail; float voltage, current, resistor; //GPIOs vorbereiten gpio.pinMode(3, OUTPUT);

gpio.digitalWrite(3, LOW); while (1) { //Spannung in V ueber Sensor abfragen voltage = adc.getVoltage(1) / (float)1000;

Experimente

if (adc.fail()){ printf("ADC-Fehler\n"); return -1; } //Strom durch Widerstand berechnen current = voltage / 12000; //Widerstand berechnen resistor = (3.3 - voltage) / current; if(resistor > 500){ gpio.digitalWrite(3, HIGH); } } } In der while-Schleife fragen wir die Lichtschranke kontinuierlich ab und schalten die LED an GPIO3 an, sobald der Pin 15 0 wird.

Benachrichtigung per E-Mail Es ist ja schön, wenn einem der Briefkasten mit einer LED anzeigt, dass man ihn doch leeren soll, aber man muss immer noch zum Briefkasten gehen, um zu sehen, ob die LED leuchtet. Aus diesem Grund erweitern wir jetzt das Programm, damit es uns zusätzlich eine E-Mail schickt “Post ist da”. Voraussetzung ist natürlich, wir haben WLAN-Empfang am Briefkasten. Wenn wir jetzt einfach einen E-Mailversand in das obige Programm einbauen, wird uns immer, wenn die Lichtschranke unterbrochen wird, eine EMail zugesendet. Damit uns nur eine E-Mail gesendet wird und wir nicht zugespamt werden, wenn z.B. die Lichtschranke blockiert wird, bauen wir das brief_flag ein. Das brief_flag signalisiert uns, dass schon einmal erkannt wurde, dass eine Brief eingeworfen wurde und die Benachrichtigung stattfand. Damit wir das Flag beim Briefkastenleeren wieder zurücksetzen können, schließen wir einen Taster an GPIO14 an. Der Aufbau sieht dann so aus:

Abbildung 2.20. Schaltung Lichtschranke mit Reset

Experimente

Abbildung 2.21. Schaltung Lichtschranke mit Reset — Aufbau

Wir erstellen wieder die Datei post-email.cpp und füllen sie mit unserem Quellcode: #include "gnublin.h" int main() { gnublin_adc adc; gnublin_gpio gpio; CSmtp mail; int brief_flag = 0; float voltage, current, resistor; //E-Mail Einstellungen mail.SetSMTPServer("mail.domain.tld",587); mail.SetLogin("smtptest@domain.tld"); mail.SetPassword("secretpassword"); mail.SetSenderName("GNUBLIN"); mail.SetSenderMail("smtptest@domain.tld"); mail.SetSubject("Neue Post!"); mail.AddRecipient("recipient@domain.tld"); mail.SetXPriority(XPRIORITY_NORMAL); mail.AddMsgLine("Es wurde etwas in den Briefkasten geworfen."); //GPIOs vorbereiten gpio.pinMode(3, OUTPUT); gpio.pinMode(14, INPUT);

Experimente

gpio.digitalWrite(3, LOW); while (1) { //Spannung in V ueber Sensor abfragen voltage = adc.getVoltage(1) / (float)1000; if (adc.fail()){ printf("ADC-Fehler\n"); return -1; } //Strom durch Widerstand berechnen current = voltage / 12000; //Widerstand berechnen resistor = (3.3 - voltage) / current; if(resistor > 500 && brief_flag == 0){ mail.Send(); gpio.digitalWrite(3, HIGH); brief_flag = 1; } //Reset-Taster ueberpruefen if (gpio.digitalRead(14) == 0) { gpio.digitalWrite(3, LOW); brief_flag = 0; } } }

Beispiel 2.3. Note Der Schwellwert in Zeile 41 muss je nach Gegebenheit entsprechend angepasst werden. Nun sollten wir jedes mal eine E-Mail bekommen, wenn etwas in den Briefkasten gelandet ist, seit dem wir ihn das letzte mal geleert haben. Wenn wir den Briefkasten geleert haben, dr체cken wir den Taster, um das brief_flag wieder auf 0 zu setzen und bei der n채chsten Post wieder eine E-Mail bekommen.

Kapitel 3. Auf zu neuen Projekten Wir haben in den Experimenten nun gelernt, wie wir verschiedene Schnittstellen auf dem GNUBLIN ansteuern können, von GPIO über ADC bis hin zu einer Netzwerkanbindung. Wir hoffen, dass wir dir Lust auf mehr gemacht haben und dass du nun Anregungen für eigene Entwicklungen bekommen hast. Die hier vorgestellten Versuche lassen sich alle noch ausbauen und um zahlreiche Funktionen erweitern. Das GNUBLIN hat noch mehr Funktionen zu bieten, als wir dir in diesem Starterkit vorstellen konnten. Es sind z.B. eine I2C- und eine SPI-Schnittstelle vorhanden, über die externe Bauteile angebunden werden können. So kann das GNUBLIN flexibel um zusätzliche Sensoren und Schnittstellen erweitert werden, je nach dem was man gerade benötigt. Es gibt eine Reihe von Modulen die ganz einfach mit dem GNUBLIN-Connector angeschlossen werden können und so das GNUBLIN kinderleicht erweitern. Für all diese Module gibt es auch Schnittstellen in der API. Zu den Modulen zählen beispielsweise: • Temperatursensor • Schrittmotorsteuerung • Displays • Relaiskarte • RS232 und RS485 • Feuchtigkeitssensor • Helligkeitssensor • Netzwerk • CAN • Echtzeituhr • Regensensor • Portexpander • Analog Digital Wandler • Digital-Analog-Wandler • Eingangskarten mit Optokoppler • und vieles mehr. Einfach auf der Projekteseite vorbei schauen. Mit dem GNUBLIN wurden schon zahlreiche kleine und große Projekte realisiert. So steuert jemand seinen Roboter mit dem GNUBLIN, ein anderer hat das GNUBLIN um einen NFC bzw. RFID-Kartenleser erweitert. Andere überwachen damit ihren Garten oder ihre Haustiere. All diese Leute haben ihre Projekte im Internet veröffentlicht und unter http://www.gnublin.org vorgestellt. Die Webseite mit ihrem Wiki und Forum ist auch die Anlaufstelle, für den Fall, dass du mal ein Problem hast und Hilfe brauchst. Du bekommst dort bestimmt eine Antwort. Deiner Fantasie für GNUBLIN-Projekte sind (fast) keine Grenzen gesetzt und wir würden uns freuen auch von deinem Projekt zu hören, egal ob es groß oder klein ist.

Auf zu neuen Projekten

In diesem Sinne wünschen wir, die Autoren und die ganze GNUBLIN-Community, viel Spaß beim entdecken der Embedded-Linux-Welt.

Anhang A. Virtuelles Netzwerk über USB GNUBLIN selbst kann über den USB OTG Port ebenfalls eine USB-Netzwerkkarte emulieren. Falls man kein WLAN zur Verfügung hat oder sich zusätzliche Hardware sparen möchte, ist dies von Vorteil. Man braucht dazu nur ein zweites Mini USB Kabel.

Vorbereitungen Vorbereitungen: • Gnublin von der Versorgungsspannung nehmen. • Jumper "USB OTG PWR" (J1) auf Device setzen und "USB OTG ID" HOST-Jumper entfernen (Device). Die Jumper und I/O Pins sieht man im Kapitel WLAN vorher. • Beide USB-Anschlüsse des Gnublin-Boards mit dem PC verbinden. Gnublin sollte nun booten. Danach einloggen.

Modul/Treiber laden Auf dem Gnublin führt man danach den folgenden Befehl aus: root@gnublin:~# modprobe g_ether Auf unserem eigenen PC führen wir nun den Befehl dmesg aus. user@mein-pc:~$ dmesg Es folgt eine recht große Ausgabe. Unter den letzten paar Meldungen sollte in etwa so etwas auftauchen: [ 2318.712037] usb 4-2: new full-speed USB device number 4 using uhci_hcd [ 2318.868124] usb 4-2: New USB device found, idVendor=0525, idProduct=a4a1 [ 2318.868133] usb 4-2: New USB device strings: Mfr=1, Product=2, SerialNumber=0 [ 2318.868140] usb 4-2: Product: Ethernet Gadget [ 2318.868146] usb 4-2: Manufacturer: Linux 2.6.33-gedda7f0 with fsl-usb2-udc [ 2318.940820] cdc_ether 4-2:1.0: usb0: register 'cdc_ether' at usb-0000:00:1d.3-2, CDC Ethernet Device, 42:c5:f6:63:af:9d [ 2318.941145] usbcore: registered new interface driver cdc_ether Wir sehen, dass unser Gnublin als USB-Gerät erkannt wurde.

Internetverbindung von Host-PC nutzen Hat man die vorherigen Schritte ausgeführt, erscheint auf unserem Host-PC eine neue Kabelverbindung. Wir öffnen den Netzwerkmanager und bearbeiten diese Verbindung. Unter IPv4-Einstellungen wählen wir unter Methode "Gemeinsam mit anderen Rechnern" ("shared to other computers") aus und speichern diese Konfiguration.

Virtuelles Netzwerk 端ber USB

Abbildung A.1. Netzwerkverbindungen bearbeiten

Abbildung A.2. IPv4-Einstellungen

Auf dem Gnublin f端hrt man danach den folgenden Befehl aus: root@gnublin:~# dhclient usb0 Nun sollte man eine IP-Adresse bekommen haben. Zum testen, ob man jetzt eine funktionierende Internetverbindung am Gnublin besitzt, kann man ganz einfach den Befehl ping benutzen: root@gnublin:~# ping www.gnublin.org Es folgt in etwa so eine Ausgabe:

Virtuelles Netzwerk Ăźber USB

PING www.gnublin.org (46.163.117.240) 56(84) bytes of data. 64 bytes from lvps46-163-117-240.dedicated.hosteurope.de (46.163.117.240): icmp_req=1 ttl=53 time=34.4 ms 64 bytes from lvps46-163-117-240.dedicated.hosteurope.de (46.163.117.240): icmp_req=2 ttl=53 time=34.2 ms 64 bytes from lvps46-163-117-240.dedicated.hosteurope.de (46.163.117.240): icmp_req=3 ttl=53 time=40.0 ms 64 bytes from lvps46-163-117-240.dedicated.hosteurope.de (46.163.117.240): icmp_req=4 ttl=53 time=33.9 ms 64 bytes from lvps46-163-117-240.dedicated.hosteurope.de (46.163.117.240): icmp_req=5 ttl=53 time=33.7 ms Wir brechen den Ping mit "Strg+c" ab. Nun haben wir unsere Internetverbindung von unserem PC mit dem Gnublin-Board geteilt und kĂśnnen vom Gnublin aus aufs Internet zugreifen.