Description: Arduino-Kurzeinfuehrung
Keywords: Arduino

| ### 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:

- Im Reiter Tools → Board den Typ des Boards auswählen
- Im Reiter Tools → Serial port den Port auswählen (ggf. mittels Systemsteuerung → System → Hardware → Gerätemanager unter Ports die Nummer des benutzten COM-Ports suchen).

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. 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.

- Mit der Schaltfläche Verify (übersetzen) können Sie das Programm kompilieren, das gerade im Editor ist. Eigentlich ist die Bezeichnung "Verify" (= überprüfen) ungünstig gewählt, da die Funktion mehr als die syntaktische überprüfung des Programms vornimmt: Sie erzeugt vielmehr aus dem Quelltext den Binärcode für das Arduino-Board.
- Die Schaltfläche New (Neue Datei) erstellt ein neues Programm. Der Inhalt des aktuellen Editor-Fensters wird gelöscht. Gegebenenfalls noch nicht gespeicherten Quelltext können Sie auf jeden Fall noch sichern.
- Mit Open laden Sie eine Programmdatei von der Platte oder einem anderen Speichermedium.
- Save speichert das aktuelle Programm.
- Wenn Sie auf die Schaltfläche Upload klicken, kompiliert die IDE das aktuelle Programm (sofern nicht schon geschehen)und transferiert es auf das Arduino-Board.
- Arduino kommuniziert mit dem Computer über die serielle Schnittstelle. Wenn Sie auf die Schaltfläche Serial Monitor (Serielles Terminal) klicken, können Sie die Ausgaben des Arduino lesen und Daten zum Arduino zurück senden.
- Die Schaltfläche Stop hält den seriellen Monitor an.
- das Help-Menü verweist auf hilfreiche Informationen, die man auf der Arduino-Website finden kann, zusammen mit schnellen Lösungen für typische Probleme, Referenzinformationen und Anleitungen.

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.

### 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:

- `Serial.flush` wartet nun, bis alle ausgehenden Daten gesendet wurden, statt empfangene Daten einfach zu ignorieren. Die folgende Anweisung löscht alle Daten aus dem Empfangspuffer:

      while(Serial.read() >= 0);

- `Serial.write` und `Serial.print` blockieren nun nicht mehr. Die Daten von `Serial.write` werden nun per Interrupt im Hintergrund übertragen. Manchmal muss man nun warten, bis alle Zeichen gesendet wurden. Gegebenenfalls ruft man `Serial.flush()` gleich nach `Serial.write()` auf.
- Die Funktion `Serial.peek()` wurde hinzugefügt, damit man sich das nächste Zeichen im Empfangspuffer ansehen kann, ohne es einzulesen. Im Gegensatz zu `Serial.read` wird das Zeichen mit Serial.peek nicht aus dem Puffer entfernt.

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:

- `boolean find(char *target)` liest aus dem Stream, bis das angegebene Ziel (target) gefunden wurde. Gibt `true` zurück, wenn der Zielstring gefunden wurde. Der Stream wird beim Parsing nur einmal verarbeitet, man kann also nicht zurückgehen, um etwas anderes zu suchen.
- `boolean findUntil(char *target, char *terminate)` ähnelt der vorhergehenden Methode, hier endet die Suche jedoch erst, wenn der Terminierungsstring gefunden wird. Gibt `true` zurück, wenn das Ziel gefunden wurde.
- `long parseInt()` gibt den ersten gültigen (langen) Integerwert zurück. Führende Zeichen, die keine Ziffern und kein Minus- oder Pluszeichen sind, werden übersprungen. Der Integerwert wird bei der ersten auf die Zahl folgenden Nicht-Ziffer abgeschlossen. Werden keine Ziffern gefunden, gibt die Funktion 0 zurück.
- `long parseInt(char skip)` arbeitet wie `parseInt()`, das angegebene Zeichen `skip` wird innerhalb des numerischen Wertes ignoriert. Verwendbar, um einen einzelnen numerischen Wert einzulesen, der durch Satzzeichen getrennt ist (1,234,555).
- `float parseFloat()` arbeitet wie `parseInt()`, jedoch für Gleitpunktzahlen.
- `size_t readBytes(char *buffer, size_t length)` liest eingehende Zeichen in den angegebenen Puffer ein, bis es zum Timeout kommt oder die angegebene Anzahl Zeichen (`length`) eingelesen wurde. Gibt die Anzahl der im Puffer abgelegten Zeichen zurück.

### 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:

- USBVCC: 5 V stabilisiert über USB
  Die durch Sicherung F1 über USB ankommende Spannung. Sofern VIN größer als ca. 6,6 V wird, sperrt der Komparator U5A über den Mosfet T1 die USB-Spannungsversorgung. Die Versorgung wird dann von VIN übernommen.

- PWRIN: 7 - 10 V per Steckernetzteil
  Der Anschluss für ein externes Steckernetzteil. Die Diode D1 verhindert, dass bei höherer Spannung VIN ein Rückstrom in das Netzteil fließt.

- VIN: Stromversorgungs-Pin auf dem Board
  Entweder eine direkt am Pin VIN angeschlossene Spannungsquelle oder die über die Diode D1 ankommende Spannung PWRIN vom Steckernetzteil. Die Spannung wird über den Spannungsregler U1 auf +5V geregelt.

- +5V: Spannung auf dem Board
  Die geregelte 5-V-Versorgungsspannung für das Arduino-Board.

- +3V3: Spannung auf dem Board
  Die geregelte 3,3-V-Versorgungsspannung, die direkt aus den 5 V erzeugt wird.

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.

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