Arduino


von Prof. Jürgen Plate

Arduino-Kurzeinführung

Was ist ein "Arduino"?

Die Arbeit mit Mikrocontrollern und die Ansteuerung von Hardware hat selbst für Informatiker etwas von einer Geheimwissenschaft an sich. Erst muss man dicke Datenblätter wälzen und dann seinen Code nicht in einer Hochsprache, sondern in Assembler schreiben. Stimmt! Stimmt aber auch wieder nicht! Inzwischen können viele Controller auch in C programmiert werden - unter Umständen kostet der Compiler nur relativ viel.

Um das Jahr 2005 herum gab es einen sehr interessanten Umschwung: Studierende des Interaction Design Institute im italienischen Ivrea suchten nach einer einfachen Möglichkeit, um ihre Ideen für neuartige Interaktion zwischen Mensch und Maschine sowie ihre Kunst- und Roboterprojekte in funktionsfähige Prototypen umzusetzen. Sie benötigten ein preiswertes, einfaches und überschaubares System, das den Leuten die Angst vor Elektronik nehmen konnte. Professor Massimo Banzi entwickelte daraufhin mit einigen Helfern ein einfaches, günstiges Mikrocontrollerboard und auch gleich die passende, C-ähnliche Programmiersprache. Nachdem das Projekt wuchs, formierte sich das Gründer-Team aus Massimo Banzi (Italien), David Cuartielles (Spanien), Tom Igoe (USA), Gianluca Martino (Italien) und David Mellis (USA). Das Ganze nannte er "Arduino" nach einem lokalen König aus dem elften Jahrhundert. Eine andere Version besagt, dass Massimo Banzi das Projekt nach der "Bar di Re Arduino" (deutsch: "Bar des Königs Arduino"), einer Kneipe in Ivrea benannte.

Dinge wie Arduino entstehen nur, wenn Ingenieure die üblichen Denkschemata von Ingenieuren verlassen, was, wie der Arduino beweist, durchaus sehr produktiv sein kann. Auch für die Erfolgsgeschichte des Arduinos gilt Apples Werbespruch "Think different".

Das kleine, mit einem Atmel-Prozessor bestückte Board trat schnell einen Siegeszug an, weil es sich an Designer oder Künstler und nicht so sehr an lötende Nerds richtete. Also Menschen, die vorher nur in extremen Ausnahmefällen Software entwickelt oder gar eigene Hardware gebaut hatten. Ein weiterer Vorteil: Board (Schaltung und Layout) sowie die Entwicklungsumgebung ist Open Source, also für jeden frei verfügbar und ebenso offen für Änderungen und Erweiterungen. Einige davon kann man auf der Arduino-Webseite bewundern.

Arbeiten mit dem Arduino

Die Software kann unter arduino.cc/en/Main/Software herunter geladen werden. Es gibt Versionen für Linux, Mac OSX und Windows. Bei letzterem hat man die Wahl zwischen einer ZIP-Datei und einenm Windows-Installer. Letzterer installiert auch auf Wunsch gleich den Treiber für die USB-Schnittstelle des Arduino. Bei den anderen Varianten werden die Dateien und Verzeichnisse beispielsweise nach c:\programme\arduino entpackt. Das Verzeichnis muss evtl. neu erstellt werden.

Nach der Softwareinstallation kann der Arduino mit der USB-Schnittstelle verbunden werden. Seine grüne LED muss leuchten. Nun kann die Entwicklungsoberfläche arduino.exe gestartet werden. Dort sind folgende Einstellungen vorzunehmen:

Der erste Test dauer nur wenige Minuten. Sie wählen ein Testprogramm aus: File → Sketchbook → examples → basic → blink. Sie wissen ja, "blink" ist das "Hello World" der Controllerprogrammierer. Das Programm wird auf das Board übertragen und startet sofort, woraufhin die SMD-LED auf dem Board blinkt.

Angesprochen wird Arduino also über die USB-Schnittstelle. Zum einen wird darüber das Programm in den Controller geladen, zum anderen kann das Board über eine virtuelle Seriellschnittstelle mit dem PC kommunizieren. Das kann über das im Entwicklungssystem eingebaute ASCII-Terminal genauso geschehen, wie über ein Terminalprogramm (z.B. "putty" unter Windows oder "minicom" unter Linux). Oder man schreibt sich das Terminalprogramm mit einigen Zeilen Perl selbst. Mit Sensoren und Aktoren versehen kann Arduino als Messfühler, Sinnesorgan oder Eingabegerät dienen und seine Daten an den PC weitergeben.

Die Programme werden im sogenanten sketchbook (bei Windows im Ordner Eigene Dateien\Arduino abgelegt (ausser, Sie wählen eine portable Installation). Für jedes Programm wird ein Unterverzeichnis mit dem Namen des Programms angelegt. Wird das Programm von Hand umbenannt, muss auch der Ordner den gleichen neuen Namen erhalten. Die Dateinamen dürfen keine Umlaute, Sonderzeichen oder Leerzeichen enthalten. In diesem Projektordner werden diverse Proejktdateien und -ordner angelegt. Zur Weitergabe oder Archivierung des Programmes muss nur die .ino–Datei kopiert werden.

Unterstützt wird die Anwendung durch zahlreiche Bibliotheken, etwa für die Ansteuerung eines LC-Displays oder die Kommunikation per I2C-Bus mit angeschlossenen Sensoren. Inzwischen gibt es auch etliche Buchtitel zum Arduino.

Der Name Arduino bezeichnet auch die zugehörige kompakte integrierte Entwicklungsumgebung (IDE) für den Steuercode. Hiermit entwickelt man kleine Programme, "Sketches" genannt (übrigens heissen die Boards zum Aufstecken auf den Arduino "Shields"), und sendet sie per USB als Maschinencode an das Arduino-Board. Dessen Bootloader schreibt das Programm selbst dauerhaft in seinen Flash-Speicher und führt es sofort danach aus. Die IDE steht auf der Arduino-Homepage kostenlos für Windows, Linux und Mac OS X zum Download bereit. Sie ist nach Auspacken des ZIP-Archivs sofort gebrauchsfertig, es muss also nichts installiert werden. Um die USB-Verbindung zum Rechner gegenüber dem Board als serielle Schnittstelle auszugeben, ist allerdings noch ein USB-Treiber für das jeweilige Betriebssystem notwendig. Im Arduino-Paket stehen im Verzeichnis "drivers" solche Treiber zur Verfügung, die aber nicht besonders aktuell sind. älteren Version. Am besten aktualisiert man den Treiber dann gleich noch.

Die Arduino-Programmiersprache ist ein Subset von C mit einigen Objekteigenschaften. Das Quellprogramm wird per GCC (GNU C Compiler) übersetzt. Die Sprache ist sehr einfach zu erlernen, selbst wenn man bisher mit anderen Programmiersprachen gearbeitet hat. Ein Arduino-Programm besteht grundsätzlich aus zwei Teilen, einem Initialisierungsblock (setup()), der bei Beginn einmal durchlaufen wird, und einer anschließenden Endlosschleife (loop()), was der typischen Controlleranwendung entspricht. Sinnvoll ist es auf jeden Fall, für die benutzten Pins des Arduino-Boards sprechende Namen zu wählen. Für die ersten Schritte sind die Arduino-Funktionen für Ein- und Ausgabe wichtig. So definiert man mit pinMode() den entsprechenden Pin entweder zum Eingang (pinMode(Pin, INPUT)) oder zum Ausgang (pinMode(Pin, OUTPUT). Von einem Eingangs-Pin wird mit digitalRead(Pin) gelesen und mit digitalWrite(Pin, HIGH) schreibt man eine 1 (5 V) auf einen Ausgangspin. LOW hingegen stünde für die 0 (0 V).

Sechs der Pins eines Arduino (A0 bis A5) führen zu einem Analog-Digital-Wandler (ADC) und erlauben das Einlesen analoger Werte. Der ADC übersetzt die analogen Eingangsspannungen zwischen 0 V und 5 V in digitale Werte zwischen 0 und 1023 - es handelt sich also um einen 10-Bit-Wandler. Gelesen wird mit der Funktion analogRead(). Die Ausgabe analoger Werte erfolgt jedoch nicht über einen Digital-Analog-Wandler, sondern per Pulsweitenmodulation (PWM) auf den Pins 3, 5, 6, 9, 10 und 11. Es wird also kein echter Analogwert ausgegeben. Vielmehr wird am jeweiligen Pin ein Rechtecksignal ausgegeben. Das Verhältnis von Einschalt- zu Ausschaltzeit bestimmt den analogen Ausgabewert. Auf diese Weise kann man beispielsweise eine LED dimmen (die Trägheit des Auges "integriert" den Wert). Über ein Verstäkerelement könnte man die Drehzahl eines Gleichstrommotors steuern - hier ist es die Trägheit des mechanischen Systems, die integrierend wirkt. Für einen sauberen Analogwert ist allerdings ein Tiefpassfilter nötig, wobei meist ein RC-Glied ausreicht. Die Ausgabe erfolgt mittels analogWrite().

Die Arduino-Familie

Inzwischen gibt es zahlreiche Arduino-Varianten, vom Lilipad für "Wearables" bis hin zu Typen mit Arm-Kern. Die Open-Source-Eigenschaft des Arduino hat auch zu zahlreichen Kopien und Nachbauten geführt, deren Qualität manchmal fragwürdig ist. Deshalb werden hier nur einige Typen erwähnt. Den Kern des Arduino-Boards bildete beim Duemilanove (2009) ein Atmel ATmega168, ein 8-Bit-Mikrocontroller mit 16 MHz Takt, 16 KByte Programm-Flash (davon sind 0,5 KByte vom Bootloader belegt), 1 KByte SRAM für Variablen. Beim aktuellen Arduino Uno wird ein ATmega368 eingesetzt, der 32 KByte Programmspeicher (0,5 KByte Bootloader) besitzt. Laut Datenblatt liefert jeder Pin bis zu 20 mA Strom. Auch darf die Summe der Ströme an bestimmten Ports nicht mehr als 100 mA betragen. Das reicht, um beispielsweise Leuchtdioden direkt zu betreiben. Stärkere Ströme steuert man per nachgeschaltetem Transistor oder anderen Verstärkern. Im Betrieb wird der Arduino entweder per USB oder per Netzteil (7 bis 12 V) versorgt.

Der Arduino Uno (R3) dient heute als Basis der Arduino-Produktlinie. Die Entwickler ersetzten den betagten FTDI-Chipsatz durch einen neu entwickelten USB-Serial-Konverter, der auf einem ATmega8U2 basiert, kürzere Latenzzeiten als sein Vorgänger aufweist und so programmiert werden kann, dass er sich beim System auch als USB-Tastatur anmelden kann.

Das Arduino-Mega-2560-Board basiert auf einem ATmega-2560-Chipsatz und ist ebenfalls mit 16 MHz getaktet. Das Board bietet jedoch mehr Schnittstellen als der Uno: 54 digitale I/O-Pins, 16 analoge Eingänge, 4 serielle Schnittstellen und einen USB-Port. Der Arduino Mega bietet 256 KByte Programmspeicher, von denen 8 KByte bereits vom Bootloader belegt sind.

Arduino-Boards gibt es in den verschiedensten Ausführungen, neben den neuen Platinen gibt es die Modelle Pro, Fio, Nano, Mini und LilyPad. Der Uno kostet etwa 25 Euro, der Mega rund 50 Euro. Das folgende Bild zeigt den kleinen und schmalen Arduino Nano.

Erweitert wird das Basis-Board mit so genannten Shields, die über die Buchsenleisten angeschlossen werden. Es ergibt sich so ein Stapel von Platinen, bestehend aus einem Arduino-Board und weiteren Shields. Unter shieldlist.org kann man mit großer Wahrscheinlichkeit ein Shield für eigene Entwicklungen finden, ohne dass eine eigene Hard- und Software-Entwicklung nötig ist. Aktuell sind dort über 150 Shields gelistet. Für eigene Entwicklungen kann man Prototyp-Shields erwerben.

Die Arduino-Software besteht aus dem Bootloader für den Arduino (damit er Programme über die serielle Schnittstelle laden kann) und aus einer integrierten Entwicklungsumgebung (IDE) und Core Libraries. Die Core Libraries sind in C und C++ geschrieben und basieren auf avr-gcc und derAVR-Libc. Die Entwicklungsumgebung ist in Processing geschrieben und, wie gesagt, Open Source.

Inzwischen gibt es weitere Familienmitglieder, die in der folgenden Tabelle aufgeführt sind.

Bezeichnung Microcontroller Flash SRAM EEPROM I/O-Pins I/O-Pins mit PWM Abmessungen
Arduino Uno Dip ATmega328 32 KB 2 KB 1 14 6 Breite: 53,4 mm
Länge: 68,6 mm
Arduino Uno ATMega328 32 KB 2 KB 1 14 6 Breite: 53,4 mm
Länge: 68,6 mm
Arduino Mega ATmega2560 256KB 8 KB 4 54 14 Breite: 53,3 mm
Länge: 101,5 mm
Arduino Enet2 ATmega32u4 32 KB 2,5KB 1 14 4 Breite: 68,8 mm
Länge: 53,0 mm
Arduino M0 Pro ATSAMD21G18 256 KB 32 0 20 2 Breite: 53,4 mm
Länge: 68,6 mm
Arduino Mini ATmega328 32 KB 2 KB 1 14 6 Breite: 30,0 mm
Länge: 18,0 mm
Arduino Nano ATmega328 32 KB 2 1 14 6 Breite: 18,0 mm
Länge: 45,0 mm
Arduino Yun ATmega32u4 32 KB 2,5 KB 1 20 7 Breite: 56,0 mm
Länge: 85,6 mm
Arduino Leonardo 700 MHz 256 MB 26 PINs 1 Port - 7 Breite: 53,0 mm
Länge: 73,0 mm

Erste Schritte

Nach dem Starten der Arduino-IDE öffnet sich das Hauptfenster, in dem der Quelltext des Anwenderprogramms eingegeben und bearbeitet werden kann. Die serielle Kommunikation erfolgt über das USB-Interface und einen virtuellen COM-Port auf dem PC. Danach kann sofort mit der Eingabe von Quelltext begonnen werden. Die Programme (Sketches) tragen die Endung ".pde".

Im folgenden Bild kann man den allgemeinen Programmaufbau erkennen. Die beiden oben erwähnten Funktionen setup() und loop() bestimmen die Programmstruktur eines jeden Arduino-Programms. setup() ist für die Initialisierungen zuständig und loop() stellt eine Endlosschleife dar, die die Aktionen des eigentlichen Anwenderprogramms enthält. Wie bei C üblich, können außerhalb dieser Routinen weitere Funktionen definiert werden, die dann von setup() bzw. loop() aus aufgerufen werden. Im ersten Sketch wird das Blinken des als Ausgang geschalteten Pins 13 (PB5) erzeugt.

Über die serielle Schnittstelle wird anfangs der String "Hallo Welt" ausgegeben. Danach wird eine Meldung bei jedem Ein- und ausschalten ausgegeben. Damit man das Blinken auch sieht, sorgt die Funktion delay(1000) für eine Pause von einer Sekunde bis zur nächsten Aktion. Durch ein mit C0M3 verbundenes Terminalprogramm oder die Terminalfunktion der IDE kann der ausgegebene String angezeigt werden. Das ist dabei auf die passende Datenrate eingestellt (9600 bps). Diese Seriellschnittstelle erlaubt es zudem, den Arduino als Peripherie für nahezu jedes Programm ins System einzugliedern. So wäre es relativ leicht möglich, die Ausgaben des Boards über ein entsprechendes CGI-Programm in eine Webseite einzubinden.

Über die Schaltflächen an der Oberkante des Fensters oder die Menüleiste lassen sich alle Funktionen der IDE steuern. Unterhalb des Textfensters wird der aktuelle Programmzustand angezeigt. Das Feld ganz unten ist für Ausgaben des Compilers, des Linkers und des Downloaders vorgesehen. Hier wird auch die Größe des erzeugten Codes ausgegeben.

Nach dem ersten Start der IDE sind lediglich zwei Dinge einzustellen: die verwendete Arduino-Variante und der verwendete COM-Port. Wie das folgende Bildschirmfoto zeigt, macht es das System dem Einsteiger besonders leicht. über das Help-Menü ist auch die komplette Sprachreferenz der sehr C-ähnlichen Programmiersprache abrufbar. Im File-Menü gibt es auch ein Untermenü "Examples" aller Beispiele und Testprogramme (siehe Bild). Das "Sketchbook" ist das Äquivalent der "Eigenen Dateien" für die erstellten Programme. Die Lage des Sketchbooks kann über die Preferences eingestellt werden. Auch dort beschränkt sich die IDE auf das Nötigste. Wirklich alle Einstellungen findet der Profi in einer Textdatei namens "preferences.txt". In der folgenden Abbildung sehen Sie die Werkzeugleiste der IDE, mit der Sie schnellen Zugriff auf die wichtigsten Funktionen erhalten.

Das Ansteuern von LEDs und Siebensegmentanzeigen oder anderes muss beim real vorhandenen Arduino-Board zusätzliche Hardware leisten (auf dem Board ist nur die Pin-13-LED vorhanden). Am Besten besorgen Sie sich entweder einen Kit, wie er z. B. von Watterot angeboten wird, oder Sie beschaffen die Bauteile im Elektronikhandel. Auf jeden Fall gehört ein "Breadbord" dazu, ein Steckbrett zum schnellen Aufbau von Schaltungen. Im folgenden Bild ist eine Mini-Version des Steckbretts abgebildet. Denken Sie auch daran, dass die LEDs immer einen Vorwiderstand benötigen.

Auf dem Bild oben sehen Sie neben LEDs und Widerständen auch Subminiatur-Taster, eine Diode, ein Trimmpotenziometer, einen Verstärker-Transistor und einen Piezo-Summer. Beim Steckbrett sind jeweils fünf senkrecht übereinander liegende "Löcher" miteinander verbunden. Die Bauteile werden passend zu Schaltung auf dem Brett platziert und weitere notwendige Verbindungen per Drahtbrücke hergestellt. Zum Entwurf und zur Darstellung solcher Breadboard-Schaltungen gibt es unter dem Namen "Fritzing" sogar eine Software. Wenn dann alles funktioniert, kann die Schaltung auf ein Prototyp-Shield übertragen werden - oder man entwirft eine eigene Platine und lässt diese anfertigen. Dann muss sie nur noch bestückt werden.

Beim Experimentieren sollten Sie zuerst die Schaltung komplett aufbauen, bevor Sie den Arduino mit Strom versorgen. Auch ist es ratsam, eine Steckbrett-Schaltung mehmals zu kontrollieren, um Steckfehler auszuschließen. Vor dem Hochladen sollte auch der Sketch zur Kontrolle einmal übersetzt werden ("Verify"), um zu überprüfen, ob er zumindest syntaktisch korrekt ist.

Das folgende Bild zeigt als Übersicht die Belegung der Ein- und Ausgabeports sowie deren unterschiedliche Belegungsmöglichkeiten von Seiten das Atmega-Prozessors.

Übrigens: Alle Pins können digital - auch jene, die mit "Analog0" bis "Analog5" beschriftet sind. Diese Pins können als Eingänge nämlich analoge oder digitale Signale verarbeiten und als digitale Ausgänge verwendet werden. Es gilt:

   Analog 0  =  Digital 14
   Analog 1  =  Digital 15
   Analog 2  =  Digital 16
   Analog 3  =  Digital 17
   Analog 4  =  Digital 18
   Analog 5  =  Digital 19
Man kann z. B. nach pinMode(19, OUTPUT) mit digitalWrite(19, HIGH) bzw. digitalWrite(19, LOW) Digitalwerte ausgeben.

Neugierig?

Wenn Sie genauer sehen wollen, was sich so hinter den Kulissen abspielt, wenn Sie ein Sketch compilieren oder hochladen, können Sie die Arduino-IDE geschwätziger machen. Dazu wählen Sie im Dateimenü den Punkt "Voreinstellungen" (Preferences) und setzen bei "Ausführliche Ausgabe während:" jeweils ein Häkchen bei "Kompilierung" und "Hochladen".

Bei der Gelegenheit können Sie dann gleich noch andere Einstellungen vornehmen, etwa die Aktivierung der Code-Faltung.

Nach einem Compilerlauf, erfahren Sie so auch, wo die IDE ihre Dateien "versteckt", z. B. beim Windows-PC die HEX-Datei unter C:\Users\plate\AppData\Local\Temp\ build9c9ef3bdfe2fccb480bc6e4bac749e41.tmp/Blink.ino.hex. Das Format dieser Datei ist im Dokument Hexfrmt.pdf beschrieben. Da hier der Binärcode in einem ASCII-Format gespeichert ist, eignet sich die Datei nicht nur für die Weitergabe von Binärcode, sondern kann auch von anderen Programmen verarbeitet werden.

Die interne LED

Die meisten Arduino- und Genuino-Boards haben eine eingebaute LED. Diese LED ist mit einem digitalen Pin verbunden und ihre Nummer kann von Board-Typ zu Board-Typ variieren. In der Regel ist es der Digitalport P13. Um Ihr Leben leichter zu machen, gibt es eine Konstante, die in jeder Board-Deskriptor-Datei angegeben ist. Diese Konstante heißt LED_BUILTIN und ermöglicht, die eingebaute LED zu steuern, ohne die Pin-Nummer zu kennen. Siehe auch das "blink"-Beispiel.

Serielle Schnittstelle

Die beiden Digital-Pins D0 und D1 werden vom USB-Controller als serielle Schnittstelle angesprochen, etwa beim Hochladen eines Programms. Weshalb in der Original-Dokumentation steht: "... Digital Pins 0-1/Serial In/Out - TX/RX: These pins cannot be used for digital i/o (digitalRead and digitalWrite) if you are also using serial communication..." Auf Deutsch: An Pin D0(RX) und Pin D1(TX) sollte keine externe Peripherie (Taster, LEDs etc.) angeschlossen werden solange die serielle Schnittstelle verwendet wird.

Die serielle Kommunikation ist beim Arduino im Standardfall immer aktiv, sobald der PC per USB mit dem Arduino verbunden ist, etwa um einen Sketch hochzuladen oder den "Serial Monitor" zu verwenden. Solange sich ein Bootloader auf dem Atmel-Controller befindet, hat man bei jedem Reset kurzzeitig eine serielle Kommunikation, weil der Bootloader bei jedem Reset versucht, einen neuen Sketch über die serielle Schnittstelle zu laden, bevor das eigentliche Programm startet. Der Bootloader läuft immer vor dem eigentlichen Programm.

Wenn man keine serielle Schnittstelle in seinem Programm benötigt, kann man die Pins D0 und D1 durchaus verwenden. Beide Pins funktionieren einwandfrei solange der Controller sein Programm in loop() abarbeitet. Nur beim Reset bzw. Einschalten werden diese beiden Pins verwendet - eine angeschlossen LED würde blinkern. Ist dort ein externes serielles Gerät angeschlossen, kann dieses auch gestört werden oder es läßt sich kein Sketch mehr hochladen. Es ist daher empfehlenswert, diese beiden Pins möglichst nicht zu verwenden. Nur im Notfall, wenn beispielsweise die Pins ausgehen und sonst alles belegt ist. Auch dann muss man daran denken, dass an den Pins nicht komplett frei sind. Sie sind noch immer mit dem USB-Chip über zwei 1-kΩ-Widerstände verbunden:

Bei der Verwendung wird also immer ein "Fremdpegel" auf den Leitungen liegen. Siehe auch Arduino-Programmierung.

Umstieg auf Arduino 1.x

Ab der Version 1.0 der Arduino-IDE haben sich einige Dinge geändert. Wer also ältere Programme laufen lassen will, muss einige Anpassungen vornehmen. Es ist nicht besonders viel, aber etwas ist doch zu tun. Das Wichtigste zuerst:

Die Bibiothek WProgram.h wurde ab IDE 1.0 durch die Arduino.h ausgetauscht. Wenn eine Zusatz-Bibiothek unter Arduino 1.0 die Fehlermeldungen liefert, das WProgramm.h nicht vorhanden sei, kann man folgendes an den Anfang der betreffenden Bibiothek schreiben. So funktioniert sie unter der alten und neuen IDE:

#if defined(ARDUINO) && ARDUINO >= 100
#include "Arduino.h"
#else
#include "WProgram.h"
#endif

Ab Arduino IDE Version 1.0 wurde die F()-Syntax eingeführt. Mit ihr kann man Strings im Flash-Speicher anstatt im RAM ablegen und so Speicherplatz im RAM gewinnnen. Zum Beispiel:

Serial.println(F("This string will be stored in flash memory"));

Arduino 1.x führt eine Reihe von Verbesserungen und Änderungen bei der Serial-Bibliothek ein:

Beim I2C-Bus haben sich die Namen der Methoden geändert:

Wire.send()Wire.write()
Wire.receive()Wire.read()

Die Methode Wire.write() benötigt für Konstante Parameter nun eine Typspezifikation. Statt beispielsweise Wire.write(0x10) muss man nun Wire.write((byte)0x10) schreiben.

Die Arduino-Versionen 1.x unterstützten nun Stream-Parsing-Methoden:

Energieversorgung des Arduino Uno

Die Stromversorgung des Arduino über die USB-Schnittstelle ist während der Entwicklung sehr praktisch. Soll er aber autark arbeiten und sind eventuell etwas strombedürftige Verbraucher auf einen Shield montiert, bedarf es einer eigenen Stromversorgung. Da stellt sich dann oft die Frage, ob man den Arduino ausschliesslich über die Hohlbuche mit 7 - 10 V Gleichspannung versorgen muss, oder ob man die 5 V auch von einen Shield aus zuführen kann. Gleich vorab: man kann!

Der folgende Auszug aus dem Arduino-Schaltplan zeigt die relevanten Komponenten (das ist halt das Schöne an Open Source - man kann einfach mal nachschauen):

Die verschiedenen Spannungsquellen im Schaltplan sind:

Der 5-V-Spannungsregler verkraftet maximal 1 A. Der reale Maximalstrom hängt aber auch von der Wärme ab, die im Regler entsteht (bei 10 V EIngangsspannung eben höher als bei 7 - 8 V). Der Regler für die 3,3 V liefert maximal 150 mA.

Alternative GUI: Arduino-Builder

Neben dem Kommandozeilentool gleichen Namens, gibt es unter http://arduinodev.com/software/arduino-builder/ eine alternative GUI zum Herunterladen. Arduino Builder ist ein Standalone-Programm zur Anzeige, zum Compilieren und zum Hochladen von Arduino Sketches. Auch das Hochladen von kompilierten ELF- oder HEX-Dateien auf Arduino-Boards über die serielle Schnittstelle oder den ISP-Anschluss ist möglich.

Die Distribution enthält die aktuellen Arduino-Kern- und -Bibliotheksdateien, den AVR GCC-Compiler mit Toolchain und das AVRDUDE-Programm. Bitte beachten Sie, dass nur die Standard-Arduino-Bibliotheken mit dem Programm ausgeliefert werden.

Alternative GUI: Geany

Unter Linux greifen Programmierer nicht nur oft auf den "Urgroßvater" aller Programmeditoren, den "vi" (oder auch "Vim") zurück, sondern verwenden für kleinere Aufgaben "Geany" als IDE. Geany ist schlank, schnell und einfach zu bedienen und bietet dem geübten Programmierer mehr Komfort als die Arduino-IDE. Geany gibt es übrigens nicht nur für Linux, sondern auch für Windows und den Mac. Wie die Installation unter Linux mit Debian oder Ubuntu läuft, zeigt die Webseite Tinkering Arduino im Blogeintrag vom 18. Mai 2013.

Die Arduino-IDE portabel machen

Die Arduino-IDE legt, wie viele Windows-Programme, ihre Dateien und Ordner an festgelegten Stellen auf der Festplatte ab. Wenn Sie immer nur auf ihrem eigenen Computer arbeiten, spielt das keine Rolle, wenn Sie jedoch öfter mal den Firmen-PC oder Uni-Computer benutzen müssen, auf dem Sie keine Packages oder Bibliotheken installieren dürfen, kann dies ein Problem darstellen.

Mit einem kleinen Trick kann man eine portable Arduino-IDE erzeugen, die alles, was man braucht in einem Ordner enthält. Um die IDE portabel zu machen, müssen Sie ledigliglich im Installationsordner (der mit der Datei arduino.exe) einen zusätzlichen Ordner namens "portable" anlegen. Das Anlegen erfordert Administrator-Rechte, wenn die IDE im "Programme"-Ordner von Windows angelegt wird. In diesem Fall muss der Ordner dann auch noch für alle Benutzer für den Zugriff freigegeben werden (über die Dateieigenschaften). Beim nächsten Start der IDE wird dieser automatisch erkannt und als Speicherort verwendet. Alle von Ihnen nachträglich installierten Pakete und Bibliotheken sowie auch alle Zwischendateien werden dort abgelegt. Alles befindet sich dann ordentlich in einem einzigen Ordner, den Sie auf einen USB-Stick mitnehmen können.

Die portable IDE bietet auch die Möglichkeit, verschiedene Arduino-Installationen auf einem Rechner getrennt zu halten. Bibliotheken und Pakete der Arduino-IDE werden ja regelmäßig aktualisiert. Wenn man stets die aktuelle IDE installiert, profitiert zwar jedes neue Projekt davon, aber es kann möglicherweise ein altes Projekt nicht mehr funktionieren. Mit der portablen IDE lassen sich Projekte leicht archivieren.

Da der portable Ordner einfach in andere IDE-Installationen kopiert werden kann, ermöglicht dies auch eine schnelle Einrichtung von identischen IDEs auf mehreren Computern. Auf einem System werden alle zusätzlichen Dinge im portablen Ordner installiert und dieser dann auf die anderen Rechner kopiert. Das wird man bei Schulungen sicherlich zu schätzen wissen. So können in einem Kurs die Teilnehmer nicht nur Ihre Projekte einfach mit nach Hause nehmen, sondern es können von den Teilnehmern auch Bibliotheken oder Paketet installiert werden. Für den nächsten Kurs wird der portable Ordner dann gelöscht und wieder durch den Standard-Ordner ersetzt.

Siehe auch: https://www.arduino.cc/en/Guide/PortableIDE

COM-Port unter Windows fest einstellen

Man kann unter Windows den COM-Port für den Arduino auch dauerhaft festlegen, dann muss man nicht im Falle des Falles nach dem COM-Port suchen. Auch ist das nützlich, wenn ein Programm auf dem PC über die serielle Schnittstelle mit dem Arduino kommunizieren soll. Das Programm kann dan fest für einen bestimmten COM-Port konfiguriert werden. Um das zu erreichen, öffnen Sie in der Systemsteuerung den Geräte-Manager. Dort suchen Sie Anschlüsse (COM & LPT)Arduino .... Im Bild ist dies (zufällig) COM14).Klicken Sie auf den Eintrag des Arduino mit der rechten Maustaste und wählen Sie im sich öffnenden Menü den Punkt Eigenschaften. Dort geht es weiter mit dem Reiter Anschlusseinstellungen. Klicken Sie auf die Schaltfläche Erweitert. Dort könne Sie nun einen COM-Port auswählen. Bestätigen Sie alles mit "OK". Solange der Adapter immer im gleichen USB-Port steckt, sollte auch die Nummer des COM-Ports (im Bild wurde COM4 gewählt) unverändert bleiben.

Manchmal stellt man fest, dass bei der Auswahl des COM-Ports nur noch zweistellige Portnummern frei sind und zahlreiche COM-Ports als "belegt" geführt werden, obwohl vielleicht nur der Arduino am Rechner steckt. Die Ursache kann im Windows-System oder in den Treibern des verwendeten USB-Geräts liegen. Manche, schlecht programmierte Software, legt bei jedem Einstecken einen neuen COM-Port an, ohne dass die nicht mehr verwendeten Ports der letzten Durchläufe gelöscht werden. Auf diese Weise tritt sehr bald der Zustand ein, dass keine COM-Ports mehr angelegt werden können oder der von manchen Geräten verwendete Bereich von COM1 bis COM16 verlassen wird. Bedauerlicherweise werden diese angelegten, aber unbenutztbaren Ports in der Windows-Systemsteuerung nicht angezeigt. Diese "Zombie-Ports" sind also im System virtuell vorhanden, aber nicht anwendbar und unsichtbar.

Solche "Zombie-Ports" können mit der folgenden Massnahm in der Systemsteuerung sichtbar gemacht und dann entfernt werden:

  1. Öffnen der Eingabeaufforderung als Administrator (Rechtsklick auf das Symbol und "Als Administrator öffnen" anklicken).
  2. Die folgenden Eingaben auf der Kommandozeile oder in einer Batch-Datei ausführen:
    set devmgr_show_nonpresent_devices=1
    set devmgr_show_details=1
    start DEVMGMT.MSC
    
  3. Im nun gestarteten Gerätemanager unter Ansicht bei Ausgeblendete Geräte anzeigen ein Häckchen setzen! Schon werden die Zombies angezeigt und können gelöscht werden.
Das Verfahren eignet sich auch für andere Gerätetypen, insbesondere auch für inaktive Parallelschnittstellen.


Copyright © Hochschule München, FK 04, Prof. Jürgen Plate und die Autoren
Letzte Aktualisierung: