ARDUINO IDE Installation

Grundlagen der Programmierung

Vorbemerkungen

Zum Thema ARDUINO und seine Programmierung gibt es zahlreiche Veröffentlichungen, seien es Bücher oder Artikel im Internet. Warum mache ich mir dann die Mühe hier abermals das Thema

ARDUINO, Befehle und Programmierung

aufzugreifen? Nun, gerade für Neueinsteiger – dazu zähle auch ich mich – empfinde ich diese Veröffentlichungen vielfach als sehr mangelhaft (man möge mir meinen Eindruck verzeihen!). Einige meiner Kritikpunkte möchte ich anmerken:

- meist ausgesprochen mangelhafter didaktischer Aufbau
(deshalb „lernerschwerend“)

- Grundlagen des prinzipiellen Vorgehens beim erstellen eigener Programme wird so gut wie nicht vermittelt (kaum sind Abbildungen von Programmstrukturen, z. B. Flussdiagramme, zu finden).

- die Sketches (so werden beim ADRUINO Programme genannt) werden mit wenigen Kommentarzeilen im Sketch abgedruckt und erst unterhalb dieses Programmlistings weitere Erklärungen abgedruckt. Das Auge muss folglich stets vom Programmlisting und dem Erklärungstext hin und her wandern, was sehr ermüdend ist. Warum nicht links den Programmausdruck und entsprechend jeweils rechts dazu die erforderlichen Erklärungen?

- Für Variablen werden oft Namen verwenden, welche den Namen der Programmbefehle zum verwechseln ähneln (die Autoren verfallen hier dem Irrglauben damit eine Hilfe zu geben).

- In Büchern wird oft das Programmlisting grau hinterlegt, was die Lesbarkeit einschränkt, zumal der Text hier oft viel zu „dünn“ gedruckt ist. An farblichen Hervorhebungen wird meist völlig verzichtet (der graue Alltag des Programmierens?)

- eine komplette strukturierte Liste aller Programmierbefehle – zu mindest als Anhang – findet man so gut wie vergeblich.

- der lernwillige Leser wird in den meisten Fällen mit dutzenden konkreten Programmbeispielen gequält, um sich damit in die Thematik des Programmierens einzuarbeiten und sich die Vielzahl von Programmbefehlen einzuprägen. Grundsätzliches, allgemein Gültiges, Struktur sowie Vorgehensweisen bleiben didaktisch auf der Strecke.

- Es macht keinen Sinn Beispiele auswendig zu lernen! Der geneigte Leser gewinnt bestenfalls den Eindruck damit alles zu wissen; möchte er dann aber ein eigenes Projekt realisieren, kommt er schnell ins Dilemma „wie mache ich denn Das?“.

Versuch wir dies im Folgenden etwas besser zu gestalten.

Der Anfang

>> bevor wir einen Aufsatz schreiben konnten, mussten wir Lesen und Schreiben lernen<<

bevor wir eigene Programme schreiben können, müssen wir Programmbefehle und Programmstrukturen lernen.

Generell merken wir uns:

Der ARDUINO versteht nur einen definierten Wortschatz, den Befehlssatz.
Befehle werden sequentiell (also nacheinander, Zeile für Zeile) abgearbeitet
Variablen (das sind Platzhalter, den Information zugewiesen werden kann) müssen definiert werden.
Kommentare sind Texte, die das Programm ignoriert (nicht ausführt), aber hilfreich zum Verständnis beim Lesen eines Programmlistings sind.

prinzipieller, sequentieller Programmablauf

Programm Starten (beim ARDUINO erfolgt der Programmstart im Allgemeinen sowie die Stromversorgung anliegt)

Variablen werden definiert,
Ein-, Ausgänge (ARDUINO-Pins) werden definiert

Programmanweisungen.
Beispielsweise lese Potentiometerspannung an Eingang X ein.
Lasse LED an Ausgang Y blinken.

Ausgabe auf einen Monitor (beim ARDUINO „Serial Monitor“ auf den PC):
Potentiometerspannung X Volt
LED blinkt

STOP (beim ADRUINO nicht der Fall, es wird eine sich wiederholende Programmschleife durchlaufen!)

Abb.1

Die obige Abbildung soll lediglich veranschaulichen, dass ein Mikrokontroller ein Programm sequentiell, also Schritt für Schritt, abarbeitet.
Weiterhin erkenn wir, dass es sehr hilfreich ist, die Aufgabenstellung erst einmal hinzuschreiben (in der Abbildung rechts) und dann ein kleines Flussdiagramm zu erstellen (in der Abbildung links). Hier wird dann sofort ein Problem erkennbar: die Potentiometerspannung wird einmal eingelesen, ein weiteres Verstellen des Potentiometers wird nicht mehr angezeigt, da das Programm stoppt! Blinkt die LED überhaupt weiter?

Also ändern wir unseren Programmablauf ein wenig:

prinzipieller, sequentieller Programmablauf

Programm Starten (beim ARDUINO erfolgt der Programmstart im Allgemeinen sowie die Stromversorgung anliegt)

1. Definitionen von Variablen
Ein-, Ausgänge (ARDUINO-Pins) werden definiert

2. Start-Prozedur = Setup-Routine

=> Schleifendurchlauf

3. Programmablauf in einer Endlosschleife
Programmanweisungen. Beispielsweise lese Potentiometerspannung an Eingang X ein. Lasse LED an Ausgang Y blinken.

Ausgabe auf einen Monitor (beim ARDUINO „Serial Monitor“ auf den PC):
Potentiometerspannung x Volt, LED blinkt

<= Rücksprung (Schleife)

Abb.2

Wir haben eine Schleife (englisch loop) eingefügt. Innerhalb dieser Schleife befinden sich die Anweisungen und die Ausgabe, welche nun permanent durchlaufen werden. Im Beispiel wird die LED nicht aufhören zu blinken und jede Potentiometeränderung wird einen entsprechenden Spannungswert anzeigen.

Wir sehen also wie hilfreich ein Flussdiagramm für die Erstellung eines Programms ist:
Führt das Programm das aus, was wir wollen?
Mögliche Fehler im Programmablauf werden leichter erkannt!

Soviel zu erforderlichen Vorarbeiten bei der Erstellung von Programmen (Verzeihung, beim ADRUINO nennt man ja ein Programm Sketch; wir wollen uns daran gewöhnen).
Englisch sketch, übersetzt: Skizze, Entwurf, Aufzeichnung (warum auch immer man Programme hier so bezeichnet).

Noch können wir keinen Sketch für den ADRUINO schreiben, es fehlt uns noch das Wissen über erforderliche Befehle und deren Anwendung dazu. Das soll bald folgen.
Zuvor jedoch eine kurze Übersicht der ARDUINO UNO Platine, da wir dessen Anschlüsse mit ihren Bezeichnungen zum Programmieren kennen müssen.

Der ARDUINO UNO die Platine mit ihren Anschlüssen

Abb.3

Steckbretter (englisch: Breadboards) sind zum schnellen kleinen Schaltungsaufbau bestens geeignet:

Abb.4

Die grundsätzliche Programmstruktur beim ARDUINO

1. Definitionen von Variablen
= Port n weist einer Variablen den Anschluss-Pin n zu (Port n steht hier also für eine Zahl, z.B. 13).
Wichtig ist das Semikolon am Zeilenende!

2. Start-Prozedur = Setup-Routine
Diese Prozedur wird nur einmal beim Start ausgeführt. Anweisungen stehen innerhalb geschweifter Klammern. void setup gibt keine Werte zurück.

Schleifendurchlauf

3. Programmablauf in einer Endlosschleife
Diese Prozedur wird endlos durchlaufen, bis die Stromversorgung getrennt wird, oder durch RESET das Programm neu gestartet wird. Alle Anweisungen stehen innerhalb geschweifter Klammern.

Abb.5

Wagen wir uns an eine erste Programmieraufgabe heran

Wir wollen die LED 13 auf dem Bord blinken lassen und über ein extern angeschlossenes Potentiometer eine einstellbare Spannung zwischen 0 und 5 Volt messen und auf dem PC im Serial Monitor anzeigen. Dabei werden wir obige grundsätzliche Programmstruktur wieder erkennen, sowie weitere Befehle kennen lernen.

Beachte:

· Die Programmiersprache des ADRUINO unterscheidet zwischen Groß- und Kleinschreibung!

· Programmbefehle sind deshalb exakt in der Schreibart einzugeben
(Groß/Klein, mit/ohne Leerzeichen, runde Klammern auf/zu, Komma, usw.)!

· Befehle werden stets mit einem Semikolon (Strichpunkt „;“) abgeschlossen!
Anweisungen innerhalb von void setup() und void loop() stehen stets innerhalb geschweifter Klammern „{…}“

PGM_01, unser erstes Demo-Programm

Programm-Listing

in dieser Spalte
steht das eigentliche Programm

Kommentar

In dieser Spalte werden zu den einzelnen Programmbefehlen Erklärungen gegeben. Innerhalb eines sketch können auch Kommentare eingefügt werden, diese werden durch vorangestellte „//“ Zeichen markiert und das Nachfolgende ignoriert.

1. Variablen definieren
Dieser Programmteil wird nur einmal beim Programmstart ausgeführt

int LEDPin = 13;	int definiert eine Integer-Variable (beinhalten ausschließlich ganze Zahlen oder einen logischer Wert). Für die Variable haben wir den Namen „LED“ gewählt. Pin= 13 besagt, dass die LED an den Pin 13 des Ports vom ADRUINO angeschlossen ist. Anmerkung: die auf dem Bord befindlich LED ist mit Pin 13 verbunden, sodass wir hier nicht zwingend eine externe LED anschließen müssen.
float ADC0=0;	definiert Analog-Eingang 0 als Fließkommazahl (ADC=AnalogDigitalControl = Analogdigitalwandler)
float Spannung;	Variable „Spannung“ zum Speichern des Analogeingangssignals als Fließkommazahl

2. Start-Prozedur = Setup-Routine = Initialisierungs-Routine (-Prozedur)
Dieser Programmteil wird nur einmal beim Programmstart durchlaufen

void setup() {	Initialisiert Variablen, Ports, etc. zum Programmstart Anweisungen müssen innerhalb geschweifter Klammern stehen
pinMode(LEDPin, OUTPUT);	Port „LEDPin“ wird als Ausgang definiert, dabei ist „LED“ der zuvor definierte Variabel-Name.
Serial.begin(9600);	definiert die serielle Schnittstelle mit der Baudrate 9600
}	Geschweifte Klammer zu, beendet die Initialisierungs-Prozedur.

3. Programmablauf in einer Endlosschleife
Dieser Programmteil wird fortlaufend ausgeführt (bis RESET oder Stromunterbrechung erfolgt)

void loop() {	Schleifenanfang Startet die Routine des eigentlichen Programms Anweisungen müssen innerhalb geschweifter Klammern stehen
digitalWrite(LEDPin, HIGH);	Schaltet die LED am zuvor definierten Port (LEDPin) ein (HIGH)
delay(1000);	Verzögert die Ausführung des nächsten Programmschritts um 1000 Millisekunden = 1 Sekunde
digitalWrite(LEDPin, LOW);	Schaltet die LED am zuvor definierten Port (LEDPin) aus (LOW)
delay(1000);	Verzögert die Ausführung des nächsten Programmschritts um 1000 Millisekunden = 1 Sekunde
Spannung=analogRead(ADC0);	übergibt den gemessenen Wert am Analogeingang 0 der Variablen „Spannung“
Spannung=Spannung/1024*5;	Eingangswert normiert auf den Bereich 0 bis 5 Volt; Einheit [V]!
Serial.print("Potiometerspannung = ");	schreibt den Text auf den Serial-Monitor
Serial.println (" V");	schreibt die Einheit auf den Serial-Monitor gefolgt mit Zeilenumbruch: das Anhängsel „ln“ (=line, deutsch Zeile) an den Befehl „print“ bewirkt, dass eine neue Zeile beginnt.
delay(1000);	Verzögert die Ausführung des nächsten Programmschritts um 1000 Millisekunden = 1 Sekunde.
}	Geschweifte Klammer zu, Schleifenende und Rücksprung zum Schleifenanfang.

Abb.6

Der Hardware-Aufbau zum PGM_01

Das Programm PGM_01, in der ARDUINO-Sprache SKETCH, alleine reicht natürlich nicht, wir benötigen noch den Schaltungsaufbau, Neudeutsch: den Hardware-Aufbau.

Hier ist er:

Abb.7

Serial-Monitor:

In der PC-Software des ARDUINO wird der Serial-Monitor unter Tools oder mittels Tastatureingabe Strg+Umschalt+M aufgerufen:

Abb.8

Das Listing des SKETCH PGM_01

// PGM_01 HJB-electronics 28.01.2016
// LED Blinken, Poti Volt Monitor
// nach Programmstart bitte den Serial-Monitor zur Anzeige auf dem PC starten!
// _________________________________________________________________

// DEFINITIONEN

int LEDPin = 13; // interne LED an Pin 13 erhält den Variablennamen LED
float ADC0=0; // definiert Analog-Eingang 0 als Fließkommazahl
float Spannung; // Variable zum Speichern des Analogeingangssignals als Fließkommazahl

// _________________________________________________________________

// SETUP-ROUTINE (wird nur einmal beim Programmstart durchlaufen)

void setup()
{
pinMode(LEDPin, OUTPUT); // der Port für die Variable LED wird als Ausgang konfiguriert
Serial.begin(9600); // definiert die serielle Schnittstelle mit der Baudrate 9600
}

// _________________________________________________________________

// HAUPTPROGRAMM (Programmablauf in einer Endlosschleife)

// Schleifen-Start

void loop()
{
    digitalWrite(LEDPin, HIGH); // der Ausgang für die LED wird eingeschaltet => LED an
    delay(1000); // nächster Programmschritt wartet 1000 ms = 1 Sekunde
    digitalWrite(LEDPin, LOW); // der Ausgang für die LED wird ausgeschaltet => LED aus
    delay(1000); // nächster Programmschritt wartet 1000 ms = 1 Sekunde
    Spannung=analogRead(ADC0); // übergibt den gemessenen Wert am Analogeingang 0 der Variablen
    Spannung=Spannung/1024*5; // Eingangswert normiert auf den Bereich 0 bis 5 Volt; Einheit [V]!
    Serial.print("Potiometerspannung = "); // schreibt den Text auf den Serial-Monitor
    Serial.print(Spannung); // schreibt den Inhalt der Variablen auf den Serial-Monitor
    Serial.println(" V"); // schreibt die Einheit auf den Serial-Monitor gefolgt mit Zeilenumbruch
    delay(1000); // verzögert um 1 weitere Sekunde, bis ein neuer Wert angezeigt werden kann}
// Schleifen-Ende und Rücksprung zum Schleifen-Start

// _________________________________________________________________

Abb.10

Ergänzende Erklärungen von Befehlen zum obigen Listung:

Spannung=analogRead(ADC0);

Ist es Ihnen aufgefallen, dass der Analogeingang 0 zum Programmstart nicht definiert wurde? Im Gegensatz zu allen anderen Ein-/Ausgängen (die stets vor Verwendung definiert werden müssen), müssen Analog-Ein-/Ausgänge nicht zuvor definiert werden.

Spannung=Spannung/1024*5

Der vom AD-Wandler erzeugte Wert wird hier in die Einheit Volt gewandelt und der Variablen „Spannung“ wieder übergeben.
In Worten: Spannung ergibt sich aus Spannung durch 1024 mal 5

Analoge Signale kann ein Mikrokontroller nur digital verarbeiten! Der ARDUINO wird mit einer Spannung von 5 V betrieben und nimmt diese als Referenzspannung. Ein analoges Signal von bis zu 5 V durchläuft einen Analog-Digital-Wandler, welcher den Spannungsbereich von 0 bis 5 Volt in 1024 Bereiche aufteilt (1024 dezimal = 2¹⁰, das sind 10 Bit, also die Auflösung; 10 Bit AD-Wandler).

5V/1024=0,00488V ist damit die maximal erreichbare Auflösung.

Der Serial Monitor des ARDUINOs und Alternativen

Auf obiger Abb. 8 ist der Serial Monitor, welcher Bestandteil der Software des ARDUINOs ist, dargestellt. Die Werte des Beispielprogramms werden hier zeilenweise untereinander aktualisiert dargestellt. Das heißt nach jedem übertragenen Wert (also nach jedem Durchlauf der Schleife) erfolgt ein Zeilenumbruch. Dies erfolgt durch das Anhängsel „ln“ an den Befehl „Serial.print“ => „Serial.println“.

Wird das Anhängsel „ln“ weggelassen, erfolgt kein Zeilenumbruch und die Werte werden einfach in einer Zeile hintereinander geschrieben.

Möchte man jedoch, dass die Werte stets an ein und derselben Position auf dem Monitor aktualisiert dargestellt werden, so muss nach jeder Werteübertragung zum Monitor ein Rücksprung zum Zeilenanfang erfolgen. Dazu gibt es einen Befehl „Wagenrücklauf“ (englisch: carriage return = cr), welcher aus der Zeit der guten alten Schreibmaschine stammt. In der Programmiersprache des ARDUINOs lautet er „\r“ (r steht für return, deutsch: zurück. Der vorangestellte umgekehrte Schrägstrich „\“, englisch backslash, veranlasst, dass „r“ ein Steuerbefehl ist und keine Variable).

Serial.print( '\r' );

Programm-Befehl des ARDUINOs für „Zurück zum Zeilenanfang“

Doch leider zeigt dieser Befehl im Serial-Monitor vom ARDUINO keine Auswirkungen! Woran liegt das?
Der ARDUINO sendet zwar den richtigen Befehl, jedoch ignoriert dieser Monitor den Befehl, weil er in nicht kennt.

Der im ARDUINO enthaltene Serial-Monitor ist kein vollständiges ANSI/VT100 Terminal !

Lösung des Problems:

auf einen anderen Seriellen-Monitor (Terminal-Programm) ausweichen!

Ich beschreibe hier eine Möglichkeit:

Bis Windows XP verfügte das Microsoft-Betriebssystem noch über das Programm „Hyper Terminal“. Wer also noch einen PC mit Windows XP besitzt, rufe dort das Hyper Terminal Programm auf (Bedienungshinweise folgen weiter unten).

Wer mit Windows 7 (oder höher) arbeitet, kann sich die folgenden Dateien des Hyper Terminals von seinem XP-Rechner in einen Ordner auf seines Windows-7-Rechners kopieren:

1) C:\Program\Windows NT\HYPERTRM.EXE (*)

2) C:\Windows\System32\hypertrm.dll

3) C:\Windows\Help\HYPERTRM.CHM

4) C:\Windows\Help\HYPERTRM.HLP

(*) beim Kopieren die Strg-Taste gedrückt halten, sonst wird nur eine Verknüpfung kopiert!

Erstellen wir unter Win7 also einen Ordner beispielsweise namens „XP_Hyper_Terminal“ und kopieren alle oben genannten Dateien in diesen Ordner (HYPERTRM.EXE | hypertrm.dll | HYPERTRM.CHM | HYPERTRM.HLP).

Dieser Ordner „XP_Hyper_Terminal“ kann unter C:\Programme(x86) erstellt werden, muss aber nicht. Jedes andere Verzeichnis ist auch möglich; beispielsweise auf ein Datenlaufwerk D:\DATEN\ARDUINO\ XP_Hyper_Terminal.

Es ist empfehlenswert sich noch eine Verknüpfung zum schnellen Aufrufen des Programms HYPERTRM.EXE auf den Desktop anzulegen.

Aus lizenzrechtlichen Gründen vermute ich, dass ich obige 4 Programmteile aus WinXP nicht zum Download einstellen kann. Bei Fragen bitte Mail.

Bevor wir unser XP Hyper Terminal Programm ausprobieren –eine Beschreibung dazu folgt gleich anschließend – hier erst einmal der dazu angepasste ARDUINO Sketch :
PGM_01_r

// PGM_01_r HJB-electronics 28.01.2016
// LED Blinken, Poti Volt Monitor
// nach Programmstart bitte XP_Hyper_Terminal zur Anzeige auf dem PC starten!// _________________________________________________________________

// DEFINITIONEN

// _________________________________________________________________

// SETUP-ROUTINE (wird nur einmal beim Programmstart durchlaufen)

void setup()
{
pinMode(LEDPin, OUTPUT); // der Port für die Variable LED wird als Ausgang konfiguriert
Serial.begin(9600); // definiert die serielle Schnittstelle mit der Baudrate 9600
}

// _________________________________________________________________

// HAUPTPROGRAMM (Programmablauf in einer Endlosschleife)

// Schleifen-Start
void loop()
{
    digitalWrite(LEDPin, HIGH); // der Ausgang für die LED wird eingeschaltet => LED an
    delay(1000); // nächster Programmschritt wartet 1000 ms = 1 Sekunde
    digitalWrite(LEDPin, LOW); // der Ausgang für die LED wird ausgeschaltet => LED aus
    delay(1000); // nächster Programmschritt wartet 1000 ms = 1 Sekunde
    Spannung=analogRead(ADC0); // übergibt den gemessenen Wert am Analogeingang 0 der Variablen
    Spannung=Spannung/1024*5; // Eingangswert normiert auf den Bereich 0 bis 5 Volt; Einheit [V]!
    Serial.print("Potiometerspannung = "); // schreibt den Text auf den Serial-Monitor
    Serial.print(Spannung); // schreibt den Inhalt der Variablen auf den Serial-Monitor
    Serial.print (" V"); // schreibt die Einheit auf den Serial-Monitor ohne Zeilenumbruch
    delay(1000); // verzögert um 1 weitere Sekunde, bis ein neuer Wert angezeigt werden kann
    Serial.print( '\r' ); // funktioniert nicht mit ADRUINOs Serial Monitor!!!
    // funktioniert mit HyperTerminal von WinXP
    // HyperTerminal nicht mehr in Win7 enthalten, kann aber von WinXP nach Win7 portiert werden
}

// Schleifen-Ende und Rücksprung zum Schleifen-Start

// _________________________________________________________________

Die Änderungen zum Sketch PGM_01 sind im obigen Listing PGM_01_r Gelb hinterlegt.

Verwendet man bei Programmausführung den ARDUINO Serial Monitor, so wird man feststellen, dass alles in der oberen Zeile hintereinander geschrieben wird. Der Befehl Serial.print( '\r' ) zeigt hier keine Wirkung. Bei Verwendung des Hyperterminals hingegen funktioniert es erwartungsgemäß.

Anleitung zum Programm Hyper Terminal als Serial Monitor für den ARDUINO

1.] ARDUINO an USB anschließen

2.] ARDUINO-IDE aufrufen und unser Beispielprogramm PGM_01_r laden.
      Es ist wichtig erst die IDE mit angeschlossenen ADRUINO zu starten, damit der entsprechende
     COM-Port belegt ist, bevor Hyper Terminal aufgerufen wird. In der ADRUINO IDE wird der COM-Port
     unten rechts angezeigt.

3.] HyperTerminal aufrufen

Bei der Erst-Verwendung des Hyper Terminals erscheint ein Fenster.

Hier tragen wir einen frei wählbaren Namen ein, und wählen ein Symbol aus.

Anschließend mit OK bestätigen.

Abb rechts unter WinXP

Dann wird der
vom ADRUINO verwendete COM-Port
eingetragen.

Abb rechts unter WinXP

Weiter Einstellungen unter XP entsprechen (im Wesentlichen) denen von Windows 7:
Unter Win7:

1] Verknüpfung erstellen

Hier wird das Verzeichnung gesucht indem das Programm hypertrm.exe abgelegt ist, um die Verknüpfung zu erstellen.
im Anschluss kann diese Verknüpfung benannt werden.

Verknüpfung benennen