Erste Schritte

Diese Arbeit wurde mithilfe von KI übersetzt. Wir freuen uns über dein Feedback und deine Kommentare: translation-feedback@oreilly.com

1.0 Einleitung

Die Arduino-Umgebung wurde so konzipiert, dass sie auch von Anfängern, die keine Erfahrung mit Software oder Elektronik haben, leicht zu bedienen ist. Mit Arduino kannst du Objekte bauen, die auf Licht, Ton, Berührung und Bewegung reagieren und/oder diese steuern. Mit Arduino wurden schon die unterschiedlichsten Dinge gebaut, darunter Musikinstrumente, Roboter, Lichtskulpturen, Spiele, interaktive Möbel und sogar interaktive Kleidung.

Arduino wird in vielen Bildungsprogrammen auf der ganzen Welt eingesetzt, vor allem von Designern und Künstlern, die auf einfache Weise Prototypen erstellen wollen, aber kein tiefes Verständnis für die technischen Details hinter ihren Kreationen benötigen. Da die Software so konzipiert ist, dass sie auch von technisch nicht versierten Personen genutzt werden kann, enthält sie viele Beispielcodes, die zeigen, wie die verschiedenen Funktionen des Arduino-Boards genutzt werden können.

Obwohl Arduino einfach zu bedienen ist, arbeitet die zugrundeliegende Hardware auf demselben hohen Niveau, das Ingenieure für die Entwicklung eingebetteter Geräte verwenden. Menschen, die bereits mit Mikrocontrollern arbeiten, fühlen sich von Arduino auch wegen seiner agilen Entwicklungsmöglichkeiten und der schnellen Umsetzung von Ideen angezogen.

Arduino ist vor allem für seine Hardware bekannt, aber du brauchst auch Software, um die Hardware zu programmieren. Sowohl die Hardware als auch die Software werden als "Arduino" bezeichnet. Die Hardware (Arduino und Arduino-kompatible Boards) kannst du preiswert kaufen oder selbst bauen (die Hardware-Designs sind Open Source). Die Software ist kostenlos, quelloffen und plattformübergreifend. Diese Kombination ermöglicht es dir, Projekte zu erstellen, die die physische Welt wahrnehmen und steuern.

Außerdem gibt es eine aktive und hilfsbereite Arduino-Community , die weltweit über die Arduino-Foren, Tutorials und den Project Hub erreichbar ist. Auf diesen Seiten findest du Lernressourcen, Beispiele für die Projektentwicklung und Lösungen für Probleme, die dich bei deinen eigenen Projekten inspirieren und unterstützen können.

Arduino Software und Skizzen

Softwareprogramme, sogenannte Sketches, werden auf einem Computer mit der integrierten Entwicklungsumgebung (IDE) von Arduino erstellt. Mit der IDE kannst du Code schreiben und bearbeiten und diesen Code in Anweisungen umwandeln, die die Arduino-Hardware versteht. Die IDE überträgt diese Anweisungen auch in Form von kompiliertem Code auf das Arduino-Board (ein Vorgang, der Upload genannt wird).

Tipp

Du bist es vielleicht gewohnt, Software-Quellcode als "Programm" oder einfach als "Code" zu bezeichnen. In der Arduino-Community wird der Quellcode, der Computeranweisungen zur Steuerung der Arduino-Funktionen enthält, als Sketch bezeichnet. Das Wort Sketch wird in diesem Buch durchgehend für Arduino-Programmcode verwendet.

Die Rezepte in diesem Kapitel erklären dir, wie du die Entwicklungsumgebung einrichtest und wie du einen Beispielsketch kompilierst und ausführst.

Der Blink-Sketch, der auf den meisten Arduino-Boards und kompatiblen Geräten vorinstalliert ist ( ), wird als Beispiel für die Rezepte in diesem Kapitel verwendet. Das letzte Rezept in diesem Kapitel geht jedoch noch weiter, indem es Töne hinzufügt und Eingaben über zusätzliche Hardware erfasst, anstatt nur das in das Board eingebaute Licht zu blinken. Kapitel 2 behandelt die Strukturierung eines Sketches für Arduino und gibt eine Einführung in die Programmierung.

Hinweis

Wenn du dich bereits mit den Arduino-Grundlagen auskennst, kannst du gerne zu späteren Kapiteln übergehen. Wenn du zum ersten Mal mit Arduino arbeitest, wird sich deine Geduld bei diesen ersten Rezepten später durch bessere Ergebnisse auszahlen.

Arduino Hardware

Das Arduino-Board ist der Ort, an dem der von dir geschriebene Code ausgeführt wird. Das Board kann nur Elektrizität steuern und darauf reagieren. Deshalb wirst du bestimmte Komponenten an ihm befestigen, die es ihm ermöglichen, mit der realen Welt zu interagieren. Bei diesen Komponenten kann es sich um Sensoren handeln, die einen Aspekt der realen Welt in Strom umwandeln, damit das Board ihn wahrnehmen kann, oder um Aktoren, die Strom vom Board erhalten und ihn in etwas umwandeln, das die Welt verändert. Beispiele für Sensoren sind Schalter, Beschleunigungsmesser und Ultraschall-Abstandssensoren. Aktoren sind Dinge wie Lichter und LEDs, Lautsprecher, Motoren und Displays.

Es gibt eine Vielzahl offizieller Boards, die du mit der Arduino-Software verwenden kannst, und eine große Auswahl an Arduino-kompatiblen Boards, die von Unternehmen und einzelnen Mitgliedern der Community hergestellt werden. Zusätzlich zu den auf dem Markt erhältlichen Boards findest du sogar Arduino-kompatible Controller in allen möglichen Produkten, von 3D-Druckern bis hin zu Robotern. Einige dieser Arduino-kompatiblen Boards und Produkte sind auch mit anderen Programmierumgebungen wie MicroPython oder CircuitPython kompatibel.

Die gängigsten Boards enthalten einen USB-Anschluss, der für die Stromversorgung und die Verbindung zum Hochladen deiner Software auf das Board verwendet wird. Abbildung 1-1 zeigt ein einfaches Board, mit dem die meisten Leute anfangen: das Arduino Uno. Es wird von einem 8-Bit-Prozessor angetrieben, dem ATmega328P, der über 2 Kilobyte SRAM (statischer Direktzugriffsspeicher, der zum Speichern von Programmvariablen verwendet wird) und 32 Kilobyte Flash-Speicher zum Speichern deiner Sketche verfügt und mit 16 MHz läuft. Ein zweiter Chip ist für die USB-Verbindung zuständig.

Hinweis

Trotz des Wortes "statisch" in seinem Namen ist statischer RAM eine Form von flüchtigem Speicher. Dies steht im Gegensatz zum dynamischen RAM (DRAM), der gelegentlich aufgefrischt werden muss, um die elektrische Ladung aufrechtzuerhalten. SRAM behält seinen Zustand so lange bei, wie die Stromversorgung aufrechterhalten wird, ohne dass zusätzliche Schaltkreise zur Auffrischung erforderlich sind.

Basisplatine: der Arduino Uno

Das Arduino Leonardo Board hat den gleichen Formfaktor (das Layout des Boards und seine Anschlusspins) wie das Uno, verwendet aber einen anderen Prozessor, den ATmega32U4, der deine Sketche ausführt und sich auch um die USB-Verbindung kümmert. Er ist etwas günstiger als der Uno und bietet außerdem einige interessante Funktionen, wie z. B. die Möglichkeit, verschiedene USB-Geräte wie Mäuse und Tastaturen zu emulieren. Die Arduino-kompatiblen Teensy- und Teensy++-Boards von PJRC(http://www.pjrc.com/teensy) sind ebenfalls in der Lage, USB-Geräte zu emulieren.

Ein weiteres Board mit einer ähnlichen Pinbelegung und einem noch schnelleren Prozessor ist der Arduino Zero. Im Gegensatz zum Arduino Uno und Leonardo verträgt es keine Eingangsspannungen von mehr als 3,3 Volt. Der Arduino Zero hat einen 32-Bit-Prozessor, der mit 48 MHz läuft, und verfügt über 32 Kilobyte RAM und 256 Kilobyte Flash-Speicherung. Der Metro M0 Express von Adafruit und das RedBoard Turbo von SparkFun haben den gleichen Formfaktor wie der Arduino Zero und sind ebenfalls mit mehreren Umgebungen kompatibel, darunter die Arduino IDE und CircuitPython.

Wenn du ein Board zum Lernen suchst, auf dem die meisten Sketche in diesem Buch laufen, ist der Uno eine gute Wahl. Wenn du mehr Leistung als der Uno haben willst, aber trotzdem den Uno-Formfaktor nutzen möchtest, solltest du den Zero oder ein ähnliches Board wie den Metro M0 Express oder den RedBoard Turbo in Betracht ziehen. Die MKR-Boards und Nano 33 bieten ebenfalls eine hervorragende Leistung, allerdings in einem kleineren Formfaktor als der Uno.

Vorsicht ist bei einigen 3,3-Volt-Boards geboten

Viele der neueren Boards arbeiten mit 3,3 Volt und nicht mit den 5 Volt, die ältere Boards wie der Uno verwenden. Einige dieser Boards können dauerhaft beschädigt werden, wenn ein Eingangs- oder Ausgangspin auch nur für den Bruchteil einer Sekunde 5 Volt erhält. Überprüfe daher in der Dokumentation deines Boards, ob es 5 Volt toleriert, bevor du etwas verdrahtest, wenn die Gefahr besteht, dass die Pin-Pegel höher als 3,3 Volt sind. Die meisten 3,3-Volt-Boards werden mit einem 5-Volt-Netzteil (z. B. über den USB-Anschluss) versorgt, das jedoch von einem Spannungsregler in 3,3 Volt umgewandelt wird, bevor es die 3,3-Volt-Elektronik des Boards erreicht. Das bedeutet, dass es nicht ungewöhnlich ist, einen 5-Volt-Stromversorgungspin auf einem Board zu sehen, dessen Eingangs- und Ausgangspins nicht 5-Volt-tolerant sind.

Arduino-Boards gibt es in anderen Formfaktoren,. Das bedeutet, dass die Pins auf diesen Boards ein anderes Layout haben und nicht mit Shields kompatibel sind, die für den Uno entwickelt wurden. Das MKR1010 ist ein Arduino-Board, das einen viel kleineren Formfaktor hat. Seine Pins sind für 3,3V E/A ausgelegt (es ist nicht 5V-tolerant) und wie der Zero verwendet es einen ARM-Chip. Das MKR1010 verfügt jedoch auch über WiFi und eine Schaltung zum Betreiben und Aufladen einer LIPO-Batterie. Obwohl die MKR-Familie nicht mit den für den Uno entwickelten Shields kompatibel ist, bietet Arduino eine Auswahl an Zusatzplatinen für den MKR-Formfaktor an, die sogenannten Carrier.

Es gibt Boards, die so klein wie eine Briefmarke sind, wie das Adafruit Trinket M0; größere Boards mit mehr Anschlussmöglichkeiten und leistungsfähigeren Prozessoren, wie das Arduino Mega und das Arduino Due; und Boards, die auf bestimmte Anwendungen zugeschnitten sind, wie das Arduino LilyPad für Wearable-Anwendungen, das Arduino Nano 33 IoT für drahtlose Projekte und das Arduino Nano Every für Embedded-Anwendungen (eigenständige Projekte, die oft batteriebetrieben sind).

Es sind auch andere Arduino-kompatible Boards von Drittanbietern erhältlich, darunter die folgenden:

Bare Bones Board (BBB)
Kostengünstige Bare Bones Boards sind mit oder ohne USB-Fähigkeit von Modern Device und von Educato in einer Shield-kompatiblen Version erhältlich.
Adafruit Industries
Adafruit hat eine große Sammlung von Arduino- und Arduino-kompatiblen Boards und Zubehör (Module und Komponenten).
SparkFun
SparkFun hat jede Menge Arduino und Arduino-kompatibles Zubehör.
Seeed Studio
Seeed Studio vertreibt Arduino- und Arduino-kompatible Boards sowie viel Zubehör. Außerdem bietet es ein flexibles Erweiterungssystem für Arduino und andere Embedded Boards namens Grove an, das ein modulares Steckersystem für Sensoren und Aktoren verwendet .
Teensy und Teensy++
Diese winzigen aber extrem vielseitigen Bretter sind bei PJRC erhältlich.

Wikipedia hat eine ausführliche Liste von Arduino-kompatiblen Boards. Eine Übersicht über die Arduino-Boards findest du auch auf der Arduino-Website.

1.1 Installieren der integrierten Entwicklungsumgebung (IDE)

Problem

Du möchtest, die Arduino-Entwicklungsumgebung, auf deinem Computer installieren.

Lösung

Lade die Arduino-Software für Windows, MacOS oder Linux herunter. Hier findest du Hinweise zur Installation der Software auf diesen Plattformen:

Windows

Wenn du mit Windows 10 arbeitest, kannst du Arduino über den Microsoft Store installieren, ohne Administratorrechte zu benötigen. Für frühere Windows-Versionen brauchst du jedoch Admin-Rechte, um den Windows-Installer nach dem Download per Doppelklick zu starten. Alternativ kannst du die Windows-ZIP-Datei herunterladen und sie in ein beliebiges Verzeichnis entpacken, auf das du Schreibrechte hast.

Wenn du die Datei entpackst, wird ein Ordner mit dem Namen Arduino-<nn> erstellt (wobei <nn> die Versionsnummer der Arduino-Version ist, die du heruntergeladen hast). Das Verzeichnis enthält die ausführbare Datei (namens Arduino.exe) sowie weitere Dateien und Ordner.

Hinweis

Wenn du Arduino zum ersten Mal unter Windows ausführst, erscheint möglicherweise ein Dialog mit der Meldung "Die Windows Defender Firewall hat einige Funktionen dieser Anwendung blockiert" und gibt javaw.exe als Quelle für die Warnung an. Die Arduino IDE ist eine Java-basierte Anwendung,. Deshalb kommt die Warnung vom Java-Programm und nicht von der Arduino.exe. Diese wird von Boards verwendet, die das Hochladen von Skizzen über ein lokales Netzwerk unterstützen. Wenn du vorhast, ein solches Board zu verwenden, solltest du diesen Dialog nutzen, um javaw.exe den Zugriff auf das Netzwerk zu erlauben.

Wenn du das Board einsteckst, wird der installierte Treiber automatisch mit dem Board verknüpft (das kann ein wenig dauern). Wenn dieser Vorgang fehlschlägt oder du Arduino mit der ZIP-Datei installiert hast, gehe auf die Seite Arduino Guide, klicke auf den Link für dein Board in der Liste und folge den Anweisungen.

Wenn du eine ältere Karte verwendest (jede Karte, die FTDI-Treiber verwendet) und online bist, kannst du Windows nach den Treibern suchen lassen und sie werden automatisch installiert. Wenn du keinen Internetzugang hast oder mit Windows XP arbeitest, solltest du den Speicherort der Treiber angeben. Verwende die Dateiauswahl, um zum Verzeichnis für die USB-Treiber vonFTDI zu navigieren, das sich in dem Verzeichnis befindet, in das du die Arduino-Dateien entpackt hast. Wenn dieser Treiber installiert ist, erscheint der Assistent für das Suchen neuer Hardware erneut und meldet, dass ein neuer serieller Anschluss gefunden wurde. Befolge den gleichen Prozess noch einmal.

Tipp

Möglicherweise musst du die Abfolge der Schritte zur Installation der Treiber zweimal durchlaufen, um sicherzustellen, dass die Software mit dem Board kommunizieren kann.

macOS

Der Arduino-Download für den Mac ist eine ZIP-Datei. Wenn die ZIP-Datei nicht automatisch entpackt wird, nachdem du sie heruntergeladen hast, suche den Download und doppelklicke darauf, um die Anwendung zu entpacken. Verschiebe die Anwendung an einen geeigneten Ort - der Ordner " Programme" ist ein sinnvoller Ort. Doppelklicke auf die Anwendung. Es erscheint der Startbildschirm , gefolgt vom Hauptfenster des Programms.

Aktuelle Arduino-Boards wie der Uno können ohne zusätzliche Treiber verwendet werden. Wenn du das Board zum ersten Mal einsteckst, kann es sein, dass eine Meldung erscheint, dass ein neuer Netzwerkanschluss gefunden wurde; diese kannst du ignorieren. Wenn du ältere Boards verwendest, die FTDI-Treiber benötigen, kannst du diese unter von FTDI beziehen.

Linux

Linux-Versionen sind zunehmend über den Paketmanager deiner Distribution erhältlich, aber diese Versionen sind oft nicht die aktuellste Version. Deshalb ist es am besten, die Version von http://arduino.cc/download herunterzuladen . Sie ist für 32 oder 64 Bit verfügbar und bietet eine ARM-Version, die auf dem Raspberry Pi und anderen Linux-ARM-Boards verwendet werden kann. Die meisten Distributionen verwenden einen Standardtreiber, der bereits installiert ist, und bieten normalerweise auch FTDI-Unterstützung. Auf dieser Arduino-Linux-Seite findest du Anweisungen zur Installation von Arduino unter Linux. Du musst diese Anweisungen befolgen, um das Installationsskript auszuführen, und du musst dies eventuell tun, damit dein Benutzerkonto auf die serielle Schnittstelle zugreifen kann.

Bei Arduino-kompatiblen Boards, die nicht von Arduino hergestellt wurden, musst du eventuell die Support-Dateien mit dem Boards Manager installieren (siehe Rezept 1.7). Du solltest auch in der Dokumentation des jeweiligen Boards nachsehen, ob zusätzliche Schritte erforderlich sind.

Nachdem du Arduino installiert hast, doppelklicke auf das Symbol und der Startbildschirm sollte erscheinen (siehe Abbildung 1-2).

Arduino-Startbildschirm (Arduino 1.8.9 unter Windows 10)

Auf den Startbildschirm folgt das Hauptfenster des Programms (siehe Abbildung 1-3). Sei geduldig, denn es kann einige Zeit dauern, bis die Software geladen ist. Das Arduino-Symbol findest du im Startmenü (Windows), im Ordner " Programme" (macOS) oder möglicherweise auf dem Desktop. Unter Linux musst du das Arduino-Programm möglicherweise über die Terminal-Shell ausführen.

IDE-Hauptfenster (Arduino 1.8.9 auf einem Mac)

Diskussion

Wenn der Start der Software fehlschlägt, findest du im Abschnitt zur Fehlerbehebung auf der Arduino-Website Hilfe bei der Lösung von Installationsproblemen.

Siehe auch

Online-Anleitungen für die ersten Schritte mit Arduino gibt es für Windows, für macOS und für Linux.

Die Arduino Pro IDE ist eine Entwicklungsumgebung für Arduino, die auf die Bedürfnisse von professionellen Nutzern ausgerichtet ist. Zum Zeitpunkt der Erstellung dieses Artikels befand sie sich noch in einem frühen Stadium. Siehe das Arduino Pro IDE GitHub Repo.

Das Arduino CLI ist ein Kommandozeilen-Tool zum Kompilieren und Hochladen von Sketches. Du kannst es auch anstelle des Library and Boards Manager verwenden. Siehe das Arduino CLI GitHub Repo.

Es gibt eine Online-Bearbeitungsumgebung namens Arduino Create. Um diese zu nutzen, musst du ein Konto erstellen und ein Plug-in herunterladen, mit dem die Website mit dem Board kommunizieren kann, um Code hochzuladen. Sie verfügt über eine Speicherung in der Cloud, in der deine Skizzen gespeichert werden, und bietet Möglichkeiten zum Teilen von Code. Als dieses Buch geschrieben wurde, war Arduino Create ein relativ neuer Dienst, der sich noch in der Entwicklung befand. Wenn du Arduino-Skizzen erstellen möchtest, ohne eine Entwicklungsumgebung auf deinem Computer installieren zu müssen, dann schau dir Arduino Create an.

Wenn du ein Chromebook verwendest, musst du für die Chrome-App von Arduino Create ein monatliches Abonnement von 1 US-Dollar abschließen. Es gibt eine zeitlich begrenzte Testversion, damit du sie ausprobieren kannst. Es gibt noch eine weitere Alternative zum Kompilieren und Hochladen von Arduino-Code von einem Chromebook aus: Codebender ist eine webbasierte IDE wie Arduino Create, unterstützt aber auch eine Reihe von Arduino-kompatiblen Boards anderer Hersteller. Es gibt auch preisgünstige Angebote für Klassenräume und Schulen. Siehe diese Codebender-Seite.

1.2 Einrichten des Arduino-Boards

Problem

Du willst ein neues Board einschalten und überprüfen, ob es funktioniert.

Lösung

Verbinde das Board mit einem USB-Anschluss deines Computers und überprüfe, ob die LED-Stromanzeige auf dem Board leuchtet. Die meisten Arduino-Boards haben eine LED-Betriebsanzeige, die immer dann aufleuchtet, wenn das Board mit Strom versorgt wird.

Die Onboard-LED (in Abbildung 1-4 beschriftet) sollte beim Einschalten des Boards blinken (auf den meisten Boards ist ab Werk die Software vorinstalliert, um die LED blinken zu lassen und so zu überprüfen, ob das Board funktioniert).

Grundlegendes Arduino Board, der Uno Rev3
Hinweis

Die aktuellen Boards im Arduino Uno-Formfaktor haben einige Pins, die auf älteren Boards nicht vorhanden waren, und es kann sein, dass du auf einige ältere Arduino Shields triffst, die diese Pins nicht haben. Glücklicherweise hat dies in der Regel keine Auswirkungen auf die Verwendung älterer Shields; die meisten funktionieren mit den neuen Boards genauso gut wie mit früheren Boards (aber das kann sich ändern).

Die neuen Anschlüsse bieten einen Pin (IOREF) für Shields, um die analoge Referenzspannung zu erkennen (damit analoge Eingangswerte mit der Versorgungsspannung korreliert werden können), sowie SCL- und SDA-Pins, um eine einheitliche Pin-Position für I2C-Geräte zu ermöglichen. Die Position der I2C-Pins war auf einigen früheren Boards wie dem Mega aufgrund unterschiedlicher Chipkonfigurationen unterschiedlich, und in einigen Fällen mussten bestimmte Shields mit Jumper-Drähten versehen werden, um die I2C-Pins des Shields mit denen des Mega zu verbinden. Shields, die für das neue Layout entwickelt wurden, sollten auf jedem Board mit den neuen Pinpositionen funktionieren. Ein zusätzlicher Pin (neben dem IOREF-Pin) ist im Moment noch ungenutzt, ermöglicht es aber, in Zukunft neue Funktionen zu implementieren, ohne die Pinbelegung erneut ändern zu müssen.

Diskussion

Wenn die Power-LED nicht leuchtet, wenn das Board mit deinem Computer verbunden ist, wird das Board wahrscheinlich nicht mit Strom versorgt (versuche eine andere USB-Buchse oder ein anderes Kabel).

Die blinkende LED wird durch den Code auf dem Board gesteuert (neue Boards sind auf mit dem Blink-Beispielsketch vorinstalliert). Wenn die Onboard-LED blinkt, läuft der Sketch korrekt, was bedeutet, dass der Chip auf der Platine funktioniert. Wenn die Power-LED leuchtet, aber die Onboard-LED (normalerweise mit L beschriftet) nicht blinkt, könnte es sein, dass der Werkscode nicht auf dem Chip ist; folge den Anweisungen in Rezept 1.3, um den Blink-Sketch auf das Board zu laden und zu überprüfen, ob das Board funktioniert. Wenn du keine Standardplatine verwendest, hat sie möglicherweise keine Onboard-LED, also überprüfe die Dokumentation für deine Platine.

Die Boards der Leonardo und Zero-Klasse (Arduino Zero, Adafruit Metro M0, SparkFun RedBoard Turbo) haben die gleiche Grundfläche wie der Uno (die Header befinden sich an der gleichen Position, so dass Shields angebracht werden können). In anderen Punkten unterscheiden sie sich deutlich. Der Leonardo hat einen 8-Bit-Chip wie der Uno, aber da er keinen separaten Chip für die USB-Kommunikation hat, akzeptiert der Leonardo nur Programm-Uploads unmittelbar nach einem Reset des Boards. Du wirst sehen, dass die LED des Leonardo sanft pulsiert, während er auf einen Upload wartet. Der Leonardo ist 5V-tolerant. Die Zero hat einen 32-Bit-ARM-Chip mit mehr Speicher zum Speichern und Ausführen deines Programms. Außerdem gibt es einen Pin, der einen Digital-Analog-Wandler (DAC) bereitstellt, d.h. du kannst eine variable analoge Spannung abgreifen. Damit kannst du Audiosignale in viel besserer Qualität als mit einem Uno erzeugen. Das Zero ist nicht 5V-tolerant, ebenso wenig wie die ähnlichen Boards von Adafruit (Metro M0 Express) oder SparkFun (RedBoard Turbo).

Das MKR1010 verwendet denselben Chip wie das Zero (und ist wie das Zero nicht 5V-tolerant), hat aber einen kleineren Formfaktor. Außerdem verfügt er über WiFi, sodass er sich über ein WiFi-Netzwerk mit dem Internet verbinden kann. Der MKR-Formfaktor unterstützt keine Shields, die für das Uno-Pin-Layout ausgelegt sind.

Alle 32-Bit-Boards haben mehr Pins, die Interrupts unterstützen, als die meisten 8-Bit-Boards, was für Anwendungen nützlich ist, die schnell Signaländerungen erkennen müssen (siehe Rezept 18.2). Die einzige 8-Bit-Ausnahme ist das Arduino Uno WiFi Rev2,, das Interrupts an jedem seiner digitalen Pins unterstützt.

Siehe auch

Online-Anleitungen für die ersten Schritte mit Arduino gibt es für Windows, für macOS und für Linux. Im Arduino Guide findest du board-spezifische Anleitungen.

Eine Anleitung zur Fehlersuche findest du auf der Arduino-Website.

1.3 Verwendung der integrierten Entwicklungsumgebung zur Vorbereitung eines Arduino-Sketches

Problem

Du solltest dich mit dem Kompilierungsprozess von Arduino vertraut machen und sowohl die Status- als auch die Fehlermeldungen verstehen, die er erzeugen kann.

Lösung

Der Quellcode für Arduino wird Sketch genannt. Der Prozess, bei dem ein Sketch in eine Form umgewandelt wird, die auf dem Board funktioniert, heißt Kompilierung. Mit der Arduino-IDE kannst du Sketches erstellen, öffnen und ändern, die festlegen, was das Board tun soll. Du kannst diese Aktionen mit den Schaltflächen oben in der IDE durchführen (siehe Abbildung 1-6) oder du kannst die Menüs oder Tastenkombinationen verwenden (siehe Abbildung 1-5).

Im Skizzeneditor kannst du den Code für eine Skizze anzeigen und bearbeiten. Er unterstützt gängige Textbearbeitungskürzel wie Strg-F (⌘+F auf dem Mac) zum Suchen, Strg-Z (⌘+Z auf dem Mac) zum Rückgängigmachen, Strg-C (⌘+C auf dem Mac) zum Kopieren von markiertem Text und Strg-V (⌘+V auf dem Mac) zum Einfügen von markiertem Text.

Abbildung 1-5 zeigt, wie du den Blink-Sketch lädst (der Sketch, der auf einem neuen Arduino-Board vorinstalliert ist).

IDE-Menü (Auswahl des Blink-Beispielsketches) unter Windows 10

Nachdem du die IDE gestartet hast, gehst du zum Menü Datei→Beispieleund wählst 01.Basics→Blink, wie in Abbildung 1-5 gezeigt. Der Code für das Blinken der eingebauten LED wird im Sketch Editor-Fenster angezeigt (siehe Abbildung 1-6).

Bevor du den Code an das Board senden kannst, muss er in Anweisungen umgewandelt werden, die vom Arduino-Controller-Chip gelesen und ausgeführt werden können; dies wird Kompilieren genannt. Klicke dazu auf die Schaltfläche Verifizieren/Kompilieren (die Schaltfläche oben links mit einem Häkchen) oder wähle Sketch→Verifizieren/Kompilieren (Strg-R; ⌘+R auf einem Mac).

Du solltest die Meldung "Skizze kompilieren..." und einen Fortschrittsbalken im Nachrichtenbereich unter dem Textbearbeitungsfenster sehen. Nach ein oder zwei Sekunden erscheint die Meldung "Fertig kompiliert". Der schwarze Konsolenbereich enthält die folgende zusätzliche Meldung:

Sketch uses 930 bytes (2%) of program storage space. Maximum is 32256 bytes.
Global variables use 9 bytes (0%) of dynamic memory, leaving 2039 bytes for
local variables. Maximum is 2048 bytes.

Die genaue Meldung kann sich je nach Board und Arduino-Version unterscheiden; sie gibt die Größe des Sketches und die maximale Größe an, die dein Board akzeptieren kann.

Arduino IDE auf macOS

Diskussion

Die IDE verwendet hinter den Kulissen eine Reihe von Befehlszeilen-Tools, um einen Sketch zu kompilieren. Weitere Informationen dazu findest du in Rezept 17.1.

Die abschließende Meldung, die dir die Größe des Sketches mitteilt, gibt an, wie viel Programmspeicher benötigt wird, um die Regleranweisungen auf dem Board zu speichern. Wenn die Größe des kompilierten Sketches größer ist als der verfügbare Speicher auf dem Board, wird die folgende Fehlermeldung angezeigt:

Sketch too big; see
http://www.arduino.cc/en/Guide/Troubleshooting#size for tips on reducing it.

In diesem Fall musst du deinen Sketch verkleinern, um ihn auf dem Board unterbringen zu können, oder ein Board mit größerer Flash-Speicherkapazität kaufen. Wenn deine globalen Variablen zu viel Speicherplatz beanspruchen, wird stattdessen eine andere Fehlermeldung angezeigt:

Not enough memory; see http://www.arduino.cc/en/Guide/Troubleshooting#size
for tips on reducing your footprint.

In diesem Fall musst du deinen Code durchgehen und die Menge des Speichers, die du globalen Variablen zuweist, reduzieren oder ein Board mit einer höheren SRAM (dynamischer Speicher) Kapazität kaufen.

Tipp

Um zu verhindern, dass du versehentlich den Beispielcode überschreibst, erlaubt dir die Arduino IDE nicht, Änderungen an den eingebauten Beispielskizzen zu speichern. Du musst sie mit der Menüoption Datei→Speichernunter umbenennen. Sketche, die du selbst schreibst, kannst du mit der Schaltfläche Speichern speichern (siehe Rezept 1.5).

Wenn der Code Fehler enthält, gibt der Compiler eine oder mehrere Fehlermeldungen im Konsolenfenster aus. Diese Meldungen können helfen, den Fehler zu identifizieren - siehe Anhang D zu Softwarefehlern für Tipps zur Fehlerbehebung.

Der Compiler kann auch Warnungen erzeugen, wenn er feststellt, dass dein Sketch Besonderheiten aufweist, die Probleme verursachen könnten. Diese können sehr hilfreich sein, um Probleme zu vermeiden, die dich später in Schwierigkeiten bringen könnten. Du kannst deine Warnstufe konfigurieren, indem du File→Preferences(Windows oder Linux) oder Arduino→Preferences(macOS) öffnest und Compiler-Warnungen auf None, Default, More oder All setzt. Trotz des Namens ist Arduino standardmäßig auf Keine eingestellt. Wir empfehlen dir, die Einstellung auf Standard oder Mehr zu setzen.

Hinweis

Der auf das Board hochgeladene Code kann nicht auf deinen Computer zurückgeladen werden. Stelle sicher, dass du deinen Sketch-Code auf deinem Computer speicherst. Du kannst Änderungen, die du an den Beispieldateien vorgenommen hast, nicht speichern; du musst "Speichern unter" verwenden und der geänderten Datei einen anderen Namen geben.

Siehe auch

Rezept 1.5 zeigt eine Beispielskizze. In Anhang D findest du Tipps zur Behebung von Softwareproblemen.

1.5 Erstellen und Speichern einer Skizze

Problem

Du möchtest eine Skizze erstellen und sie auf deinem Computer speichern.

Lösung

Um ein Editorfenster für einen neuen Sketch zu öffnen, starte die IDE (siehe Rezept 1.3), gehe zum Menü Datei und wähle Neu. Lösche den Boilerplate-Code im Sketch-Editor-Fenster und füge an seiner Stelle den folgenden Code ein (er ähnelt dem Blink-Sketch, aber die Blinks dauern doppelt so lang):

void setup()
{
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop()
{
  digitalWrite(LED_BUILTIN, HIGH); // set the LED on
  delay(2000);                     // wait for two seconds
  digitalWrite(LED_BUILTIN, LOW);  // set the LED off
  delay(2000);                     // wait for two seconds
}

Kompiliere den Code, indem du auf die Schaltfläche Verifizieren/Kompilieren klickst (die Schaltfläche oben links mit einem Häkchen) oder wähle Sketch→Verifizieren/Kompilieren(siehe Rezept 1.3).

Lade den Code hoch, indem du auf die Schaltfläche Hochladen klickst oder Sketch→Uploadwählst (siehe Rezept 1.4). Nach dem Hochladen sollte die LED blinken, wobei jedes Blinken zwei Sekunden dauert.

Du kannst diese Skizze auf deinem Computer speichern, indem du auf die Schaltfläche Speichern klickst oder Datei→Speichernwählst. Du kannst eine Skizze unter einem neuen Namen speichern, indem du die Menüoption Speichern unter auswählst. Es öffnet sich ein Dialogfeld, in das du den Dateinamen eingeben kannst.

Diskussion

Wenn du eine Datei in der IDE speicherst, öffnet sich ein Standarddialogfeld des Betriebssystems. Es schlägt vor, dass du den Sketch in einem Ordner namens Arduino in deinem Ordner Eigene Dateien (oder deinem Ordner Dokumente auf einem Mac) speicherst. Du kannst den Standardnamen des Sketches durch einen aussagekräftigen Namen ersetzen, der den Zweck deines Sketches widerspiegelt. Klicke auf Speichern, um die Datei zu speichern.

Hinweis

Der Standardname ist das Wort Skizze, gefolgt von dem aktuellen Datum. Fortlaufende Buchstaben, die mit a beginnen, werden verwendet, um Skizzen zu unterscheiden, die am selben Tag erstellt wurden. Wenn du den Standardnamen durch einen aussagekräftigen Namen ersetzt, kannst du den Zweck einer Skizze leichter erkennen, wenn du sie später wieder aufrufst.

Wenn du Zeichen verwendest, die die IDE nicht zulässt (z. B. das Leerzeichen), ersetzt die IDE diese automatisch durch gültige Zeichen.

Arduino Sketches werden als reine Textdateien mit der Endung .ino gespeichert. Ältere Versionen der IDE verwendeten die Endung .pde, die auch von Processing verwendet wird. Sie werden automatisch in einem Ordner mit demselben Namen wie der Sketch gespeichert.

Du kannst deine Skizzen in einem beliebigen Ordner speichern, aber wenn du den Standardordner verwendest (den Arduino-Ordner in deinem Dokumente-Ordner; ~/Arduino unter Linux), erscheinen deine Skizzen im Skizzenbuch-Menü der Arduino-Software und sind leichter zu finden.

Wenn du eines der eingebauten Beispiele bearbeitet hast, kannst du die geänderte Datei nicht im Beispiele-Ordner speichern. Du wirst dann aufgefordert, sie in einem anderen Ordner zu speichern.

Nachdem du Änderungen vorgenommen hast, wird ein Dialogfeld angezeigt, in dem du gefragt wirst, ob du den Sketch speichern möchtest, wenn ein Sketch geschlossen wird. Das §-Symbol nach dem Namen der Skizze in der oberen Leiste des IDE-Fensters zeigt an, dass der Skizzencode Änderungen enthält, die noch nicht auf dem Computer gespeichert wurden. Dieses Symbol wird entfernt, wenn du die Skizze speicherst.

Wenn du eine Skizze entwickelst und veränderst, brauchst du eine Möglichkeit, um die Änderungen zu verfolgen. Am einfachsten geht das mit dem Versionskontrollsystem Git (Informationen zur Installation findest du auf dieser Atlassian Git Tutorial-Seite ). Der Zugriff auf Git erfolgt in der Regel über eine Befehlszeilenschnittstelle (es gibt auch grafische Clients). Der grundlegende Arbeitsablauf, um eine Skizze unter Versionskontrolle in Git zu stellen, ist folgender:

  • Finde heraus, in welchem Ordner sich deine Skizze befindet. Du findest ihn mit Sketch→Skizzenordneranzeigen. Dadurch wird der Skizzenordner im Dateimanager deines Computers geöffnet.

  • Öffne eine Eingabeaufforderung (unter Windows: Eingabeaufforderung; unter Linux oder macOS: Terminal). Verwende den Befehl cd, um in das Verzeichnis zu wechseln, in dem sich dein Sketch befindet. Wenn du zum Beispiel einen Sketch namens Blink im Standard-Sketch-Ordner gespeichert hast, kannst du unter macOS, Linux und Windows mit den folgenden Befehlen in dieses Verzeichnis wechseln:

    $ cd ~/Documents/Arduino/Blink
$ cd ~/Arduino/Blink
> cd %USERPROFILE%\Documents\Arduino\Blink

  • Initialisiere das Git-Repository mit dem Befehl git init.

  • Füge die Sketch-Datei mit git add Blink.ino zu Git hinzu (ersetze Blink.ino durch den Namen deines Sketches). Wenn du weitere Dateien zu deinem Skizzenordner hinzufügst, musst du sie mit dem git add filename Befehl hinzufügen.

  • Nachdem du wesentliche Änderungen vorgenommen hast, tippe git commit -a -m "your comment here". Ersetze "dein Kommentar hier" durch etwas, das die von dir vorgenommene Änderung beschreibt.

Nachdem du eine Änderung an Git übergeben hast, kannst du unter git log einen Überblick über deine Änderungen erhalten. Jede dieser Änderungen wird mit einem Commit-Hash versehen:

commit 87e962e54fe46d9e2a00575f7f0d1db6b900662a (HEAD -> master)
Author: Brian Jepson <bjepson@gmail.com>
Date:   Tue Jan 14 20:58:56 2020 -0500

    made massive improvements

commit 0ae1a1bcb0cd245ca9427352fc3298d6ccb91cef (HEAD -> master)
Author: Brian Jepson <bjepson@gmail.com>
Date:   Tue Jan 14 20:56:45 2020 -0500

    your comment here

Mit diesen Hashes kannst du mit älteren Versionen von Dateien arbeiten (du brauchst nicht den vollständigen Hash, sondern nur genug davon, um zwischen den Versionen zu unterscheiden). Du kannst eine alte Version wiederherstellen mit git checkout hash filenamewiederherstellen, wie in git checkout 0ae1 Blink.ino. Du kannst Versionen vergleichen mit git diff firsthash..secondhashvergleichen, wie in git diff 0ae1..7018. Unter https://git-scm.com/doc findest du die vollständige Dokumentation zu Git.

Häufiges Kompilieren, wenn du Code änderst oder hinzufügst, ist eine gute Methode, um nach Fehlern zu suchen. Es ist einfacher, Fehler zu finden und zu beheben, weil sie in der Regel mit dem verbunden sind, was du gerade geschrieben hast.

Hinweis

Sobald eine Skizze auf das Board hochgeladen wurde, gibt es keine Möglichkeit mehr, sie zurück auf deinen Computer zu laden. Achte darauf, dass du alle Änderungen an deinen Skizzen speicherst, die du beibehalten möchtest.

Wenn du versuchst, eine Skizzendatei zu speichern, die sich nicht in einem Ordner mit demselben Namen wie die Skizze befindet, teilt dir die IDE mit, dass diese nicht geöffnet werden kann und schlägt dir vor, auf OK zu klicken, um den Ordner für die Skizze mit demselben Namen zu erstellen.

Hinweis

Skizzen müssen in einem Ordner mit dem gleichen Namen wie die Skizze gespeichert werden. Die IDE erstellt den Ordner automatisch, wenn du eine neue Skizze speicherst.

Sketche, die mit älteren Versionen der Arduino-Software erstellt wurden, haben eine andere Dateierweiterung (.pde). Die IDE öffnet sie, und wenn du den Sketch speicherst, wird eine Datei mit der neuen Erweiterung (.ino) erstellt. Code, der für frühere Versionen der IDE geschrieben wurde, lässt sich möglicherweise nicht in Version 1.0 kompilieren. Die meisten Änderungen, um alten Code zum Laufen zu bringen, sind leicht durchzuführen.

1.6 Ein einfaches erstes Arduino-Projekt

Problem

Du möchtest mit einem Projekt beginnen, das einfach zu bauen ist und Spaß macht.

Lösung

Dieses Rezept gibt einen Vorgeschmack auf einige der Techniken, die in späteren Kapiteln ausführlich behandelt werden.

Der Sketch basiert auf dem LED-Blinkcode aus dem vorherigen Rezept, aber anstatt eine feste Verzögerung zu verwenden, wird die Rate durch einen lichtempfindlichen Sensor, den Fotowiderstand oder kurz LDR (siehe Rezept 6.3), bestimmt. Verdrahte den Fotowiderstand wie in Abbildung 1-7 gezeigt.

Arduino mit Fotoresistor

Wenn du mit dem Aufbau einer Schaltung anhand eines Schaltplans nicht vertraut bist, findest du in Anhang B eine Schritt-für-Schritt-Anleitung, wie du diese Schaltung auf einem Breadboard erstellen kannst.

Hinweis

Fotowiderstände enthalten eine Verbindung (Cadmiumsulfid), die ein gefährlicher Stoff ist. Du kannst einen Fototransistor verwenden, wenn du in einem Land lebst, in dem es schwierig ist, einen Fotowiderstand zu bekommen, oder wenn du einfach keinen Fotowiderstand verwenden möchtest. Ein Fototransistor hat eine lange und eine kurze Leitung, ähnlich wie eine LED. Du kannst ihn genau wie in der Abbildung gezeigt verdrahten, musst aber die lange Leitung mit 5 V und die kurze Leitung mit dem Widerstand und Pin 0 verbinden. Achte darauf, dass du einen Fototransistor wie den von Adafruit mit der Artikelnummer 2831 kaufst, der sichtbares Licht erkennen kann, damit du ihn mit einer gewöhnlichen Lichtquelle testen kannst.

Die folgende Skizze liest den Lichtpegel eines Fotowiderstands aus, der an den analogen Pin 0 angeschlossen ist. Der Lichtpegel, der auf den Fotowiderstand trifft, verändert die Blinkverzögerung der internen Onboard-LED:

/*
 * Blink with photoresistor sketch
 */
const int sensorPin = A0;         // connect sensor to analog input 0

void setup()
{
  pinMode(LED_BUILTIN, OUTPUT);  // enable output on the led pin
}

void loop()
{
  int delayval = analogRead(sensorPin); // read the analog input
  digitalWrite(LED_BUILTIN, HIGH);      // set the LED on
  delay(delayval);                      // delay is dependent on light level
  digitalWrite(LED_BUILTIN, LOW);       // set the LED off
  delay(delayval);
}

Der Code in diesem Rezept und im gesamten Buch verwendet den Ausdruck const int, um sinnvolle Namen (sensorPin) für Konstanten anstelle von Zahlen (0) zu vergeben. Mehr über die Verwendung von Konstanten erfährst du in Rezept 17.5.

Diskussion

Der Wert des in Abbildung 1-7 gezeigten Widerstands hängt von der Reichweite deines Fotowiderstands ab: Du brauchst einen Widerstand, der in etwa dem maximalen (dunklen) Widerstand deines Fotowiderstands entspricht (du kannst ihn herausfinden, indem du den Fotowiderstand abdeckst, während du seinen Widerstand mit einem Multimeter misst). Wenn dein Fotowiderstand also im Dunkeln 10 kOhm misst, nimm einen 10 k-Widerstand. Wenn du einen Fototransistor verwendest, reicht in der Regel ein Wert zwischen 1K und 10K aus. Der Befehl analogRead (siehe Kapitel 6) liefert einen Wert, der von etwa 200, wenn der Sensor dunkel ist, bis zu 800 oder so reicht, wenn er sehr hell ist (die Empfindlichkeit hängt von der Art des Fotowiderstands und des Widerstands ab und davon, ob du einen Fototransistor anstelle des Fotowiderstands verwendest). Der analoge Messwert bestimmt die Dauer der Ein- und Ausschaltzeiten der LED, sodass die Blinkverzögerung mit der Lichtintensität zunimmt.

Du kannst die Blinkrate mit der Arduino map Funktion wie folgt skalieren:

/*
 * Blink with photoresistor (scaled) sketch
 */
const int sensorPin = A0;    // connect sensor to analog input 0

// low and high values for the sensor readings; you may need to adjust these
const int low  = 200;
const int high = 800;

// The next two lines set the min and max delay between blinks.
const int minDuration = 100;  // minimum wait between blinks
const int maxDuration = 1000; // maximum wait between blinks

void setup()
{
  pinMode(LED_BUILTIN, OUTPUT);  // enable output on the LED pin
}

void loop()
{
  int delayval = analogRead(sensorPin);    // read the analog input

  // the next line scales the delay value between the min and max values
  delayval = map(delayval, low, high, minDuration, maxDuration);
  delayval = constrain(delayval, minDuration, maxDuration);

  digitalWrite(LED_BUILTIN, HIGH); // set the LED on
  delay(delayval);                 // delay is dependent on light level
  digitalWrite(LED_BUILTIN, LOW);  // set the LED off
  delay(delayval);
}
Hinweis

Wenn du beim Einstellen des Lichts keine Veränderung der Werte feststellst, musst du mit den Werten für low und high spielen. Wenn du einen Fototransistor verwendest und keine Veränderungen in der Blinkrate feststellst, versuche es mit einem Wert von 10 für low.

Rezept 5.7 enthält weitere Einzelheiten über die Verwendung der Funktion map zur Skalierung von Werten. Rezept 3.5 enthält Einzelheiten zur Verwendung der Funktion constrain , um sicherzustellen, dass die Werte einen bestimmten Bereich nicht überschreiten. Wenn dein Verzögerungswert aus irgendeinem Grund außerhalb des Bereichs zwischen low und high liegt, gibt map einen Wert zurück, der außerhalb des Bereichs zwischen minDuration und maxDuration liegt. Wenn du constrain nach map aufrufst, wie in der Skizze gezeigt, vermeidest du das Problem, dass die Werte außerhalb des Bereichs liegen.

Wenn du den Wert der Variable delayval auf deinem Computer sehen möchtest, kannst du ihn auf dem Arduino Serial Monitor ausgeben, wie im folgenden überarbeiteten Schleifencode gezeigt. Der Sketch zeigt den Wert der Verzögerung im Serial Monitor an. Du öffnest das Fenster Serial Monitor in der Arduino IDE, indem du auf das Symbol rechts in der oberen Leiste klickst (siehe Kapitel 4 für weitere Informationen zur Verwendung des Serial Monitors):

/*
 * Blink sketch with photoresistor (scaled with serial output)
 */
const int sensorPin = A0;    // connect sensor to analog input 0

// Low and high values for the sensor readings. You may need to adjust these.
const int low  = 200;
const int high = 800;

// the next two lines set the min and max delay between blinks
const int minDuration = 100;  // minimum wait between blinks
const int maxDuration = 1000; // maximum wait between blinks

void setup()
{
  pinMode(LED_BUILTIN, OUTPUT);  // enable output on the led pin
  Serial.begin(9600);            // initialize Serial
}

void loop()
{
  int delayval = analogRead(sensorPin);    // read the analog input
  // the next line scales the delay value between the min and max values
  delayval = map(delayval, low, high, minDuration, maxDuration);
  delayval = constrain(delayval, minDuration, maxDuration);

  Serial.println(delayval);        // print delay value to serial monitor
  digitalWrite(LED_BUILTIN, HIGH); // set the LED on
  delay(delayval);                 // delay is dependent on light level
  digitalWrite(LED_BUILTIN, LOW);  // set the LED off
  delay(delayval);
}

Du kannst den Sensor verwenden, um die Tonhöhe eines Geräusches zu kontrollieren, indem du einen kleinen Lautsprecher an den Pin anschließt, wie in Abbildung 1-8 gezeigt.

Anschlüsse für einen Lautsprecher mit der Fotowiderstandsschaltung

Du musst die An-/Ausschaltrate des Pins auf eine Frequenz im Audiospektrum erhöhen. Das kannst du, wie hier gezeigt, erreichen, indem du die Min- und Max-Dauer verringerst:

/*
 * Speaker sketch with photoresistor
 */
const int outputPin = 9;  // Speaker connected to digital pin 9
const int sensorPin = A0; // connect sensor to analog input 0

const int low  = 200;
const int high = 800;

const int minDuration = 1;  // 1 ms on, 1 ms off (500 Hz)
const int maxDuration = 10; // 10 ms on, 10 ms off (50 Hz)

void setup()
{
  pinMode(outputPin, OUTPUT); // enable output on the led pin
}

void loop()
{
  int sensorReading = analogRead(sensorPin); // read the analog input
  int delayval = map(sensorReading, low, high, minDuration, maxDuration);
  delayval = constrain(delayval, minDuration, maxDuration);

  digitalWrite(outputPin, HIGH); // set the pin on
  delay(delayval);               // delay is dependent on light level
  digitalWrite(outputPin, LOW);  // set the pin off
  delay(delayval);
}

Siehe auch

Eine ausführliche Diskussion über die Audioausgabe mit Arduino findest du in Kapitel 9.

1.7 Verwendung von Arduino mit Boards, die nicht in der Standarddistribution enthalten sind

Problem

Du möchtest ein Board wie das Arduino MKR 1010 verwenden, aber es erscheint nicht im Board-Menü.

Lösung

Um das MKR 1010 mit Arduino zu verwenden, musst du seine Daten zur Arduino-Software hinzufügen, die du bereits heruntergeladen hast. Gehe dazu auf Tools→Board→BoardsManager(Abbildung 1-9).

Boards Manager auswählen (hier die Linux-Version der Arduino IDE)

Wenn sich dieses Fenster öffnet, wird die Liste der online verfügbaren Boarddefinitionen überprüft, um sicherzustellen, dass du die neuesten Versionen hast.

Hinzufügen anderer Boards zum Menü Boards

Das hier beschriebene Verfahren gilt auch für andere Boards, die du dem Board-Menü hinzufügen möchtest. Schau in der Dokumentation deines Boards nach, wo die Definitionsdateien zu finden sind.

Das sich öffnende Fenster(Abbildung 1-10) zeigt dir die bereits installierten und die zum Download verfügbaren Boarddefinitionen an.

Der Manager der Boards

Um das MKR 1010 zu finden, kannst du in der Liste nach unten scrollen oder seinen Namen in das Filterfeld eingeben. Für das MKR 1010 musst du den Eintrag Arduino SAMD Boards in der Liste auswählen. Wenn du ihn ausgewählt hast, klicke auf Installieren und er wird heruntergeladen und zur Arduino IDE hinzugefügt. Dies kann einige Zeit dauern.

Danach kannst du weitere Boards hinzufügen oder auf Schließen klicken, um die Verwendung des Boards Managers zu beenden. Wenn du Tools→Boardöffnest, solltest du jetzt die Möglichkeit haben, das MKR 1010 auszuwählen, wie in Abbildung 1-11 gezeigt.

Das MKR 1010 ist nun installiert und kann mit der Arduino IDE programmiert werden

Diskussion

In den Dateien, die du dabei herunterlädst, wird beschrieben, wie du die Programmierkonzepte in Arduino, die mit bestimmten Bits der Hardware im Mikrocontroller-Chip des Boards verbunden sind, einem bestimmten Chip oder einer Chip-Familie zuordnen kannst.

Wenn du die Beschreibung für einen bestimmten Chip hinzugefügt hast, kannst du oft mit einer ganzen Familie von Boards arbeiten, die diesen Chip verwenden. Wenn du zum Beispiel die Unterstützung für das MKR 1010 Board hinzufügst, wird auch das Arduino Zero unterstützt, da beide Boards denselben Mikrocontroller-Chip verwenden.

Um die Unterstützung für die wachsende Zahl von Arduino- und Arduino-kompatiblen Boards zu erleichtern, hat die Arduino IDE in Version 1.6 einen Boards Manager hinzugefügt. Der Boards Manager wurde entwickelt, um das Hinzufügen und Entfernen von Board-Details in der Installation zu erleichtern. Außerdem kannst du damit die Board-Unterstützungsdateien aktualisieren, wenn neuere Versionen verfügbar sind, oder die Version auswählen, die du verwendest, wenn du eine bestimmte Version verwenden musst. Die Arduino-IDE enthält nicht mehr die Beschreibungsdateien für alle Arduino-Boards. Selbst wenn du die neueste IDE herunterlädst, kann es also sein, dass du die Beschreibungen für dein Board nicht bekommst.

Der Boards Manager ermöglicht es auch Drittanbietern, die Details ihrer Boards in das System einzutragen. Wenn die Beschreibungen ihrer Tafeln im richtigen Format online verfügbar sind, kannst du den Ort als einen der Orte hinzufügen, die der Boards Manager für die Erstellung der Liste verwendet. Das bedeutet, dass diese Dateien auch überprüft werden, wenn der Boards Manager seine Details aktualisiert. So wirst du über Aktualisierungen benachrichtigt und kannst den gleichen Mechanismus nutzen, um sie zu aktualisieren, sobald sie installiert sind. Dazu gehst du zu Arduino→Einstellungen und klickst auf das Symbol rechts neben dem Feld Zusätzliche Boards Manager-URLs. Daraufhin wird das Dialogfeld Zusätzliche Boards Manager-URLs angezeigt (siehe Abbildung 1-12).

Präferenzen, nachdem du auf das Symbol rechts neben dem Eintrag Zusätzliche Boards Manager URLs geklickt hast

Wenn die Ersteller des Boards eine URL zur Verfügung stellen, die du zu Arduino hinzufügen kannst, füge sie in das Dialogfeld "Zusätzliche URLs" ein (in einer separaten Zeile, falls es weitere Einträge gibt). Wenn es keine explizite URL gibt, klicke auf den Text unter dem Feld, um zu der Webseite zu gelangen, die eine Liste mit inoffiziellen URLs zur Beschreibung von Arduino-Boards führt.

Wenn du ein Teensy-Board verwenden möchtest, , musst du ein separates Installationsprogramm von der Teensy-Website herunterladen. Es ist wichtig, dass du ein Teensy-Installationsprogramm verwendest, das die IDE-Version unterstützt, die du verwendest. Eine kompatible Version wird normalerweise innerhalb von ein oder zwei Wochen nach einer neuen Arduino-Version veröffentlicht.

Siehe auch

Schnellstart-Anleitungen für verschiedene Arduino-Boards

1.8 Verwendung eines 32-Bit Arduinos (oder eines kompatiblen)

Problem

Du willst 32-Bit-Leistung im Uno-Formfaktor.

Lösung

Der Arduino Zero (Abbildung 1-13) hat die gleiche Pinbelegung wie der Uno, verfügt aber über viel mehr Speicher und einen schnelleren Prozessor. Wenn du Schwierigkeiten hast, einen Zero zu bekommen, sind der Metro M0 Express von Adafruit und das RedBoard Turbo von SparkFun kompatible Alternativen.

Das Arduino/Genuino Zero Board

Trotz der ähnlichen Anordnung der Pins gibt es eine Reihe von Unterschieden. Der Unterschied zwischen diesen Boards und dem Uno besteht darin, dass sie einen 32-Bit-ARM-Chip, den Microchip SAMD21, verwenden. Die folgende Skizze, die dem vorherigen Rezept ähnelt, zeigt einige wichtige Unterschiede zwischen den ARM-basierten Boards und dem Uno:

Hinweis

Wenn du keine Veränderung der Werte hörst, während du das Licht einstellst, musst du mit den Werten für low und high spielen. Wenn du einen Fototransistor verwendest und keine Veränderungen in der Blinzelrate wahrnimmst, versuche es mit einem Wert von 10 für low. Wenn dein Umgebungslicht von einer Leuchtstoffröhre oder LED stammt, kann es sein, dass du ein deutliches Flackern hörst, das auf das Flimmern solcher Lichtquellen zurückzuführen ist und optisch nicht wahrnehmbar ist.

/*
 * Zero wave sketch
 */
const int outputPin = A0; // headphones connected to analog 0
const int sensorPin = A1; // connect sensor to analog input 1

const int low  = 200;
const int high = 800;

const int sampleCount = 16;  // number of samples used to render one cycle

const int minDur = 1000000/(sampleCount*500); // period in uS for 500 Hz
const int maxDur = 1000000/(sampleCount*50);  // period for 50 Hz

// table of values for 16 samples of one sine wave cycle
static int sinewave[sampleCount] = {
  0x1FF,0x2B6,0x355,0x3C7,0x3FF,0x3C7,0x355,0x2B6,
  0x1FF,0x148,0x0A9,0x037,0x000,0x037,0x0A9,0x148
};

void setup()
{
  analogWriteResolution(10); // set the Arduino DAC resolution to maximum
}

void loop()
{
  int sensorReading = analogRead(sensorPin);    // read the analog input
  int duration = map(sensorReading, low, high, minDur, maxDur);
  duration = constrain(duration, minDur, maxDur);
  duration = constrain(duration, minDur, maxDur);

  for(int sample=0; sample < sampleCount; sample++) {
    analogWrite(outputPin, sinewave[sample]);
    delayMicroseconds(duration);
  }
}

Bevor du Sketche auf das Zero, das Adafruit Metro M0 oder M4 oder das SparkFun RedBoard laden kannst, öffne den Arduino Boards Manager und installiere das entsprechende Paket (siehe Rezept 1.7). Wenn du ein Adafruit- oder SparkFun-Board verwendest, musst du zuerst die URL des Boardmanagers zur Arduino IDE hinzufügen. Siehe Adafruit oder SparkFun für weitere Informationen. Nachdem du die Unterstützung für dein SAMD-Board installiert hast, konfigurierst du die Arduino-IDE über das Menü "Extras" so, dass sie das Board verwendet, und stellst den richtigen seriellen Anschluss für die Verbindung mit dem Board ein. Schließe einen Widerstand, ein Potentiometer und einen Fotowiderstand (auch bekannt als lichtabhängiger Widerstand) an, wie in Abbildung 1-14 gezeigt. Als Nächstes lädst du den Code mit der Arduino IDE hoch.

Anschlüsse für den Audioausgang mit der Fotowiderstandsschaltung für die Zero-Platte

Diese SAMD-basierten Boards sind nicht 5-Volt-tolerant

Du darfst nicht mehr als 3,3 Volt an ihre I/O-Pins anschließen, sonst kannst du die Platine beschädigen!

Diskussion

Auch wenn die Verdrahtung auf den ersten Blick ähnlich aussieht wie in Abbildung 1-8, werden für den Sensoreingang und den Audioausgang unterschiedliche Pins verwendet. Diese Boards haben einen Digital-Analog-Wandler (DAC), der realistischere Audiosignale erzeugen kann als der binäre Ausgang der normalen digitalen Pins. Der DAC ist jedoch nur am analogen Pin 0 verfügbar, so dass der Sensoreingang hier an den analogen Pin 1 angeschlossen ist.

Ein weiterer Unterschied, der aus der Abbildung vielleicht nicht ersichtlich ist, ist, dass diese Boards nur bis zu 7 mA an einem Pin treiben können, im Vergleich zu 40 mA beim Uno. Und weil die Spannung an den Pins von 0 bis 3,3 Volt reicht, verglichen mit dem 0- bis 5-Volt-Bereich des Uno, ist die maximale Leistung an einem Pin fast 10 Mal geringer als beim Uno. Aus diesem Grund sollten die Ausgangspins mit Kopfhörern oder einem Verstärkereingang verbunden werden, da sie keinen Lautsprecher direkt ansteuern können.

Die Skizze verwendet eine Lookup-Tabelle mit 16 Samples pro Sinuszyklus, aber diese Boards sind schnell genug, um viel höhere Auflösungen zu verarbeiten, und du kannst die Anzahl der Samples erhöhen, um die Reinheit des Signals zu verbessern.

Siehe auch

Arduino Zero Schnellstartanleitung

Mehr über Audio mit Arduino in Kapitel 9

Get Arduino Kochbuch, 3. Auflage now with the O’Reilly learning platform.

O’Reilly members experience books, live events, courses curated by job role, and more from O’Reilly and nearly 200 top publishers.

Start your free trial