ARDUINO-IDE

http://sites.prenninger.com/arduino-uno-r3/arduino-ide

http://www.linksammlung.info/

http://www.schaltungen.at/

                                                                                             Wels, am 2019-05-10

BITTE nützen Sie doch rechts OBEN das Suchfeld  [                                                              ] [ Diese Site durchsuchen]

DIN A3 oder DIN A4 quer ausdrucken
*******************************************************************************I**
DIN A4  ausdrucken   (Heftrand 15mm / 5mm)     siehe     http://sites.prenninger.com/drucker/sites-prenninger
********************************************************I*
~015_b_PrennIng-a_arduino.uno.r3-arduino.ide (xx Seiten)_1a.pdf

                ARDUINO-IDE

300_d_ARDUINO-X_ArduSmartPilot - Arduino-Programmierung (16 Seiten)_1a.pdf


Generell mag die ARDUINO-IDE keine Leerzeichen im Namen
und auch keine Sonderzeichen als auch keine Namen,
welche mit eine Zahl anfangen.

besser so
Adafruit_NeoPixel-master
\
Adafruit_NeoPixel.h

1.0   Die Arduino-IDE

Die Einzelheiten zur Installation der Arduino-IDE finden Sie im Internet

Die Arduino IDE ist sehr einfach. Sie wurde in Java geschrieben und enthält:
+    Einen rudimentären Texteditor zum Schreiben des Programms
+    Einige Shortcuts zum Konfigurieren der IDE und zum schnellen Auffinden von Beispielen und der Hilfe.
+    Funktionen zum Kompilieren des Programms und zum Hochladen in die CPU.
+    Ein einfaches Terminal zum Kommunizieren mit dem Board über die serielle Schnittstelle
Die sechs am häufigsten verwendeten Funktionen sind über Buttons unter dem Hauptmenü erreichbar.

Von links nach rechts stehen zur Verfügung:

Überprüfen, Upload, Neu, Öffnen, Speichern und Serial Monitor.


Ein Programm wird hier „Sketch" genannt und in C, C++ (oder Assembler, wenn nötig) geschrieben.
Mit Version 1.0.1 wurde die IDE um einige wichtige neuen Features erweitert.
Dazu gehört auch eine Menü-Übersetzung in mehr als 30 Sprachen. Standardmäßig ist die IDE auf Englisch eingestellt.
IDE-Version 1.0.5-r2 brachte nicht viele Neuigkeiten hinsichtlich der Gestaltung der Oberfläche.
Die wirkliche Neuigkeit dieser Version bestand in der Unterstützung des Arduino-Due-Boards,
das wegen seines 32bit-Mikrocontrollers spezielle Programmiertools braucht.

Die Arduino-IDE und ihre drei Hauptbereiche

1) menu
2) sketch
3) messages









1.1 Datei-Menü




Neu (Strg + N)
Öffnet ein neues Fenster für ein neues Programm (Sketch)
Öffnen... (Strg + 0)
Öffnet einen bestehenden Sketch. Standardmäßig wird das Arduino-Arbeitsverzeichnis geöffnet,
der standardmäßig vorgegebene Ort zum Speichern eines Sketchs.
Unter „Einstellungen" können Sie herausfinden, wo sich dieses Verzeichnis befindet.
Beispiele
Öffnet das Arduino-Beispieleverzeichnis
Schließen (Strg + W)
Beendet den aktiven Sketch
Speichern (Strg + S)
Speichert den aktiven Sketch
Speichern unter... (Strg + Shift + S)
Speichert den aktiven Sketch unter einem neuen Namen.
Upload (Strg + U)
Kompiliert den Sketch und sorgt anschließend für den Upload in den Mikrocontroller.
Dies geschieht über den seriellen Port, der zuvor im Menü Tools ---> Serial Port ausgewählt wurde.
Upload mit Programmer (Strg + Shift + U)
Kompiliert den Sketch und sorgt anschließend für den Upload in den Mikrocontroller.
Dies geschieht über den Programmer, der zuvor unter Tools —> Programmer ausgewählt wurde.
Papierformat (Strg + Shift + P)
Bereitet den Druck der aktiven Datei vor.
Drucken (Strg + P)
Druckt die aktive Datei.

Einstellungen (Strg + Komma)

Zeigt das Fenster mit den in der IDE möglichen, wichtigsten Einstellungen.
Weitere Einstellungen finden sich in der Datei preferences.txt, die außerhalb der IDE editiert werden kann.
Der Ort, an dem sich diese Datei befindet, ist unten im Fenster angegeben.
Leider lässt die Dokumentation dieser Optionen sehr viel zu wünschen übrig.

+    Sketchbook Speicherort  *.ino
Anzeige des Ortes, wo Ihre Sketche gespeichert werden.
Das sind die Sketche, auf die zugegriffen werden kann, wenn man auf Sketchbook im Datei-Menü klickt.
+    Editor language
Sprache innerhalb der IDE.
+    Editor Schriftgröße
Auswahl der beim Schreiben eines Sketch verwendete Schriftgröße.
+ Ausführliche Ausgaben während Kompilierung/Upload
Beim Anklicken der betreffenden Checkboxen ist die Ausgabe von Compiler- bzw. Programmer-Meldungen aktiviert.
+    Code nach Upload überprüfen
Hier wird bestätigt, dass das Programm ordnungsgemäß in den Mikrocontroller geladen wurde, aber der Programmiervorgang wird dadurch verzögert.
Ich würde daher die Aktivierung nur dann empfehlen, wenn Sie ein Kommunikationsproblem zwischen Arduino und Computer vermuten.
+    Externen Editor benutzen
Der Editor der IDE wird deaktiviert. Die IDE kompiliert die letzte Version des Sketchs, der von Ihnen geändert (und gespeichert!) wurde, in einem Editor außerhalb der IDE.
Dies erlaubt Ihnen, Ihr Programm in einem Editor Ihrer Wahl zu schreiben, der wahrscheinlich leistungsfähiger als der zu Arduino-IDE gehörende Editor sein wird.
Der Nachteil besteht jedoch darin, dass der Sketch in zwei Tools ( IDE und externer Editor) geöffnet werden muss und man beim Editieren und Compilieren eines Sketchs zwischen beiden wechseln muss.
+    Beim Starten nach Updates suchen
Die Arduino IDE nimmt Kontakt zur Arduino-Website auf, um zu prüfen, ob
eine neue Version verfügbar ist.
+    Sketchdateien beim Speichern zu neuen Dateiendungen aktualisieren
 IDE-Versionen vor 1.0 verwendeten die Extensions *.pde für Sketche. Seit Version 1.0 wurde diese Endung in *.ino geändert.
Beim Anklicken der betreffenden Checkbox werden alle alten Endungen automatisch in .ino geändert.
Vorsicht: Ältere Versionen der IDE erkennen die umbenannte Sketche nicht mehr.
+ *.ino-Dateien automatisch mit Arduino verknüpfen
Dies Option ermöglicht den Start von *.ino-Dateien beim Klick auf einen Sketch mit dieser Endung.

Beenden

Schlieft alle geöffneten Fenster der IDE. Beim Klick auf das kleine weiße Kreuz im roten Quadrat dagegen wird nur das betreffende Fenster geschlossen.



1.2 Bearbeiten-Menü
(Edit-Menü)






Rückgängig (Strg + Z)
Macht die letzte Editor-Aktion rückgängig.
Wiederholen (Strg+ Y)
Wiederholt die letzte Editor-Aktion.
Ausschneiden (Strg + X)
Schneidet den ausgewählten Text aus.
Kopieren (Strg + C)
Kopiert den ausgewählten Text (Copy & Paste).
Für Forum kopieren (Strg + Shift + C)
Kopiert den ausgewählten Text mit Farben und Layout zum veröffentlichen im Arduino-Forum
Als HTML kopieren (Strg + Alt + C)
Kopiert den ausgewählten Text mit Farben und Layout zum Einfügen in eine HTML-Seite.




Als HTML-File kopiert

<pre>

<span style="color: #7E7E7E;">//&nbsp;the&nbsp;loop&nbsp;routine&nbsp;runs&nbsp;over&nbsp;and&nbsp;over&nbsp;again&nbsp;forever:</span>
<span style="color: #CC6600;">void</span> <span style="color: #CC6600;"><b>loop</b></span>() {
&nbsp;&nbsp;<span style="color: #CC6600;">digitalWrite</span>(led, <span style="color: #006699;">HIGH</span>);   <span style="color: #7E7E7E;">// turn the LED on (HIGH is the voltage level)</span>
&nbsp;&nbsp;<span style="color: #CC6600;">delay</span>(1000);               <span style="color: #7E7E7E;">// wait for a second</span>
&nbsp;&nbsp;<span style="color: #CC6600;">digitalWrite</span>(led, <span style="color: #006699;">LOW</span>);    <span style="color: #7E7E7E;">// turn the LED off by making the voltage LOW</span>
&nbsp;&nbsp;<span style="color: #CC6600;">delay</span>(1000);               <span style="color: #7E7E7E;">// wait for a second</span>
}

</pre>




Einfügen (Strg + V)
Fügt den zuvor ausgeschnittenen oder kopierten Abschnitt ein.
Alles Auswählen (Strg + A)
Mit Strg+A markieren Sie den gesamten Text im Editor.
Kommentieren (Strg+Slash)
Der betreffende Hotkey funktioniert mit absoluter Sicherheit nur bei QUERTY-Tastaturen.
Bei allen anderen Keyboards schreiben Sie ganz einfach zwei Mal einen Slash direkt hintereinander vor die Zeile, die in einen Kommentar umgewandelt werden soll, zum Beispiel:
// Die Setup Routine läuft ein Mal beim Drücken von Reset.
Einrücken (Strg + ])
Rückt die Zeile um eine Einheit nach rechts ein. Auch hier gilt der Hotkey nur bei QUERTY-Keyboards.
Das Einrücken funktioniert auf allen Keyboards (wenn auch etwas umständlich), wenn Sie den Cursor vor die gewünschte Zeile stellen und mit der Maus auf den Menü-Eintrag „Einrücken" klicken.
Ausrücken (Strg + [ )
Einrückposition verringern (Cursor nach links rücken). Auch hier gelten die gleichen Einschränkungen hinsichtlich der Tastatur wie oben.
Suchen (Strg + F)
In einem Eingabefenster können Sie angeben, nach welchem String Sie suchen bzw. welchen String Sie ersetzen möchten.
Nächstes Finden (Strg + G)
Findet die nächste mit „Suchen" vorgegebene Stelle.
Vorheriges Finden (Strg + Shift + G, seit 1.0.1)
Findet die vorige mit „Suchen" vorgegebene Stelle.  Auswahl zum Suchen verwenden (Strg+ E, seit 1.0.1)
Hier kann der Suchbegriff für die oben bechriebenen Suchfunktionen durch das Markieren eines Textes und das anschließende Betätigen von Strg+E gewählt werden, ohne im Such-Eingabefenster eingetippt werden zu müssen




1.3 Sketch-Menü






Überprüfen / Kompilieren (Strg + R)
Compilieren des Sketchs, ohne ihn dabei in den Mikrocontroller zu laden.
Sketchordner anzeigen (Strg + K)
Öffnet das Verzeichnis des aktuellen Sketchs in einem separaten Fenster.
Datei hinzufügen
Fügt eine Datei zu einem Sketch hinzu. Die Dateien, die sich compilieren lassen (.ino, .pde, .h usw.) werden in das Verzeichnis des Sketchs kopiert und in neuen Tabs der IDE geöffnet.
Für andere Dateien wird ein Unterverzeichnis im Verzeichnis des Sketchs erzeugt (falls es noch nicht existiert) und die Datei wird dorthin kopiert. Solche Dateien werden nicht compiliert.
Library Importieren
(Version 1.0.x oder neuer) Fügen Sie die Zeile #include <xxx.h> am oberen Ende der Hauptdatei des Sketchs ein.
Das ist die Datei mit dem Namen des Sketchs. Der Ausdruck „xxx" ist der Name der zu importierenden Library.
Zu dieser Option gibt es ein Untermenü mit dem Namen „Add Library" zur Installation von Libraries, die von anderen Usern vorbereitet wurden.


Die Arduino-IDE ermöglicht kein Debugging. So ist es zum Beispiel nicht möglich, Breakpoints zum Anhalten des Sketchs zu setzen


1.4 Tools-Menü





Bei diesem Menü kann es bei manchen Rechnern unter Umständen eine Weile dauern, bis es sich öffnet.
Automatisch formatieren (Strg + T)
Einrücken des Zeilenanfangs. Erwarten Sie keine Wunder von dieser Option.
Eigentlich kann man sie vergessen, wenn man einmal gelernt hat, seine Sketches sorgfältig anzulegen.
Sketch archivieren
Erzeugt eine Archivdatei des aktiven Sketchs in einem durch Sketchbook Speicherort vorgegebenem Verzeichnis (siehe Einstellungen im Datei-Menü).
Das Archiv enthält alles, was im Verzeichnis des Sketchs enthalten ist.
Der Name des Archivs enthält das Datum und einen Buchstaben (a,b,c...) um die Versionsnum-mern innerhalb eines Tages zu unterscheiden.
Kodierung reparieren & neu laden
Enthält ein Sketch Zeichen, die nicht zum so genannten UTF-8 Zeichensatz gehören, so wird eine Fehlermeldung während der Compilierung ausgegeben.
Solche Zeichen können in einen Sketch gelangen, wenn eine Datei zum Beispiel außerhalb des Arduino IDE verändert und unter einem anderen Zeichensatz (zum Beispiel ANSI) gespeichert wurde.
Dieses Problem wird mit der hier beschriebenen Funktion behoben.
Serial Monitor (Strg+ Shift + M)
Öffnet das Terminal, um mit dem Board über den seriellen Port des Computers zu kommunizieren.
Board
Wählt das Arduino-Board aus, für das der vorliegende Sketch compiliert werden soll.
Je nach IDE-Version erscheinen die Boards, die mit verschiedenen Mikrocontrollern bestückt sein dürfen, nur unter ihrem generischen Namen und der Prozessor muss im Prozessor-Menü ausgewählt werden.
Die Boards des Mega 1280 und des Mega 2560 werden unter dem generischen Namen Mega aufgelistet.
Die Auswahl der MCU, Atmega1280 oder Atmega2560 erfolgt im nächsten Menü.
Die IDE-Versionen 1.0x listen alle bekannten Boards auf.
Prozessor (Version 1.5 oder neuer)
Auswahl der MCU des Arduino-Boards.
Diese Option ist nur aktiv, wenn der im vorhergehenden Menü ausgewählt Board-Typ mit verschiedenen Mikrocontrollern ausgestattet werden kann.
Serieller Port
Auswahl des seriellen Ports, der verwendet wird, um ein neues ausführbares Programm ins Board hochzuladen oder um mit dem Board zu kommunizieren.
Programmer
Auswahl des AVR-Programmers (falls vorhanden).
Bootloader installieren
Hochladen des Bootloaders in die MCU und Programmieren der MCU-Sicherungen (Fuses).
Dazu wird ein zuvor unter Tools —› Programmer ausgewählter AVR-Programmer benötigt.


1.5 Hilfe-Menü





Erste Schritte
Öffnet einen Quick-Start-Guide in einem separaten Fenster.
Environment
Öffnet eine Hilfe zur IDE in einem separaten Fenster.
Fehlersuche
Öffnet ein separates Fenster mit einer Liste häufig auftretender Probleme und den entsprechenden Lösungen
Referenz
Öffnet in einem separaten Fenster die so genannte Sprach-Referenz .(Language Reference) oder genauer:
Die Arduino Application Programming Interface Refe-rence (API).
In Referenz suchen (Strg + Shift + F)
Öffnet in einem separaten Fenster die Hilfe für die im aktuellen Sketch selektierte
Funktion.
Häufig gestellte Fragen
Öffnet in einem separaten Fenster eine Hilfeseite zu häufig gestellten Fragen (frequently asked questions).
Visit Arduino.cc
Öffnet die Arduino-Website im Internetbrowser (erfordert Internetzugang).
Über Arduino
Zeigt ein kleines Fenster mit der Versionsnummer und den Namen hinter Arduino.


1.6 Tabs

Das Tabs-Menü ist schwer zu finden





Wenn Sie einen Sketch öffnen, öffnet die IDE alle Dateien im Sketch-Verzeichnis, die (nach ihrer „Meinung") compiliert werden können, und erzeugt einen Tab für jede geöffnete Datei.
Das Tabs-Menü ist schwer zu finden.
Auf der rechten Seite der IDE, unter dem Menü verbirgt sich unter einem kleinen, nach unten zeigenden Pfeil (bzw. Dreieck) ein Menü mit Optionen, die sich auf Tabs beziehen und mit denen man unter anderem Tabs umbenennen, hinzufügen und löschen kann


2.0 Service
Ein Board mit einem AVR-Mikrocontroller darauf und einer in Java geschriebenen IDE zur Entwicklung von Anwendungsprogrammen wird nur zum Arduino, wenn bestimmten Anschlüssen der MCU auch bestimmte Funktionen zugeordnet sind:
Dafür sorgt ein Application Programming Interface (API), eine Software-Ebene, die Arbeiten auf niedriger Ebene für Sie erledigt.
Dank dieser API braucht sich der Programmierer nicht in die niederen Gefilde der manuellen MCU-Registerkonfigurierung zu begeben.

2.1 Pin-Nummern
Beim Arduino wurden die Namen der Anschlüsse vereinfacht. Die traditionelle Bezeichnung der I/O-Ports (Port A, Port B) wurde durch Pin-Nummern ersetzt.
Die Nummerierung ist einfach und logisch, wenn man bedenkt, dass das erste Arduino-Board mit einem ATmega8 ausgerüstet war.
Pin 2 war dort mit einer 0 versehen. Nicht logisch? Doch, da Pin 1 des ATmega8-Chips mit PC6 übereinstimmt, was nichts anderes als „1/0-Nummer von Port C" bedeutet.
Da dieser Pin jedoch auch der Reset-Eingang des Chips ist und weil die Entwickler es vorzogen, ihn mit einem Taster zu verbinden, ist PC6 nicht mehr länger freie.

Der zweite Pin des ICs, PDO oder I/O-Nummer 0 von Port D, ist verfügbar, und dort beginnt auch die Nummerierung.
Sie wird von dort weiter hoch gezählt und überspringt die Pins, bei denen es sich nicht um I/O-Anschlüsse handelt (Versorgung) oder die aus anderen Gründen nicht frei sind — so zum Beispiel PB6 und PB7, die für den Quarz reserviert sind.

Am Ende bleiben uns 20 digitale I/O-Anschlüsse (0 bis 19). I/O 14 bis I/O 19 sind mit dem A/D-Wandler der MCU verbunden.
Man hat sich hier dazu entschlossen, sie einer separaten Buchsenleiste zuzuordnen und sie „Analog Inputs" zu nennen (0 bis 5).
Ein UNO-Board hat zum Beispiel 14 digitale 1/0-Anschlüsse und 6 Analog-Eingänge. Die 14 digitalen I/O-Anschlüsse mit der Bezeichnung „Digital (PWM#)" befinden sich auf der einen Seite des Boards, und die Analogeingänge auf der gegenüberliegenden Seite.
Auf der Seite mit den Analogeingängen befindet sich eine weitere Buchsenleiste, die den Zugang zum Reset-Signal und der Versorgung ermöglicht.

1. Das ist nicht ganz korrekt, da es beim Programmieren der Sicherung (fuse) RSTDISBL immer noch möglich ist, diesen Port als digitalen (mit einem Taster verbundenen) Eingang zu verwenden. Dies verhindert jedoch den automatischen Reset, der benötigt wird, wenn man einen Sketch hoch lädt.


Warum steht bei den digitalen Anschlüssen zusätzlich der Begriff PWM #? Nun, die mit einem # (Lattenkreuz) und manchmal auch mit dem Tilde-Zeichen („—") beschrifteten Pins sind in der Lage, PWM-Signale (Pulsbreitenmodulation) aufzunehmen.
Sie sind markiert, weil sie im Arduino als analoge Ausgänge dienen. Ihre Anzahl hängt von der MCU ab.
Der ATmega8 hat nur drei davon (I/O 9 bis 11), der ATmega168 sowie der ATmega328p besitzen jeweils sechs solcher Anschlüsse (I/O 3, 5, 6 und 9 bis 11).

Vier Boards der Typs Mega sind mit MCUs ausgestattet, die mehr Pins besitzen als die Versionen ATmega8, ATmega168 und ATmega328.
Die Nummerierung der I/O-Pins ist unterschiedlich, da sie nach Funktionen gruppiert sind. Solch ein Board hat eine Buchsenleiste für die Versorgungsanschlüsse, die analogen und digitalen Anschlüsse sowie weitere Anschlussbereiche für die Datenübertragung und für PWM-Signale.
Die digitale Anschlussleiste besitzt sogar zwei Reihen.

Der Mega 2560 besitzt insgesamt 70 I/O-Anschlüsse, die sich über 32 digitale, 16 analoge, 15 PWM-Output und 10 Datenübertragungsanschlüsse verteilen.
Bei der Konfiguration der Pins, das heißt, bei der Beschränkung auf bestimmte Funktionen, kann Arduino deren Initialisierung übernehmen, was dem Anfänger eine Menge harte Arbeit erspart.
Die schränkt keineswegs, wie Sie vielleicht annehmen, die Flexibilität des Programmierers ein, da Arduino ihre Nummerierung nicht ausschließt.
Sie können selbst entscheiden, aber seien Sie nicht enttäuscht, wenn eine Arduino-Funktion nicht zum gewünschten Erfolg führt.

2.2 Der Boot-Loader
Genau genommen braucht man eigentlich gar keinen, aber ohne einen ist das Leben viel schwerer. Ich spreche über den Boot-Loader.
Jeder Arduino wurde vom Hersteller mit einem vorprogrammierten Exemplar ausgestattet, der den fertigen Sketch in die MCU lädt, ohne dass dafür ein spezieller Programmer notwendig wäre.
Ein gewöhnlicher, serieller Port reicht völlig aus — und die meisten Arduiono-Boards haben sogar einen USB-Anschluss.
Der Boot-Loader ist ein kleines Stückchen Software, das in einer Ecke des Programmspeichers untergebracht ist.
Das Programm wird stets ausgeführt, wenn die MCU nach einem externen Reset neu startet.
Dies kann durch den Resetknopf oder einem Aus- und Einschalten des Boards verursacht worden sein.

Der Boot-Loader scannt den seriellen Port der MCU für ein paar Sekunden, um festzustellen, ob ein Reprogramming-Request ankommt.
Ist dies nicht der Fall, dann wird die Hauptanwendung hochgeladen, wenn sie existiert.
Wird jedoch ein Reprogramming-Request empfangen, geht der Boat-Loader in den Programmiermodus über und die IDE kann den compilierten Sketch in den Speicher übergeben.

Der ganze Vorgang dauert etwa 10 Sekunden; die genaue Zeit hängt von der Größe der ausführbaren Datei ab.
Danach wird das Board neu gestartet. Da der Reset diesmal intern vom Boot-Loader selbst erzeugt wurde, wird er kein zweites Mal ausgeführt.
Stattdessen wird die Anwendung ausgeführt.

Boot-Loader unterscheiden sich hauptsächlich durch die Anzahl ihrer verfügbaren Optionen.
Doch mit den Optionen vergrößert sich auch der Umfang des Boot-Loaders.
Der maximal für einen Sketch zur Verfügung stehende Speicherplatz wird daher vom Umfang des Boot-Loaders bestimmt.
Für den Arduino gibt es Boot-Loader, die weniger als 512Bytes umfassen und in den meisten Fällen recht nützlich sind.

Der Arduino Boot-Loader verwendet nicht dasselbe Verbindungsprotokoll wie Wiring (STK500 versus STK500v2), wodurch keine Kompatibilität zwischen den beiden Plattformen herrscht.
Außerdem benötig der Boot-Loader von Wiring mehr Speicherplatz als derjenige des Arduino.

In seltenen Fällen kann der Boot-Loader durch einen schlecht kontrollierten Programmiervorgang zerstört werden.
Falls die geschieht, kann er von der IDE aus mittels eines AVR-Programmers wieder hergestellt werden.
Das ausführbare Programm kann von der IDE ebenfalls direkt in die MCU hochgeladen werden, ohne dass dazu ein Boot-Loader notwendig wäre
 - aber auch dazu braucht man einen AVR-Programmer.

Kurz und gut: Es ist besser, das Überschreiben des Boot-Loaders zu vermeiden.

Quelle: Clemens Valens Seite 50 bis 62
www.polyvalens.com





********************************************************I*
3 Entwicklungsumgebung und Programmiergrundlagen

Das Arduino-Board wird über eine spezielle, anfängerfreundliche Programmieroberfläche
(IDE = Integrated Design Environment = Integrierte Entwicklungsoberfläche)
programmiert.

Der große Vorteil im Vergleich zu einer klassischen „Tool-Chain" liegt darin, dass sie sehr intuitiv bedient werden kann.
Neben dem Arduino-Board selbst, ist diese spezielle Entwicklungsumgebung sicher einer der Hauptfaktoren für den großen Erfolg des Arduino-Konzeptes.

3.1 Die Integrierte Entwicklungsumgebung (IDE)
Die IDE erfordert keine langwierige Installation. Die ersten Programme können direkt nach dem Start der IDE auf den Mikrocontroller geladen werden.
Die aktuelle Version der IDE kann kostenlos unter
http://arduino.cc/en/Main/Software
heruntergeladen werden.

Es stehen verschiedene Versionen für die gebräuchlichsten Betriebssysteme (Windows, MAC OS und Linux) zur Verfügung.
Die vollständigen Programmpakete liegen als komprimierte ZIP-Archive vor und können in ein beliebiges Verzeichnis extrahiert werden.

Hinweis:
Die aktuelle Version der IDE ist Arduino 1.x. Die Vorgängerversionen wurden alle mit vierstelligen Ziffern (0001 bis 0023) bezeichnet.
Unglücklicherweise wurden beim Übergang zur Version 1.0 verschiedene Änderungen implementiert, welche die Kompatibilität mit älteren Sketchen und Bibliotheken deutlich einschränken.

Einige Programme in diesem Buch müssen daher mit der IDE-Version Arduino 0022 bearbeitet und geladen werden.

Zu erkennen sind diese Programme am Suffix .pde.
Programmnamen für die Version 1.0 enden auf .ino.

Diese Inkompatibilität hat unter Arduino-Anwendern für einigen Unmut gesorgt.
Man wird aber sicherlich einige Zeit mit dieser Übergangslösung leben müssen, zumindest solange, bis alle wichtigen Bibliotheken und Sketche auf die neue Version portiert sind.


Mein Arduino-Verzeichnis fehlt
Bild 3.1: Typisches Arduino-Verzeichnis


Das Verzeichnis enthält dann alle zur Programmierung des Freeduinos erforderlichen Komponenten.
Darüber hinaus sind unter „examples" noch verschiedene Beispielprogramme verfügbar.
Das Unterverzeichnis „libraries" enthält nützliche Programmbibliotheken, die unter anderem die Ansteuerung von

Schrittmotoren und Modellbau-Servos
LC-Displays
Externen Komponenten wie Taster, EEPROMs oder Sensoren
etc.


unterstützen.

Darüber hinaus können die Möglichkeiten des Arduinos noch mit zusätzlichen Spezialbibliotheken ergänzt werden.
Mehr zu diesem Thema findet sich in Kapitel 3.18.
Nach dem Entpacken des ZIP-Archivs steht im Verzeichnis
..\arduino-xxxx
das Startprogramm für die IDE: arduino.exe


Bild 3.2: Icon für den Start der Arduino-IDE
Nach erfolgreichem Start erscheint das folgende Informationsfenster mit den üblichen Angaben zu den Autoren des Programms:

fehlt
Bild 3.3: Info-Screen der Arduino 1.0 IDE

Anschließend wird die Oberfläche der IDE angezeigt:


fehlt
Bild 3.4: Leeres Sketch-Fenster


Wenn noch kein Programm geladen wurde oder der aktuell zu bearbeitende Sketch noch namenlos ist, wird ein Default-Name verwendet:
Sketch_MonatTag x
Dieser besteht aus einer Abkürzung für den aktuellen Monat und den aktuellen Tag sowie aus einem Buchstaben. Die Buchstaben a, b , c ... stehen dabei für den 1., 2., 3., ... neuen Sketch des aktuellen Tages.

Im nächsten Schritt muss nun die richtige Arduino-Version ausgewählt werden.




Bild 3.5: Auswahl der verwendeten Arduino-Version


Dann kann der Arduino über ein USB-Kabel mit dem PC verbunden werden.
Das Kabel sollte nicht zu lang sein. Kabellängen von mehr als 0,5 m können zu Übertragungsproblemen führen.

Es folgt die Auswahl des verwendeten virtuellen COM-Ports.
Hier ist die Port-Nummer auszuwählen, welche dem Arduino zugewiesen wurde.
Wenn nur ein Arduino verwendet wird, ist dies meist die letzte Position in der Liste.
Falls mehrere Controllerboards an einem PC verwendet werden, hilft hier oft nur das Durchtesten aller angebotenen COM-Nummern.




Bild 3.6: Auswahl des virtuellen COM-Ports



Unterhalb der Menüleiste am oberen Rand der IDE finden sich die folgenden Symbole:


Bild 3.7: Symbole der IDE


Sie haben im Einzelnen folgende Bedeutungen:
•    Verify:
Hier wird die Übersetzung des Programms gestartet. Entdeckt der Compiler Fehler, dann werden diese im schwarzen Info-Bereich am unteren Rand des Fensters ausgegeben.
    •    Upload:
Dieses Symbol führt nach der Kompilierung auch gleich das Laden des eben übersetzten Programms auf den Arduino aus.
      •    NEW:
Hier kann ein neuer Sketch gestartet werden.
         •    Open:
Dieses Symbol dient zum Öffnen von Sketchen im Arbeitsverzeichnis.
            •    Save:
Damit werden die aktuellen Sketche gespeichert.
                  •    Serial Monitor:
Mit diesem Symbol wird der serielle Monitor gestartet. Er dient zur Kommunikation zwischen dem Arduino und dem PC während der Ausführung eines Sketches.

Mit dem Symbol „OPEN" (Pfeil nach oben)  kann nun das erste Programm in die Programmieroberfläche geladen werden. Wir wählen hierfür das Programm

..\arduino-0022\examples\Digital\Blink\Blink.pde




fehlt
Bild 3.8;  Programmierumgebung mit geladenem Sketch „Blink"



Mit dem Button „UPLOAD"  (Pfeil nach trechts) wird das Programm in den Speicher des Mikrocontrollers übertragen.
Dabei blinken die Rx/Tx-LEDs in unregelmäßigen Abständen auf.
Dies ist ein nützlicher Hinweis auf den Datenverkehr auf der seriellen Schnittstelle.

In der IDE wird gleichzeitig die Nachricht
"Uploading to I/O Board"
eingeblendet.

Nach Abschluss der Übertragung erscheint die Meldung
"Done Uploading",

die beiden Rx/Tx-LEDs erlöschen und die LED 13 beginnt regelmäßig zu blinken.




Bild 3.9: LED 13 in Aktion

Nach Abschluss der Datenübertragung hat der Freeduino also selbstständig einen Reset durchgeführt und anschließend mit der Ausführung des Programms „Blink" begonnen.



3.3 Einfacher Einstieg — der Warnblinker
LEDs sind heutzutage in praktisch allen Lebensbereichen anzutreffen.
An Rundfunkgeräten oder Stereoanlagen dienen Sie zur Anzeige des Betriebszustandes.
Im Auto haben sie längst alle Warn-,,Lämpchen" für Ölstand oder Lichtmaschine ersetzt.
An Laptops oder Monitoren informieren sie ebenso über den Einschaltzustand wie an Tiefkühltruhen oder Spülmaschinen.
Kontinuierlich leuchtende LEDs erregen also keine besondere Aufmerksamkeit mehr.
Sie dienen daher meist zur Anzeige eines Normalzustandes.
Will man dagegen auf eine Fehlfunktion oder eine Sondersituation aufmerksam machen, so lässt man die LED meist blinken.
Ein typisches Beispiel hierfür ist die Kontroll-LED an einem Tiefkühlgerät.
Arbeitet die Truhe einwandfrei und hält in ihrem Inneren eine Temperatur im Bereich zweistelliger Minusgrade, so wird dies häufig durch eine konstant leuchtende LED angezeigt.
Ist die Kühlung dagegen ausgefallen, so beginnt die LED zu blinken und zieht damit die Aufmerksamkeit des Kühltruhenbesitzers auf sich.
Analog wird in Kraftfahrzeugen, Zügen oder Flugzeugen verfahren.
Blinkende Anzeigen deuten immer auf eine besondere, meist kritische Situation hin.
In unserem ersten Projekt wollen wir nun eine solche blinkende Anzeige aufbauen.

3.4 Die allgemeine Struktur eines Arduino-Programms
Für einen etwas detaillierteren Einstieg in die Programmierung des Arduinos soll nun das Programm zum Warnblinker näher analysiert werden.

Listing 3-1: BIink.pde
// Blink: Using LED "L" on ARDUINO UNO R3
int ledPin = 13; // Definitions
// Setup routine for digital port configuration

void setup()
// Port as output
pinMode(ledPin, OUTPUT);
}


// Main program

void loop()
{ digitalWrite(ledPin, HIGH); // LED on
delay(1000);    // wait 1 sec = 1000 ms
digitalWrite(ledPin, LOW);    // LED off
delay(1000);    // wait 1 sec = 1000 ms
}

In der ersten Programmzeile steht ein sogenannter Kommentar:

// Blink: Using LED "L" on ARDUINO UNO R3

Kommentarzeilen beginnen mit einem Doppel-Slash „//". Texte und Zeichen nach dem Doppel-Slash werden vom Compiler nicht beachtet.
Sie dienen nur der besseren Lesbarkeit von Programmen.
Trotzdem sollte man mit Kommentaren keineswegs sparsam umgehen.
Die Erfahrung lehrt, dass Programme ohne gute Kommentierung auch vom Programmersteller bereits nach kürzester Zeit nicht mehr ohne weiteres nachvollzogen werden können.
Kommentare sollen einerseits kurz gehalten werden, andererseits aber die Funktion eines Programmblocks gut verständlich wiedergeben.
Es muss durchaus nicht jede Programmzeile kommentiert werden, vielmehr ist es angebracht, bestimmte logische Einheiten eines Codes in Klartext zu erläutern.

Die erste aktive Zeile
int ledPin = 13;    // Definitions
legt Pin 13 als LED-Pin fest. Dieser Pin ist auf dem Arduino-Board über einen Vorwider-stand fest mit einer LED verbunden.
Pin 13 wird daher oft für Testausgaben genutzt.

Mit dieser Festlegung kann nun an allen Stellen im Sketch „ledPin" geschrieben werden, wenn der Port Nummer 13 gemeint ist.
Durch solche Definitionen wird die Programmierarbeit erheblich erleichtert. Insbesondere bei umfangreicheren Programmen ist es nicht mehr möglich, alle Portnummern und ihre jeweiligen Belegungen im Kopf zu behalten.
Bedeutungsvolle, sogenannte „sprechende" Bezeichnungen erleichtern daher die Programmierarbeit ganz erheblich.

Die nächste Anweisung
void setup()
ist eine Spezialität von Processing. Hier wird unter anderem festgelegt, welche Aufgaben die einzelnen Freeduino-Pins erfüllen sollen.

In unserem Fall wird der oben definierte ledPin als Ausgang genutzt:
pinMode(ledPin, OUTPUT);
Diese „setup"-Anweisung ist in einem Arduino-Sketch immer erforderlich, selbst wenn sie keine einzige Definition enthält.
Durch den Aufruf von setup werden nämlich auch interne Abläufe gestartet, welche die Arbeit mit dem Arduino erst ermöglichen.

Der Start des Hauptprogramms erfolgt mit
void loop()

In Mikrocontrollern läuft das Hauptprogramm nahezu ausschließlich in einer Endlos-schleife (englisch „loop") ab.
Da Controller nicht über eigene Betriebssysteme verfügen, darf die Hauptprogrammschleife nicht verlassen werden.
Würde das Ende eines Programms erreicht, bliebe der Controller einfach stehen und könnte erst nach der Durchführung eines Resets wieder die Arbeit aufnehmen.
Die Endlosschleife sorgt also dafür, dass der Prozessor solange arbeitet, bis die Betriebsspannung abgeschaltet wird.

Mit
digitalWrite(ledPin, HIGH);
wird der ledPin auf „HIGH"-Potential gesetzt.
Das bedeutet, dass die LED-Anode auf eine Spannung von 5 V gelegt wird. Dadurch beginnt die LED zu leuchten.

Die Leuchtdauer der LED wird mit
delay(1000);    // wait 1 sec = 1000 ms
festgelegt. Damit erhält der Prozessor den Auftrag 1000 ms = 1 sec zu warten.

Abschließend wird mit
digitalWrite(ledPin, LOW);    // LED off

die LED wieder ausgeschaltet und bei dunkler LED nochmals eine Pause von 1 s eingelegt.

Dann beginnt das gesamte Spiel wieder von vorne, da das Hauptprogramm ja in einer Endlosschleife abläuft.
Die LED blinkt damit nun mit einer Periodendauer von 2 s, dies entspricht einer Frequenz von f = 1/(2s) = 0,5 Hz.



Quelle:
BUCH: Arduino Schaltungsprojekte für Profis  Seite 21





DIN A4  ausdrucken
********************************************************I*
Impressum: Fritz Prenninger, Haidestr. 11A, A-4600 Wels, Ober-Österreich, mailto:schaltungen@schaltungen.at
ENDE







Untergeordnete Seiten (4): CodeReferenz Erste-Schritte H-Datei INO-Datei
Comments