Eine while-Schleife wiederholt den Code innerhalb der geschweiften Klammern bis die Bedingung in den runden Klammern nicht mehr wahr ist bzw. nicht mehr zutrifft. Der Wert muss geändert werden, sei es innerhalb der Schleife durch eine Variable die inkrementiert wird oder durch den Druck eines Tasters, um die Schleife zu verlassen.
Syntax
eine Bedingung die entweder wahr oder falsch sein kann
Beispiel
Die do-Schleife verhält sich genau wie die while-Schleife, nur, dass die Bedingung immer am Ende der Schleife geprüft wird. Das bedeutet, dass die Schleife immer mindestens einmal durchlaufen wird.
Syntax
break wird benutzt, um eine do, for oder while-Schleife zu verlassen, ohne dass die Bedingung zum Schleifenabbruch erfüllt ist.
for (x = 0; x < 255; x ++) {
digitalWrite(PWMpin, x);
sens = analogRead(sensorPin);
39 if (sens > Grenzwert) { // verlasse Schleife, wenn der Sensor einen größeren Wert
// als den Grenzwert liefert
Die Anweisung continue springt ans Ende der aktuellen Schleifenanweisungen (do, for oder while
Schleife). Die Schleife setzt mit der Prüfung der Schleifenbedingung fort und führt entsprechend der Schleife die nächste Iteration aus.
for (x = 0; x < 255; x++)
Beendet eine Funktion und gibt der aufrufenden Funktion einen Wert zurück, wenn dies gewünscht ist.
Syntax
return;
return wert; // beide Formen sind korrekt
Parameter
wert: beliebige Variable oder Konstante
Beispiel
Eine Funktion, die den Sensorwert mit einem Grenzwert vergleicht
int checkSensor(){
Es gibt auch die Möglichkeit, bei nur einer Anweisung hinter if oder else, diese verkürzt so zu schreiben:
int checkSensor(){
if (analogRead(0) > 400) return 1;
else return 0;
}
goto
Leitet den Programmfluss zu einer bestimmten Sektion im Programmcode, welcher im Label definiert ist.
Syntax
goto label; // leitet den Programmfluss zur Sektion "label"
label:
// hier weitere Anweisungen
Hinweis
Die Benutzung des goto-Befehls ist unter C-Programmierern verpönt, da man einen undefinierten Programmfluss erzeugen kann, welcher sich nicht debuggen lässt.
Dennoch kann der goto-Befehl in manchen Situationen sehr nützlich sein, z.B. um aus stark verzweigten for-Schleifen auszusteigen.
Beispiel
for(byte r = 0; r < 255; r++){
for(byte g = 255; g > -1; g--){
for(byte b = 0; b < 255; b++){
if (analogRead(0) > 250){ goto ausstieg;}
// weitere Anweisungen }
} }
ausstieg:
41
Rechenoperationen
= Zuweisungsoperator
Speichert den Wert rechts des = in die Variable links des =.
Das =-Zeichen in der Programmiersprache C heißt Zuweisungsoperator. Das = funktioniert ähnlich wie man es aus dem Matheunterricht kennt. Die linke Seite ist gleich der rechten Seite. Allerdings funktioniert das nur in diese Richtung!
Beispiel
// Ein kleiner Tipp:
int a = 10; // funktioniert, schreibt den Wert 10 in die Variable a
5 = a; // funktioniert nicht, da 5 nicht der Wert aus a zugewiesen werden kann, //da 5 bereits selber ein Wert ist
// Deklaration und Wertzuweisung getrennt int sensVal;
sensVal = analogRead(0);
// Deklaration mit sofortiger Wertezuweisung int sensVal = analogRead(0);
Hinweis
Die Variable auf der linken Seite des Zuweisungsoperators muss groß genug sein, um den zugewiesenen Wert zu speichern, andernfalls ist der gespeicherte Wert inkorrekt. Der Wert 1023 (10-bit groß) kann also nicht in eine byte-Variable (8-bit groß) gespeichert werden.
= (einfaches =) und == (doppeltes =) dürfen nicht verwechselt werden, da = der Zuweisungsoperator, zum Zuweisen eines Wertes, und == der Vergleichsoperator ist, welcher prüft, ob zwei Werte gleich groß sind.
Grundrechenarten (Addition, Subtraktion, Division, Multiplikation)
Die Rechenoperatoren ermöglichen alle Grundrechenarten. Die Operatoren geben die Summe, die Differenz, das Produkt oder den Quotienten der Faktoren rechts und links der Operatoren zurück. Das Ergebnis hängt maßgeblich vom Datentypen der gewählten Variablen ab.
Ein kleines Beispiel:
int ergebnis = 9 / 4 schreibt den Wert 2 in die Variable ergebnis, obwohl der Quotient beider Zahlen ja eigentlich 2,25 ist, da der Datentyp int nur ganzzahlige Werte aufnehmen kann. Der Rest 0.25 wird einfach “abgeschnitten”, weil er hinter dem Komma steht. Nur Variablen des Typs float oder double
können Dezimalbrüche (Zahlen mit Nachkommastellen) aufnehmen.
Syntax
ergebnis = Faktor1 + Faktor2;
ergebnis = Faktor1 - Faktor2;
ergebnis = Faktor1 * Faktor2;
ergebnis = Faktor1 / Faktor2;
Parameter
Faktor1: Eine Variable beliebigen Datentyps Faktor2: Eine Variable beliebigen Datentyps
Beispiel
w = w + 3;
x = x - 7;
y = y * 6;
z = z / 5;
% Modulo
Der Modulo Operator gibt den Rest einer Division zweier ganzzahligen Faktoren zurück.
Zu kompliziert? Also ein kleines Beispiel:
9 / 2 ergibt 4,5. Wenn wir diesen Wert allerdings in eine int-Variable schreiben, nimmt die Variable den Wert 4 an, da der Nachkommawert einfach abgeschnitten wird.
Der Modulo Operator gibt nun den Rest der Division zurück:
9 % 2 ergibt 1. Wieso?
Besser zu verstehen ist das, wenn wir uns einmal das Konzept des schriftlichen Dividierens in der 3.
Klasse anschauen. Wir schauen, wie oft die 2 in die 9 hineinpasst. Die 2 passt 4-mal in die 9, denn 4*2 = 8 Rest 1. Das Modulo gibt uns diesen Rest zurück.
Der Vollständigkeit halber mache ich hier nun weiter: wir setzen ein Komma hinter die 4 und zu der 1 ziehen wir eine 0 hinunter. Jetzt fragen wir uns, wie oft passt die 2 in die 10 hinein? Klar, 5-mal. Hinter die 4, schreiben wir jetzt also eine 5 und wir bekommen 4,5.
Syntax
ergebnis = dividend % divisor
Parameter
dividend: die zu teilende Zahl divisor: der Teiler
Beispiel
x = 7 % 5; // x enthält 2 x = 9 % 5; // x enthält 4 x = 5 % 5; // x enthält 0 x = 4 % 5; // x enthält 4
Hinweis
Der Modulo Operator funktioniert logischerweise nicht mit floats. (Fließkommazahlen)
43
Verknüpfungsoperationen (Boolesche Operatoren)
Diese Operatoren können innerhalb einer if-Schleife benutzt werden, um z.B. zwei Bedingungen logisch zu verknüpfen.
&& (logisches und)
ist nur wahr, wenn beide Bedingungen erfüllt sind, z.B.
if (digitalRead(2) == HIGH && digitalRead(3) == HIGH) { // lese zwei Schalter aus
// ...
}
Prüft, ob beide Eingänge logisch HIGH sind.
|| (logisches oder)
ist wahr, wenn eine der beiden Bedingungen wahr ist, z.B.
if(x > 0 || y > 0){
// ...
}
Ist wahr, wenn x oder y größer 0 ist.
! (nicht)
wahr wenn die Bedingung nicht wahr ist, z.B.
if(!(x==3)){
// ...
}
ist wahr, wenn x nicht gleich 3 ist.
Hinweis
Beachte, dass das logische UND ein „&&“ ist und das bitweise UND ein „&“ ist, denn die beiden sind komplett verschieden! Auch haben das logische ODER ( || ) und das bitweise ODER ( | ) unterschiedliche Funktionen. Das bitweise NICHT ~ sieht zwar anders aus als das logische NICHT !, aber man sollte sich doch im Klaren sein, welches wo verwendet wird.
if (a >= 10 && a <= 20){} // ist wahr wenn a zwischen 10 und 20 liegt