Anleitung Watt ise ne Arduino? Technik und Programmierung in einfachen Worten

[BAXL]

Watt ise ne Arduino? Da stelle ma uns jans dumm…

So ähnlich könnte sich das in der Feuerzangenbowle anhören. Aber im Ernst, was ist das nun für ein Ding?

Ein Arduino ist ein kleiner Computer, in der Größe einer halben Tafel Schokolade. Da ist alles drauf, was ein Computer braucht. Ein Rechenwerk, auch Prozessor oder CPU genannt, Arbeitsspeicher, Programmspeicher und eine Vielzahl von Anschlüssen, an denen elektrische Signale ausgegeben oder eingelesen werden können. Ein Arduino ist nicht mit einem PC vergleichbar, der für gewöhnlich einen Bildschirm, eine Tastatur, eine Maus und eine Vielzahl Benutzerprogramme hat. Ein Arduino ist ziemlich nackt und hat eigentlich nur ein einziges Programm, das automatisch startet und in einer unendlichen Schleife läuft. Seine Hauptanwendung ist eben das Messen, Steuern und Regeln.

Die elektrischen Anschlüsse sind das Besondere an dem Arduino. Diese Anschlüsse können z.B. Signale über Sensoren einlesen oder elektrische Signale ausgeben, mit denen man LEDs, Relais oder andere Dinge ein- und ausschalten kann. Mit den mittlerweile reichhaltig erhältlichen Sensoren für den Arduino kann man Spannungen, Ströme, Lichtstärke, Temperatur, Magnetfelder, Abstände, Druck und vieles mehr messen.

Ein Programm im Arduino kann die Eingangssignale auswerten und in Abhängigkeit davon die Ausgangskanäle schalten. Die Eingänge können aber nicht nur Schaltzustände wie AN und AUS erkennen, sondern auch Spannungen messen. Das gleiche gilt auch für die Ausgangsanschlüsse, die zum Teil nicht nur EIN und AUS schalten können, sondern mit einem kleinen Trick auch unterschiedliche Spannungen ausgeben können.

Um mit dem kleinen Arduino-Computer „sprechen“ zu können, d.h., Programme dort einzuspeichern, hat der Arduino einen USB-Anschluss, über den die Platine auch mit Spannung versorgt wird. Soll die Arduino-Platine für sich alleine arbeiten, gibt es noch die Möglichkeit an einem speziellen Stecker eine Versorgungsgleichspannung von 7-12 V einzuspeisen. Der Arduino macht daraus für sich die Betriebsspannung.

Um den Arduino programmieren zu können braucht man für seinen PC eine so genannte Enwicklungsoberfläche. Die Oberfläche sieht in etwa wie ein Textverarbeitungsprogramm aus (z.B. Word). In diesem Textverarbeitungsprogramm schreibt man die Programmbefehle.

Die Programme werden in einer Hochsprache geschrieben, das heißt, dass die Befehle für uns verständliche Wörter verwenden (sofern man ansatzweise etwas Englisch kann). Die Befehle müssen in einer bestimmten Form und Reihenfolge geschrieben werden, man nennt das auch Syntax. Man kann sich das wie einen normalen Satz vorstellen.

Nimmt man den Satz „Gehe zu dem Haus am Ende der Straße und wirf einen Brief in den Briefkasten.“ Den Satz versteht jeder und jeder weiß was er dann tun soll. Wenn ich dieselben Wörter in einer falschen Reihenfolge schreibe, z.B.:

„Gehe zu Briefkasten einen Brief Haus Ende Straße der und wirf dem am in den“, weiß keiner mehr so richtig was gemeint ist. Ein Computer hat leider nicht die Intelligenz und die Erfahrung, um aus den Wörtern den Sinn zu erkennen und richtig zu handeln, darum muß jede Anweisung bis auf das letzte Leerzeichen, Klammern und Wort, 100% richtig geschrieben sein. Wenn nicht, dann gibt’s solange Mecker bis es stimmt.


Als nächstes kommt das Programmieren, aber alles schön einfach.

Natürlich kann es in diesem Thema vorkommen, dass ich gewisse Sachen unterschlage, nicht 100% nach Lehrbuch schreibe und bewusst etwas ungenau bleibe, das kommt alles später wenn der totale Rookie anfängt zu verstehen.

 

[BAXL]

Ich möchte noch einmal anmerken, dass ich nicht der Arduino Papst bin und es im Intenet viele Spezialseiten von Leuten gibt, die das viel besser drauf haben als ich. Eigentlich bin ich auch noch ein Anfänger, verstehe aber deshalb sehr gut wo der Schuh drückt und wo man wie Max ins Getriebe guckt. OK, machen wir weiter.

Bei der Erklärung zum Programm muß ich einen Kompromiss finden. Einerseits sind ein paar Grundlagen zur Programmierung an sich notwendig, andererseits ist da noch die Sache mit der Programmiersprache des Arduino. Ich werde also immer mal hin und her hüpfen und manchmal so tun, als könntet ihr das andere schon.

Fangen wir mit dem Programmrahmen des Arduino an. Ein Arduinoprogramm besteht aus zwei Teilen. Im ersten Programmteil werden Anweisungen abgearbeitet und/oder Platzhaltern (Variable) bestimmte Zahlenwerte zugewiesen, darum auch die Bezeichnung Setup. Wenn der Arduino losrennt( also mit Spannung versorgt wird), dann arbeitet er den Teil ganz am Anfang und den Setupteil void setup(), nur ein einziges mal ab und springt dann ins Hamsterrad, also den Programmteil void loop()

Das sieht so aus:

void setup() {


// gib dein Startprogrammteil hier ein, er wird nur einmal am Start ausgeführt:

}



Der Zweite Programmteil läuft quasi in einer Endlosschleife. Ist man am Ende der Befehlskette angekommen, beginnt man wieder von Vorne. Darum nennt man das auch Loop, wie Schleife oder sich wiederholen.

void loop() {


// Gib hier Deinen Programmcode ein, der sich immer wieder wiederholt:

}

Die Anweisungen werden am Anfang und am Ende in geschweifte Klammern gesetzt { }, damit weiß das Programmiersystem, wo die Anweisungen beginnen und wo sie enden.

Es gibt aber einige Platzhalter, die bereits einen Wert vom System zugewiesen bekommen haben wie z.B. INPUT, OUTPUT, HIGH, LOW usw…

Nun aber zu den Befehlen, wir wollen schließlich Dinge schalten oder Messungen durchführen.

Vorweg sei gesagt, dass man nicht alles einfach so an den Arduino anschließen kann, mal eben einen Befehl eintippen und das Ding rennt. Manchmal ist auch noch eine kleine zusätzliche elektronische Schaltung nötig, um die kleinen Ströme (20mA) und Spannungen (5V) des Arduino an andere Anschlusswerte anzupassen, doch dazu wird euch Hermann und Andy mehr erzählen können, da bin ich nicht der Experte. Beim Arduinoprogramm wahrscheinlich auch nicht, habe aber viele Jahre in Pascal Steuerprogramme programmiert.

 

[BAXL]

Der erste Programmbefehl

Beginnen wir mit einem spannenden Befehl, mit dem man einen der Schaltausgänge des Arduino ansteuern kann, der Befehl heißt digitalWrite(); . Den kann man aber nicht so nackt nehmen, da gehört noch etwas dazu. Der Arduino muß wissen, welchen Pin er schalten soll und natürlich ob der ein, oder ausgeschaltet werden soll.

Beispiel: digitalWrite(3,HIGH);

Das bedeutet, dass der Pin 3 des Arduino eingeschaltet wird, also 5V Spannung ausgibt.


Beispiel: digitalWrite(3,LOW);

Das bedeutet, dass der Pin 3 wieder ausgeschaltet wird.

Aber halt, bevor man einen Pin ein- oder ausschalten kann, muß man dem Arduino natürlich mitteilen, dass dieser PIN ein Schaltpin ist, weil man die Pins auch zum Einlesen von Signalen nehmen kann oder zum Teil auch zum Messen oder Ausgeben einer Spannung.

Zu dem Zweck muß im ersten Programmteil, dem Setup, der Befehl pinMode(); gegeben werden.

Für unser erstes Beispiel wäre der Befehl: pinMode(3,OUTPUT);

Die 3 gibt an, welchen Pin man einstellen will und das OUTPUT sagt, dass man an dem Pin ein Signal ausgeben möchte.

Wenn man bis hier hin alles verstanden hat, versteht man auch die kleinen Abwandlungen.

 

[BAXL]

Möchte man einen Pin nicht zum Ausgeben eines Signals, sondern zum Einlesen verwenden, braucht man in dem Setup-Programmteil nur „die Richtung“ in pinMode() ändern, nämlich:

void setup() {

pinMode(3,INPUT);

}

Und siehe da, nun kann der Pin ein Signal einlesen. Das macht man mit dem Befehl digitalRead();

digitalRead(); liest von einem Pin das Signal ein und liefert als Ergebnis HIGH oder LOW zurück.
HIGH bedeutet, dass ein Signal anliegt, LOW bedeutet, dass kein Signal anliegt.

Im Programm sähe das dann so aus:

void loop() {

Eingangssignal = digitalRead(3);

// Wir lesen von Pin 3 das Signal ein und speichern das Ergebnis in Eingangssignal

}


Klammheimlich habe ich noch ein paar Sachen eingeführt, nämlich die Zeile mit den beiden // und ein Variable, die Eingangssignal heißt.

Die beiden // sind dazu da, dass man innerhalb der Programmzeilen Kommentare oder Erklärungen einfügen kann und das System das einfach überliest und nicht versucht Programmcode daraus zu machen. Wenn man nämlich ein Programm schreibt, weiß man in dem Moment natürlich genau was man da gemacht hat, nuuur, wenn man zwei Wochen Später etwas ändern will oder etwas nicht so funktioniert wie man sich das gedacht hat, steht man wie ein Ochs vorm Berg, weil man sich nicht mehr erinnert. Also nicht zu sparsam mit Erklärungen sein.


Das Zweite ist die Variable Eingangssignal. Diese Variable benötigt man, um sich das Messergebnis zu merken und weiterverarbeiten zu können. Damit diese Variable überhaupt im Programmteil loop() funktioniert, muß man dem Arduino das vorher „erklären“. Also gehört in den Programmteil Setup() noch eine Bekanntmachung (Deklaration) der Variable und das sieht so aus:

void setup() {

int Eingangssignal=0

pinMode(3,INPUT);

}

Beim Deklarieren gibt man an, was für ein Zahlentyp verwendet werden soll und setzt gleich einen Startwert, in unserm Fall 0 (Null).

Ach, ich vergass noch, da gibt es noch etwas was sich unbenerkt eingeschlichen hat, nämlich das Semikolon ; am Ende einer Programmzeile bzw. eines Befehls, damit weiß der Programmübersetzer (das ist das Übersetzungsprogramm auf dem PC), dass hier die Anweisung zuende ist.

Zum Schluß noch einmal alles zusammen und in richtiger Reihenfolge:

void setup() {

int Eingangssignal=0;

pinMode(3,INPUT);

// es wird die Variable Eingangssignal deklariert und als Startwert auf 0 gesetzt, der Pin 3 des Arduino wird als Eingangskanal gesetzt
}

void loop() {

Eingangssignal = digitalRead(3);

// Wir lesen von Pin 3 das Signal ein und speichern das Ergebnis in Eingangssignal

}

Eigentlich sind wir nun soweit, dass wir ein ganz einfaches Programm schreiben können. Es gibt noch ein paar Befehle und und Feinheiten zu beachten, aber alles hübsch langsam und der Reihe nach. Später wird’s dann flotter.

 

[BAXL]

Nun ein kleiner Zwischenschritt.

Es geht um die Platine, genauer gesagt um die Anschlüsse für die Ein- bzw. Ausgänge.

Wenn man sich die Platine ansieht, dann befinden sich an den äußeren Seiten kleine Steckbuchsen, in die ebenso kleine Stecker (z.B. von Pfostensteckern) gesteckt werden können, Vollpfosten passen da aber nicht rein. .

Leider findet man im Internet keine einfache Beschreibung für ganz Unbeleckte, sondern nur Grafiken, die Schnittmustern gleichen, oder eher oberflächliche Beschreibungen. Für Leute, die sich schon mit dem Teil befasst haben ist das als Gedankenstütze aber vollkommen ausreichend, nur nicht für Dummies. Als versuche ich mich selbst daran.

Die für uns interessanten Buchsen sind von 0 bis 13 und von A0 bis A5 durchnummeriert.

Die Buchsen 0 und 1 stehen nicht zur freien Verfügung, bleiben also die Buchsen 2 bis 13. Diese Anschlüsse sind als digitale Ein- bzw. Ausgänge nutzbar, d.h., der Arduino kann diese Pins nur zwischen Null und 5V hin und herschalten, bzw. nur die Zustände Ein (5V) und Aus (0V) feststellen.


Die Anschlüsse A0 bis A5 können Spannungen zwischen 0V und 5V in 1024 Schritten messen, was einer 10Bit Auflösung entspricht. Der Messwert 0 entspräche dann 0V, der Messwert 1023 entspricht 5V. Als exemplarischen Zwischenwert nehme ich die 478, was einer Spannung von ungefähr 2,33 V entspricht.


Nun kommen wir zu einer kleinen Besonderheit. Man kann mit dem Arduino Spannungen zwischen 0V und 5V messen, aber eigentlich nicht ausgeben. Manchmal wäre es aber schön, wenn man eine variable Spannung ausgeben könnte. Dafür gibt es einen Trick, der sich PWM nennt, also Puls Weiten Modulation.

Das heißt, dass man einen Digitalen Ausgang, der nur zwischen 0V und 5V schalten kann, so schnell ein und wieder ausschaltet, dass es für einen Verbraucher so aussieht, als sei eine kleinere Spannung als 5V vorhanden. Das geht in 256 Schritten mit den Werten 0 bis 255.

0 wäre dann wieder 0V und 255 wären 5V. möchte ich einen Zwischenwert einstellen, z.B. 3,5V, dann entspräche das einem digitalen Steuerwert von ungefähr 179. Aber wie gesagt, das sind keine echten 3,5V, sondern durch das schnelle Ein- und Ausschalten, simulierte 3,5V, also Quasi ein Mittelwert.

Die für PWM verwendbaren Pins sind 3,5,6 und 9,10,11. Man kann das auf der Platine an dem Tildezeichen ~ erkennen.

Ich fasse zusammen:

Digitale Ein- oder Ausgänge sind die Pins 2 bis 13. Die können nur zwischen 0V und 5V schalten oder als Eingangssignal erkennen. Mit einem Trick (PWM) können die Pins 3,5,6 und 9,10,11 als PWM Ausgang geschaltet, Spannungen zwischen 0V und 5V in 256 Schritten simulieren.

Die Pins A0 bis A5 sind reine Eingänge, die Spannungen zwischen 0V und 5V in 1024 Schritten messen können. Die gemessene Spannung entspricht 5V / 1024 * (eingelesener Wert).

 

[BAXL]

Weiter geht’s beim Programmieren

Erstellen wir zunächst ein kleines Programm, das man auch laufen lassen kann, ohne an den Arduino etwas anschließen zu müssen. Dafür bedienen wir uns dem Pin 13, an dem bereits eine kleine LED auf der Arduino-Platine angeschlossen ist.

Wir wollen die kleine LED blinken lassen. Dazu schalten wir den Pin 13 abwechselnd ein und wieder aus. Weil der Arduino das so schnell machen würde, dass wir das nicht sehen würden, müssen wir kleine Pausen zwischen den Programmschritten einbauen. Dafür gibt es den Befehl delay().

Dieser Befehl verzögert den Programmablauf um die angegebene Zeitspanne in Millisekunden.

1 bedeutet eine Millisekunde, 1000 bedeutet 1000 Millisekunden, was genau eine Sekunde ist.

void setup() {

pinMode(13, OUTPUT); //der Pin 13 wird als Ausgangspin konfiguriert

}

void loop() {

digitalWrite(13, HIGH); // dieser Befehl schaltet Pin 13 ein und damit auch die kleine Kontroll-LED
delay(1000); // hier wartet der Arduino für 1s
digitalWrite(13, LOW); // der Pin 13 wird wieder ausgeschaltet und die LED geht aus.
delay(1000); // hier wartet der Arduino für 1s

}

 

[BAXL]

Jetzt nehmen wir uns weitere Programmbefehle vor. Es geht aber immer noch um das Bedienen der Ein- und Ausgabepins.

Nehmen wir die Pins A0 bis A5, mit denen man Spannungen zwischen 0V und 5V in 1024 Schritten messen kann. Der dazugehörige Befehl lautet analogRead();. Man benötigt diesen Befehl um z.B. einen Wert von einem Temperatursensor oder Helligkeitssensor messen zu können.

Es muss selbstverständlich wieder angegeben werden, von welchem Pin eingelesen werden soll und das Messergebnis muss in einen Zwischenspeicher zur weiteren Verarbeitung abgelegt werden. Der eingelesene Wert kann von 0 bis 1023 gehen, weshalb die benötigte Variable vom Typ Integer sein sollte. Integervariablen können Zahlen von -32768 bis +32767 ohne Nachkommastellen sein.

Es muß also in der Startsequent void setup() die Deklaration z.B. int Messwert = 0; stehen. Die Kanäle selbst braucht man nicht als Eingang deklarieren. Die Analogeingänge sind von 0 bis 5 durchnummeriert. Möchte man von einem der Kanäle einen Wert einlesen, braucht lediglich die Nummer des Kanals angeben.



Das könnte dann z.B. für Kanal 2 so aussehen:

Messwert = analogRead(2);

Nun die Ausgabe einer (simulierten) Spannung über einen der Digitalkanäle, die mit der ~ gekennzeichnet sind, zur Erinnerung, das sind die Kanäle der Pins 3,5,6 und 9,10,11.

Wollen wir z.B. am Pin 5 eine analoge Spannung ausgeben, so muß dieser in der Startsequenz void setup() als Ausgang konfiguriert werden und kann dann im Hauptprogramm void loop() mit analogWrite() aufgerufen werden. Die Ausgabewerte dürfen dann nur von 0 bis 255 angegeben werden.

Beispiel:

void setup() {

//der Pin 5 wird als Ausgangspin konfiguriert

pinMode(5, OUTPUT);

}

void loop() {

analogWrite(5, 178); // dieser Befehl gibt an Pin 5 den Wert 178 an, der ungefähr 3,49V entspricht

delay(1000); // hier wartet der Arduino für 1s

analogWrite(5, 100); // dieser Befehl gibt an Pin 5 den Wert 100 an, der ungefähr 1,96V entspricht

delay(1000); // hier wartet der Arduino für 1s

}

Die Ausgangsspannung wird im 1s Takt zwischen 3,49V und 1,96V hin und her geschaltet.

Natürlich kann man für die Zahl auch durch eine Variable ersetzen und im Programmablauf beliebig verändern. Die Variable muß in void setup() als int, also Integer deklariert werden, z.B.

int Ausgabewert=0;

 

[BAXL]

Programmablaufsteuerung

Damit so ein Programm auch etwas Sinnvolles machen kann sind Befehle notwendig, mit denen verglichen, entschieden, weitergeleitet, oder eine Anweisung mehrfach wiederholt werden kann.

Die FOR – Schleife

Die FOR – Schleife ist eine Art Miniprogramm in dem loop() – Berteich, bei der die enthaltenen Befehle solange ausgeführt werden bis eine Bedingung erfüllt ist.

Syntax: for (Voreinstellung; Abbruchbedingung; Inkrement)
{

// Anweisungen

}

Bei diesem Schleifentyp definiert man zuerst eine Variable (Voreinstellung), mit der man zählt. Es wird geprüft, ob die Variable einen bestimmten Wert erreicht hat (Abbruchbedingung). Mit Inkrement kann man die Variable um einen bestimmten Wert erhöhen, aber auch verringern.

Das könnte dann etwa so aussehen:


for (i=0; i<=7; i++)

{
digitalWrite(i,High);
delay(1000);
digitalWrite(i,LOW);
delay(500);
}

In dieser Schleife würden der Reihe nach die Schaltausgänge Pin 0 bis Pin 7 ein und nach einer 1 sekündigen Pause wieder ausgeschaltet. Damit könnte man z.B. an die Schaltausgänge LEDs anschließen, die wie ein Lauflicht blinken. Natürlich muß man in void setup() die Variable i bekannt machen (int i = 0); und die Digitalen Kanäle Pin 0 bis Pin 7, der Reihe nach als Ausgänge definieren pinMode( pinnummer, OUTPUT);

Bei der Abbruchbedingung wird der aktuelle Wert von i immer mit der Zahl 7 verglichen. Ist der Wert kleiner (<) oder gleich (=) 7, läuft die Befehlskette durch. Mit i++ erhöht man den Wert von i bei jedem Scheifendurchlauf um den Wert 1. D.h., wenn i den Wert 4 hatte hat er nach dem Schleifendurchlauf, durch i++, den Wert 5.

Innerhalb der Anweisungsschleife wird der Reihe nach der Ausgangspin mit dem aktuellen Zahlenwert von i ein und wieder ausgeschaltet.

 

[BAXL]

Eine Entscheidung!

Einstweilen kommt es vor, dass man einen Befehl ausführen möchte, in Abhängigkeit von dem Eintreten eine Bedingung. Das kann z.B. sein, wenn man einen Eingangspin überwachen möchte und falls ein bestimmter Zustand dort eintritt, einen Schaltvorgang ausführen möchte. Nehmen wir an, wir haben ein Modell und möchten die Akkuspannung überwachen. Falls ein Spannungswert unterschritten wird, soll ein Summer ein akustisches Signal ausgeben, oder eine Kontroll-LED soll angehen.

Der dafür verwendbare Befehl wäre eine IF Anweisung. If ist Englisch und heißt wenn. Wenn also etwas Bestimmtes eintritt soll etwas getan werden. Und so sieht eine IF Anweisung aus:

if (Eingangsspannung < 50)

{

digitalWrite (3, HIGH)

// Wenn die Eingangsspannung kleiner als 50 ist wird der Pin 3 aktiviert, an dem z.B. eine LED hängt

}

Man muß dabei beachten, dass nach der Entscheidungszeile die Befehle in geschweifte Klammern gesetzt sind { }, damit weiß der Computer, wo die Anweisungen für die Entscheidung anfangen und zuende sind.

Werden wir etwas praktischer. Ich möchte einen 2s Akku überwachen. Wenn die Akkuspannung unter 7V (das ist 3,5V pro Zelle) sinkt, leuchtet eine rote LED.

Leider kann man einen 2s Akku nicht direkt an einen der Spannungsmesseingänge (A0 bis A5) anschließen, weil dort maximal 5V erlaubt sind. Darum braucht man zwei Widerstände, aus denen man einen Spannungsteiler baut. Der Einfachheit halber nehmen wir zwei 1000 Ohm-Widerstände, die wir in Reihe schalten. Die Spannung teilt sich zur Hälfte auf und kann bei einem vollen Akku 4,2V betragen. Wenn der Akku nur noch 7V hat, liegt eine Spannung von 3,5V an. Beide Spannungen sind gefahrlos für den Messeingang.

Rechnen wir mal um. 5V entsprechen an z.B. A0 einem Messwert von 255. 4,2 V sind dann 214; 3,5V entsprechen dann ungefähr 178.

void setup() {
int Eingangsspannung = 0; // Variable für den Messwert deklarieren und auf 0 setzen
pinMode(5, OUTPUT); //der Pin 5 wird als Ausgangspin konfiguriert
}

void loop() {
Eingangsspannung = analogRead(0); // dieser Befehl liest die Spannung am Analogpin A0 ein
// Nun kommt die Entscheidung

if (Eingangsspannung < 178)
{
digitalWrite (5, HIGH)
// Wenn die Eingangsspannung kleiner als 178 ist wird der Pin 5 aktiviert, an dem eine LED hängt
// ist Eingangsspannung größer als 178 passiert nichts und die LED bleibt aus
}

}

Um das Ganze noch ausgefuchster zu machen, nehmen wir noch eine grüne LED dazu und führen direkt den nächste Entscheidungsbefehl ein, nämlich If / else. Bei dieser Entscheidung gibt man eine Reaktion vor, falls die Bedingung nicht erfüllt wird. Else ist, na klar, wieder Englisch und bedeutet sonst oder andernfalls osä.

Beispiel:

void setup() {
int Eingangsspannung = 0; // Variable für den Messwert deklarieren und auf 0 setzen
pinMode(5, OUTPUT); //der Pin 5 wird als Ausgangspin konfiguriert rote LED
pinMode(6, OUTPUT); //der Pin 6 wird als Ausgangspin konfiguriert grüne LED
}

void loop() {
Eingangsspannung = analogRead(0); // dieser Befehl liest die Spannung am Analogpin A0 ein
// Nun kommt die Entscheidung
if (Eingangsspannung < 178)
{
digitalWrite (5, HIGH) // Wenn die Eingangsspannung kleiner als 178 geht die rote LED an
digitalWrite (6, LOW) // Wenn die Eingangsspannung kleiner als 178 ist geht die grüne LED aus
}

else // wenn nicht, dann tue folgendes
{
digitalWrite (5, LOW) // Wenn die Eingangsspannung größer als 178 ist geht die rote LED aus
digitalWrite (6, HIGH) // ist Eingangsspannung größer als 178 geht die grüne LED an
{

}

 

[BAXL]

Vergleichsoperatoren

Wenn man im Verlauf eines Programms Werte oder Zustände miteinander vergleichen möchte, um eine Entscheidung für z.B. eine Verzweigung zu treffen, benötigt man so genannte Vergleichoperatoren. Damit kann man vergleichen, ob zwei Werte gleich sind, der eine größer als der andere, ob Werte ungleich sind oder ob eine Aussage wahr oder falsch ist.

Diese Vergleichsoperatoren setzt man dann zwischen die Werte, die verglichen werden sollen.

Möchte man auf Gleichheit prüfen setzt man zwei Gleichheitsszeichen zwischen die Werte ==.

Beispiel: if a == b

Möchte man prüfen, ob Werte ungleich sind verwendet man !=

Beispiel: if a != b

Bei Kleiner als der andere Wert das aus der Mathematik bekannte Kleinerzeichen <

Beispiel: if a < b

Analog dazu gibt es das Größerzeichen >

Beispiel: if a > b

Oder bei größer oder gleich, oder kleiner oder gleich >= <=

Beispiel: if a >= b oder if a<= b


Variablen

Wenn wir in einem Programm Zahlenwerte zwischenspeichern müssen, um diese z.B. zu einem späteren Zeitpunkt für einen Vergleich zu verwenden oder um eine Berechnung damit auszuführen, müssen wir dafür im Computer einen Speicherbereich freihalten. Dafür werden Variablen deklariert.

Aus der Mathematik kennen wir bereits unterschiedliche Zahlentypen: positve Zahlen, negative Zahlen, ganze Zahlen (also glatte Zahlen ohne Nachkommastellen) und auch Kommazahlen. Der Computer benötigt zum Speichern dieser Zahlen unterschiedlich viel Speicherplatz. Speicherplatz ist knapp im Computer, weshalb man nur soviel Speicherzellen reserviert, wie nötig. Darum gibt es unterschiedliche Zahlentypen, die auch unterschiedlich vile Platz im Speicher belegen. Man muß aber aufpassen und klug entscheiden, welchen Zahlentyp man verwendet. Ist die zu erwartende Zahl größer, als der Zahlentyp aufnehmen kann kommt es zu Fehlern im Programm, nimmt man Zahlentypen, die viel zu groß dimensioniert sind, verschwendet man kostbaren Speicher. Also vorher gut überlegen!

boolean
Beginnen wir mit dem Zahlentyp boolean, d.h., dass dort eigentlich nur gespeichert wird, ob etwas wahr oder falsch ist. Im Grunde nur den Zahlenwert 0 oder 1. Dafür braucht der Computer ein Byte Speicher.

byte
Der Zahlentyp byte kann Zahlen von 0-255 speichern und belegt, wie der Name schon sagt, ein byte Speicher.

Int
Integer kann ganze Zahlen von -32768 bis +32767 aufnehmen und belegt dafür zwei Bytes.

unsigned int
Unsigned int ähnelt dem Datentyp int, mit dem Unterschied, dass hier nur positive Zahlen gespeichert werden können, dafür liegt der Wertebereich von 0 bis 65535 und belegt ebenfalls nur 2 Bytes.

long
Long kann Zahlen von -2147483648 bis 2147483647 speichern und belegt 4 Bytes.

unsigned long oder word
Unsigned long oder word, umfasst positive Zahlen von 0 bis 4294967295 und belegt 4 Bytes

float
float sind Kommazahlen (z.B. 2,39628). Dieser Datentyp speicher sehr große Zahlenwerte, die positiv oder negativ sein können, dafür werden vier Bytes als Speicher belegt. Die Genauigkeit beträgt maximal 6 bis 7 Nachkommastellen.

Char
In Char können einzelne Buchstaben abgelegt werden, dafür belegt das Programm jeweils ein Byte.

Es gibt noch weitere Datentypen, doch will ich es mit den genannten bewenden lassen, weil die am meisten gebraucht werden. Sollte irgendwann ein zusätzlicher Datentyp gebraucht werden, erkläre ich den.

 

[BAXL]

Rechenoperationen

Möchte man im Programm Berechnungen durchführen, kennt die Arduinoprogrammumgebung Operatoren. Das ist eigentlich nichts anderes als Rechenvorschriften, die man an bekannte Rechenzeichen knüpft.

Beginnen wir mit den üblichen Rechenzeichen zum Addieren, Subtrahieren, Multiplizieren und Dividieren, kurz gesagt: plus, minus, mal, geteilt.

Die Rechenzeichen dafür sind:

Plus + z.B. 5+3

Minus – z.B. 8-5

Mal * z.B. a*5

Geteilt / z.B. a/b

Weitere Zeichen sind:

++ erhöhe den Wert einer Variablen um genau 1 (i++) wenn i vorher 5 war ist es nach i++ 6, man sagt dazu auch inkrementieren

-- verringert den Wert um genau 1 (i--), wenn i also vorher 8 war ist i nach i—nur noch 7, men nennt das auch dekrementieren


Auch hier gibt es noch mehr, doch alles zu seiner Zeit.

Natürlich gehört das Gleichheitszeichen = auch irgendwie dazu, damit übergibt man das Ergebnis einer Rechenoperation in eine Variable.

Rechenergebnis = a + 5

 

[BAXL]

Funktionen (Unterprogramme, Subroutinen)

Nachdem wir die einfacheren Sachen abgefrühstückt haben, geht es nun etwas tiefer in die Programmierung. Arduinoprogramme laufen in einer unendlichen Schleife. Das Programm fängt mit der ersten Anweisung an, arbeitet alle Befehle bis zum Programmende ab und fängt wieder von vorne an. Wie ein langer Bandwurm, der seinen Schwanz in der Schnute stecken hat.

Je nachdem, wie komplex ein Programm wird, sammeln sich ordentlich Programmzeilen an. Dabei kann es passieren, dass bestimmte Befehlsblöcke immer wieder auftauchen, oder in gleicher Art für unterschiedliche Zwecke verwendet werden. Das kann sehr mächtig und unübersichtlich werden. Diese gleichartigen Programmblöcke kann man zu einer Funktion zusammenfassen. Alte Basic-Programmierer nennen das auch Unterprogramm oder Subroutine. Das schafft Platz und Übersicht.

Die Funktionen setzt man im Programmlisting einfach unter das Hauptprogramm loop().

Nehmen wir als Beispiel die Überwachung eines 4s LiPo-Akkus. Da wollen wir einmal die Gesamtspannung überwachen, aber auch die einzelnen Zellen im Auge behalten, falls mal eine schwächelt.

Bei der Gesamtspannung lesen wir einen Messwert von einem analogen Eingang, z.B. A0 ein und vergleichen mit einem vorgegebenen Wert. Das Gleiche machen wir mit allen Einzelzellen (z.B. A1 bis A4). Bei einem 4s LiPo kommen wir somit auf 5 Befehlsfolgen, die im Grunde immer das Gleiche machen, nur werden jeweils andere analoge Messkanäle abgerufen und mit einem Vorgabewert verglichen.

Wie sieht ein Unterprogramm / Funktion aus?

Eigentlich genau so wie das Hauptprogramm.
Beispiel:

void unterprogramm()
{

// ab hier stehen die wiederkehrenden Programmbefehle

}

Das Unterprogramm wird im Hauptprogramm einfach mit seinem Namen aufgegerufen. Die o.g. Funktion ruft man mit unterprogramm(); auf, das wars schon. Manchmal möchte man der Funktion auch Werte übergeben, auch das ist möglich, die Deklaration der Funktion sieht dann in den runden Klammern () dann nur etwas anders aus.

Void unterprogramm (byte Ausgang, int Schaltzeit)
{
digitalWrite(Ausgang, HIGH);
delay(Schaltzeit);
digitalWrite(Ausgang,LOW)
}

Mit dieser Funktion können wir jeden beliebigen Ausgang einschalten, die Leuchtdauer bestimmen und danach wieder ausschalten. Natürlich nennt man die Funktion dann nicht Unterprogramm, sondern z.B. SchalteLED() oder so.

Achtet mal darauf welche Datentypen ich genommen habe. Für den digitalen Ausgang den Typ byte, weil da nur Zahlen bis max. 13 auftauchen und für Schaltzeit int, weil eine Sekunde schon die Zahl 1000 ist. Ich hätte eigentlich auch unsigned int nehmen können, weil Zeiten immer positiv sind , es sei denn, ich bastle eine Zeitmaschine :