Rechnen mit dem Arduino – Arithmetische Operatoren

Ihr Arduino kann auch rechnen, fast wie ein Taschenrechner

Er kann addideren, subtrhaieren, multiplizieren, dividieren und kennt auch die Modulo Operation. Diese Form der Operatoren wird arithmetsiche Operatoren genannt.

Tabelle Arithmetische Operatoren

Operator Operation Beschreibung Beispiel
+ Addition Addiert Werte a + b, 6 + 5, b + 5
- Subtraktion Subtrahiert Werte a – b, 6 – 5, b – 5
* Multiplikation Multipliziert Werte a * b, 6 * 5, b * 5
/ Division Dividiert Werte a / b, 6 / 5, b / 5
% Modulo Gibt den Rest einer ganzzahligen Divison aus a % b, 6 % 5, b % 5

Beispiel Addition

Das passiert:
In der ersten Zeile wird der Variablen a der Wert 8 zugewiesen.
In der zweiten Zeile wird a das Ergebnis von a + 1 zugewiesen.

Beispiel Multiplikation

Das passiert:
In der ersten Zeile wird der Variablen x der Wert 9 zugewiesen.
In der zweiten Zeile erhält die Variable y den Wert 8.
In der dritten Zeile werden die Variable y mit 10 multipliziert.
Das Ergebnis 80 wird nun der Variable x zugewiesen.

Beispiel Modulo

Das passiert:
In der ersten Zeile wird der Variablen a der Wert 18 zugewiesen.
In der zweiten Zeile erhält die Variable b den Wert 5.
In der dritten Zeile wird die Modulo Operation mit den Elementen Variable a und Variable b durchgeführt.
Dabei wird Variable a durch Variable b dividiert. Wir erhalten einen Rest von 3.
Das Ergebnis wird der Variablen a zugewiesen.

[sc name=“seriellermonitor“ ausgabe=“215
216
217″ ]

Vorrangregeln

Vorrangregeln legen fest, welche Rechenoperationen vor anderen ausgeführt werden.
Multiplikation und Division haben Vorrang vor Addition und Subtraktion.

Möchten Sie diese Reihenfolge ändern, können Sie sich der runden Klammern bedienen, die noch vorrangiger behandelt werden, also zuallererst ausgeführt werden.

Existieren mehrere geschachtelte Klammern, geht man von außen nach innen vor.

Tabelle Priorisierung Rechenarten

Rang Operation Beschreibung
1 ( ) runde Klammern haben Vorrang vor allen anderen Operationen
2 * / Multiplaktion und Division haben Vorrang vor Addition und Subtrakition
3 + - Additionen und Subtraktionen werden zuletzt durchgeführt

Inkrement-und Dekrementoperatoren

Inkrement- und Dekrementoperatoren erhöhen bzw. erniedrigen den Wert einer Variable um 1.

Tabelle Inkrement- und Dekrementoperatoren

Bezeichnung Operator Operation Beschreibung
Inkrement a++ a = a + 1 erhöht a um 1
Dekrement a– a = a + 1 erniedrigt a um 1

Diesen Typ Operatoren gibt es in zwei Varianten. Den ersten haben Sie gerade kennengelernt. Bei ihm befinden sich die Plus- oder Minuszeichen hinter der Variable. Dieser Typ wird mit dem Zusatz Postfix gekennzeichnet. Das Gegenteil wird als Präfix bezeichnet und sagt aus, dass sich die Plus- oder Minuszeichen vor der Variablen befinden.

Tabelle Postfix und Präfix

Operator Beschreibung
++a Präfixer Inkrementaloperator
a++ Postfixer Inkrementaloperator
–a Präfixer Dekrementaloperator
–a Postfixer Dekrementaloperator

Abhängig von der Position an der sich die Plus- oder Minuszeichen befinden, also ob sie vor oder hinter der Variablen stehen, ändert sich auch das Verhalten.

Die Postfix-Schreibweise erhöht bzw. verringert den Wert einer Variablen sofort, gibt aber den alten Wert an die Variable weiter.

Die Präfix-Schreibweise erhöht bzw. verringert den Wert einer Variablen und gibt diesen Wert auch sofort an die aktuellen Variable weiter.

Beispiel Präfixer Inkrementaloperator

Was passiert?
Das Inkrementieren erhöht den Wert der Variablen x um 1 auf 10. Die präfixe Schreibweise bewirkt, dass y der aktuelle Wert 10 zugewiesen wird.

Beispiel Postfixer Inkrementaloperator

Was passiert?
Das Inkrementieren macht das Gleiche wie im vorherigen Beispiel. Es erhöht den Wert der Variablen x um 1 auf den Wert von 10.
Die postfixe Schreibweise jedoch bewirkt, dass y der alte Wert von x nämlich 9 zugewiesen wird.
Erst beim nächsten Aufruf von x++ wäre 10 der "alte" Wert und y erhielte den Wert 10.

Rechnen mit Abkürzung – Zusammengesetzte Zusweisungsoperatoren

Auch mit ihnen können Sie Rechenoperationen an Variablen durchführen, nur effizienter, also mit weniger Schreibarbeit. Sie machen nichts anderes als die arithmetischen Operatoren und stellen lediglich deren Kurzform dar. Erfahrenere Programmierer verwenden Sie ausgiebig und oft.
Die Verwendung der zusammengesetzten Zuweisugnsoperatoren reduziert häufig die Lesbarkeit des Sketchs, gerade bei noch nicht so erfahrenen Programmierern.

Tabelle zusammengesetzte Zuweisungsoperatoren

Operation
Kurzform
Operation
Standard
Beschreibung
a+= b a = a + b addiert a mit b
a-= b a = a – b subtrahiert a von b
a*= b a = a * b multipliziert a mit b
a/= b a = a / b dividiert a durch b
a/= b a = a / b dividiert a durch b
a%= b a = a % b modulo von a und b

Beispiel Addition

Was passiert?
Der Wert von x erhöht sich um 9. In der bekannten Schreibweise würde der Ausdruck folgendermaßen aussehen:

 x = x  + 9

Der alte Ausdruck von x, in unserem Beispiel 1 wird zu 9 addiert
Das Ergebnis von 10 wird dann der Variablen x wieder zugewiesen.

Beispiel Multiplikation

Was passiert?
Der Wert von x verdreifacht sich. In der bekannten Schreibweise würde der Ausdruck folgendermaßen aussehen:

 x = x  * 3

Der alte Ausdruck von x, in unserem Beispiel 9 wird mit 3 multipliziert.
Das Ergebnis von 27 wird dann der Variablen x wieder zugewiesen.

Von Äpfeln und Birnen – Vergleichsoperatoren

Auch das Vergleichen ist in der Arduino Programmiersprache kein Problem. Nur werden hier keine Äpfel mit Birnen verglichen, sondern meistens Ausrücke. Der Begriff Ausdruck in einer Programmiersprache beinhaltet alles, was in irgendeiner Form Werte abbildet. Werte können in einer Variablen oder Konstanten gespeicherte Werte sein. Verglichen werden können beispielsweise Variablen untereinander oder Variablen mit Konstanten, Zahlen mit anderen Zahlen, Zeichen mit anderen Zeichen und noch vieles mehr. Das Vergleichen ändert keine Ausdrücke oder beispielsweise in einer Variablen abgelegte Werte. Es werden lediglich Prüfungen durchgeführt. Das Ergebnis dieser Vergleiche kann dann entweder wahr oder falsch sein. Diese beiden Zustände werden in der Arduino Programmiersprache mit den Konstanten „TRUE“ für wahr oder „FALSE“ für falsch abgebildet sein können.

Operator Beispiel Erklärung
== a == b vergleicht, ob a gleich b ist
!= a != b vergleicht, ob a ungleich b ist
< a < b vergleicht, ob a kleiner b ist
> a > b vergleicht, ob a größer b ist
< = a < = b vergleicht, ob a kleiner oder gleich b ist
>= a > b vergleicht, ob a größer oder gleich b ist

Vergleichsoperatoren kommen immer dann zum Einsatz, wenn innerhalb eines Sketches Entscheidungen getroffen werden sollen:
Ist der Wert der Variablen größer mache dieses.
Ist der wert der Variablen kleiner, dann mache jenes

Beispiele für Vergleiche

Für diese Beispiele verwenden wird die folgenden Variablen:

Die durchgeführten Vergleiche führen zu den folgenden Ergebnisse:

Vergleichsoperation Ergebnis
x == y FALSE
x != y TRUE
x < y TRUE
x > y FALSE

Logische Operatoren

Logische Operatoren verwenden sie, um logische Verknüpfungen auszuwerten. Es gibt das logische UND, das logische ODER und den NOT-Operator. Sie können in Abfragen verwendet werden, die mehr als einen Ausdruck enthalten. Wie auf eine solche Prüfung reagiert werden soll, lässt sich durch die Auswahl des logischen Operators bestimmen. Logische Operatoren können genau zwei Zustände annehmen. Als mögliche Werte gibt es nur wahr TRUE oder falsch FALSE.

Tabelle Logische Operatoren

Logischer-
operator
Operator
Schriftform
Bemerkung
&& UND Logische UND-Verknüpfung
|| ODER Logische Oder-Verknüpfung
! NOT Logische Negation

Logisches UND

Die logische UND-Verknüpfnung wird mit einem doppelten Ampersand angegeben &&.

Code-Beispiel

if(x > 5 && x < 10) // Nur wenn beide Bedingungen TRUE sind, ist auch das Ergebnis TRUE
{
serial.print('Das ist richtig');
}

Wahrheitstabelle UND-Verknüpfung

Ausdruck 1 Ausdruck 2 Verknüpfungsergebnis &&-Operation
FALSE FALSE FALSE
FALSE TRUE FALSE
TRUE FALSE FALSE
TRUE TRUE TRUE

Logisches ODER

Die logische ODER-Verknüpfnung verwendet das zweifache Verkettungszeichen || als Operator. Sie finden es auf der Tastatur links neben dem Y. Eingeben können Sie das Zeichen durch drücken der Tastenkombination alt gr und |

Code-Beispiel

if(x > 5 || y < 10) // Wenn eine der beide Bedingungen TRUE ist, ist auch das Ergebnis TRUE
{
serial.print('Bedingung erfüllt! x ist größer 5 oder y ist kleiner 10');
}

Wahrheitstabelle ODER-Verknüpfung

Ausdruck 1 Ausdruck 2 Verknüpfungsergebnis
ODER-Operation
FALSE FALSE FALSE
FALSE TRUE TRUE
TRUE FALSE TRUE
TRUE TRUE TRUE

Logisches NOT

Die logische NOT-Verknüpfnung wird mit einen einzelnen Ausrufungszeichen ! angegeben.

Code-Beispiel

if (!x < 5) // Der Ausdruck wird negiert. Ist das Ergebnis der Bedingung TRUE ist es danach FALSE und umgekehrt.
{
serial.print('x ist nicht kleiner als 5!!!');
}

Mit if-Abfragen ihren Sketch steuern

Der if-Befehl wird benutzt um Anweisungen auszuführen, wenn eine bestimmte Bedingung erfüllt ist.
Mit ihnen können Sie zum Beispiel einen digitalen Eingang auswerten oder prüfen, ob Messwerte, über- oder unterschritten werden und in ihrem Programm darauf reagieren.
Ist die Bedingung erfüllt, wird der Teil der innerhalb der geschweiften Klammern steht ausgeführt, ansonsten wird er einfach ignoriert.

Struktur der If-Abfrage

if … else-Abfrage

Die einfache if-Abfrage entscheidet nur, ob eine Bedingung erfüllt also TRUE ist. Soll auch darauf reagiert werden, was passiert, wenn die Bedingung nicht erfüllt ist, wird der if-Befehl um den Zusatz else erweitert.

switch / Case – mehr Optionen haben

Die switch / case-Anweisung ist eine komtortable Ergänzung zur if…else Abfrage. Mit ihr können Abfragen auf einfache Art und Weise noch weiter verzweigt werden. Sie wird verwendet, wenn mehrere Optionen vorhanden sind, die ausgewertet werden sollen. Die Switch / Case Anweisung vergleicht den Wert einer Variablen und führt bei einer Übereinstimmung den entsprechende Case-Block aus. Abgeschlossen wird der case-Block mit der break-Anweisung. Das ist unbedingt notwendig. Ergab keiner der durchgeführten Vergleiche eine Übereinstimmung, können Sie mit der default-Anweisung festlegen, wie standardmäßig darauf reagiert werden soll. Die default Anweisung ist nicht zwingend anzugeben, es ist jedoch von Vorteil es doch zu tun.

Struktur der switch / case Anweisung

Code-Beispiel

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
int note = 3;
 
switch (note)
        {
 
        case 1:
 
            Serial.print("sehr gut");
 
        break;
 
        case 2:
 
            Serial.print("gut");
 
       break;
 
        }
 
       case 3:
 
            Serial.print("befriedigend");
 
       break;
 
        }
       case 4:
 
            Serial.print("ausreichend");
 
      break;
 
        }
     case 5:
 
            Serial.print("unbefriedigend");
 
     break;
 
        }
     case 6:
 
            Serial.print("mangelhaft");
 
     break;
 
	}
     default:
 
            Serial.print("nicht feststellbar");
 
     break;
 
        }
}

Was passiert?

Allgemeines über Schleifen

Schleifen werden verwendet, wenn Anweisungen wiederholt abgearbeitet werden sollen. Alle Schleifen, die die Arduino Programmiersprache verwendet, prüfen ähnlich wie bei einer if-Abfrage, ob eine Bedingung erfüllt ist. Der große Unterschied ist jedoch, dass bei erfüllter Bedingung, alle Anweisungen, die sich innerhalb des sogenannten Schleifenkörpers, befinden durchlaufen werden. Das wiederholt sich solange, bis das Ergebnis der Prüfung FALSE ist. Dann wird die Schleife verlassen und nicht weiter ausgeführt. Die Auswahl des Schleifentyps richtet sich nach dem Anwendungsfall. Schleifen können zum vorwärts- oder rückwärts zählen oder zum schrittweisen zählen verwendet werden.
Es gibt Schleifen, die eine definierte Anzahl von Schleifendurchläufen ausführen. Zum Zählen wird dann eine Variable verwendet. Andere Schleifenarten können beliebig viele Schleifendurchläufe absolvieren. Schleifen bestehen, wie in der Abbildung zu erkennen ist aus einem Schleifenkopf dem Schleifenkörper und einem Schleifenfuß.

Grundstruktur einer Schleife

Grundstruktur einer Schleife

Schleifen werden verwendet, wenn Anweisungen wiederholt abgearbeitet werden sollen. Alle Schleifen, die die Arduino Programmiersprache verwendet, prüfen ähnlich wie bei einer if-Abfrage, ob eine Bedingung erfüllt ist. Der große Unterschied ist jedoch, dass bei erfüllter Bedingung, alle Anweisungen, die sich innerhalb des befinden, immer wieder durchlaufen werden. Der Teil der ständig wiederholt wird, wird auch Schleifenkörper genannt. Das geschieht solange, bis das Ergebnis der Prüfung FALSE ist. Dann wird die Schleife verlassen und nicht weiter ausgeführt. Die Auswahl des Schleifentyps richtet sich nach dem Anwendungsfall. Schleifen können zum vorwärts- oder rückwärtszählen oder zum schrittweisen zählen verwendet werden.
Es gibt Schleifen, die eine definierte Anzahl von Schleifendurchläufen ausführen. Zum Zählen wird dann eine Variable verwendet. Andere Schleifenarten können aber auch andere, die beliebig viele Schleifendurchläufe absolvieren können.

for Schleife

Der for-Befehl wird verwendet um Anweisungen für eine bekannten Anzahl von Durchläufen zu wiederholen.
Wie oft dieser Block durchlaufen wird, legen Sie mit einem Zähler fest. Der ist nichts anderes als eine Variable, die am einfachsten inkrementiert (erhöht) oder dekrementiert (erniedrigt) wird.
Der Kopf der for-Anweisung besteht aus drei Teilen, die wie alle anderen Anweisungen auch, durch ein Semikolon getrennt werden:

Aufbau der for-Schleife

Initialisierung

An dieser Stelle wird eine Variable initialisiert wird. Sie fungiert später als Zähler.

Bedingung

Die Schleife überprüft die Bedingung vor dem Eintritt in die Schleife.
Bei jedem Durchlauf wird geprüft, ob die die Bedigung erfüllt ist. Ist die Bedingung erfüllt wird die Schleife weiter ausgeführt.
Ist sie FASLE wird die Schleife verlassen.

Ausdruck

Dieser Teil beinhaltet den Ausdruck, der als Ergebnis einen erhöhten oder verringerten Wert ausgibt. Es ist dieselbe Variable, im ersten Teil des Schleifenkopfs initialisiert wurde. Sie kann z. B. über einen Inkrement- oder Dekrementoperator die Variable erhöht oder erniedrigt werden.

Flussdiagramm while Schleife

Arduino for Schleife

Einfache for Schleife

Code-Beispiel

1
2
3
4
5
for (int i = 0 ; i < 6; i++ )
{ 
Serial.println(i); 
// Hier können auch weitere Anweisungen folgen
}

Ausgabe serieller Monitor

Serial Monitor Arduino piece #8
Serial Monitor Arduino piece #7
Serial Monitor Arduino piece #6
Serial Monitor Arduino piece #5
Serial Monitor Arduino piece #4
Serial Monitor Arduino piece #3
0
1
2
3
4
5

Was passiert?

Im diesem Beispiel startet die Zählvariable i mit einem Wert von 0 und erhöht sich bei jedem Durchlauf um 1, solange der i < 6 wahr (TRUE) ist. Erreicht i einen Wert von 6 ändert der Ausdruck i< 6 seinen Wert. Er wechselt von TRUE auf FALSE, da die Bedingung nun nicht mehr erfüllt ist. Die Befehle innerhalb der Schleife werden nun nicht mehr bearbeitet. Die Schleife wird verlassen.

For-Schleifen können vorwärts, rückwärts oder auch in Schritten zählen:

Rückwärts zählende for Schleife

Code-Beispiel

1
2
3
4
5
6
for (int i = 6; i > 0; i--)
{ 
Serial.println(i); 
// Hier können auch weitere Anweisungen folgen
} 
}

Ausgabe serieller Monitor

Serial Monitor Arduino piece #8
Serial Monitor Arduino piece #7
Serial Monitor Arduino piece #6
Serial Monitor Arduino piece #5
Serial Monitor Arduino piece #4
Serial Monitor Arduino piece #3
6
5
4
3
2
1

Was passiert?

Im diesem Beispiel startet die Zählvariable i mit einem Wert von 6 und erniedrigt sich bei jedem Durchlauf um 1, solange die Bedingung i > 0 wahr (TRUE) ist. Erreicht i einen Wert von kleiner 0 ändert der Ausdruck i > 0 seinen Wert. Er wechselt von TRUE auf FALSE, da die Bedingung nun nicht mehr erfüllt ist. Die Befehle innerhalb der Schleife werden nun nicht mehr bearbeitet. Die Schleife wird verlassen.

Schrittweise zählende for-Schleife

Code-Beispiel

1
2
3
4
for (int ungerade = 1; ungerade < 11; ungerade = ungerade + 2)
{
Serial.println(ungerade);
}

Ausgabe serieller Monitor

Serial Monitor Arduino piece #8
Serial Monitor Arduino piece #7
Serial Monitor Arduino piece #6
Serial Monitor Arduino piece #5
Serial Monitor Arduino piece #4
Serial Monitor Arduino piece #3
1
3
5
7
9

Was passiert?

Im diesem Beispiel startet die Zählvariable i mit einem Wert von 1 und erhöht sich bei jedem Durchlauf um 2, solange bis die Bedingung i < 11 wahr (TRUE) ist. Wird i größer 11 ändert der Ausdruck i < 11 seinen Wert. Er wechselt von TRUE auf FALSE, da die Bedingung nun nicht mehr erfüllt ist. Die Befehle innerhalb der Schleife werden nun nicht mehr bearbeitet. Die Schleife wird verlassen.