In dieser dritten Lektion sehen wir, wie man Variablen in Arduino verwendet. Die Variablen diesen dazu, Informationen zu speichern.
Variablentyp
Die Daten, die wir in den Variablen speichern, können verschiedener Art sein. Im Folgenden führen wir einige von ihnen auf. Eine vollständige Auflistung der verschiedenen Variablentypen finden sich auf dieser Seite.
- char, sie werden verwendet, um Zeichen zu speichern und belegen 1 Byte.
- byte, sie können eine Zahl zwischen 0 und 255 speichern.
- int, belegt 2 Bytes (16 Bit) und speichert daher eine Zahl zwischen 2-15 und 215-1, das heißt zwischen -32,768 und 32,767.
- unsigned int, belegt ebenfalls 2 Byte, aber da es vorzeichenlos ist, können Werte zwischen 0 und 216-1 angenommen werden, das heißt zwischen 0 und 65,535.
- long, belegt 32 Bit (4 Byte), von -2,147,483,648 bis 2,147,483,647.
- unsigned long.
- float, Dezimalzahlen, die 32 Bit belegen (4 Byte). Sie können Werte zwischen -3.4028235E+38 und +3.4028235E+38 annehmen.
- double, speichert ebenfalls Dezimalzahlen, belegt aber 8 Bytes (64 Bit).
Immer wenn wir einen Datentyp auswählen, müssen wir uns für denjenigen entscheiden, der am wenigsten Speicherplatz benötigt aber gleichzeitig unsere Bedürfnisse erfüllt, da er sozusagen Speicherplatz von unserer Platine wegnimmt. Sonst könnte es passieren, dass unser Programm mehr Speicherplatz benötigt als verfügbar ist. Aber wie erstellen wir Variablen in unserem Code? Das ist sehr einfach: Wir geben den Typ und den Namen der Variablen an. Darüber hinaus können wir entscheiden, ob wir sie mit einem Anfangswert ausstatten oder nicht. Sehen wir uns ein Beispiel an:
|
1 2 3 4 5 |
char miCaracter='a'; //wir bestimmen eine Varibale des Typs char, mit dem Namen "miCarcater" und initialisieren sie mit Wert a byte unNumero = 189; // Variable des Typs Byte, initialisiert bei 189 int unEntero; //Variable des Typs int, nicht initialisiert unsigned int numeroPositivo = 2343; //initialisierte positive ganze Zahl float numDecimal = 12.212; //bei 12,212 initialisierte Dezimalzahl |
Es gibt einen weiteren wichtigen Datentyp, den String. Er kann Textketten speichern und ist besonders dann sehr wichtig, wenn Text über die serielle Schnittstelle gesendet wird. Er erlaubt es uns, ausgehend von Nummern, anderen Variablen oder verketteten Variablen, Ketten zu erstellen. Sehen wir uns ein paar Beispiele an (auf dieser Seite):
|
1 2 3 4 5 |
String stringOne = "Hello String"; // eine String-Konstante wird verwendet String stringOne = String('a'); // ein konstanter Char wird in einen String umgewandelt String stringTwo = String("This is a string"); // ein konstanter String wird in ein String-Objekt umgewandelt String stringOne = String(stringTwo + " with more");// zwei Strings werden verkettet String stringOne = String(13); // eine Integer-Konstante wird verwendet |
Es gibt noch einen wichtigen Datentyp, der Array genannt wird. Es handelt sich um eine geordnete Gruppierung von einem bestimmten Datentyp. Aber dazu später mehr… immer der Reihe nach. Wir erstellen ein Beispielprogramm, das zwei ganze Zahlen addiert und das Ergebnis über die serielle Schnittstelle ausgibt:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
int a = 5; //Variable a ist eine ganze Zahl, initialisiert bei 5 int b = 6; //Variable b ist eine ganze Zahl, initialisiert bei 6 int c = a + b; //Variable c ist eine ganze Zahl, initialisiert bei 11. void setup() { // initialize Serial Serial.begin(9600); // baudrate 9600 Serial.print("a + b equals "); Serial.println(String(c)); } void loop() { } |
Bei diesem Programm haben wir alles in die Funktion setup geschrieben, da wir ja wollen, dass sie nur ein einziges Mal ausgeführt wird. Welche dieser drei Möglichkeiten wird deiner Meinung nach über die serielle Schnittstelle geschrieben?
- a + b ist gleich c
- 5 + 6 ist gleich 11
- a + b ist gleich 11
Du wirst es selber ausprobieren müssen, um zu wissen, ob du richtig liegst.
Variablenbereich
Dies erklären wir dir anhand von ein paar Beispielen.
Globaler Gültigkeitsbereich
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
int a= 5; void setup() { // initialize Serial Serial.begin(9600); // baudrate 9600 Serial.println(String(a)); Serial.println("fin setup"); } void loop() { a = a + 1; Serial.println(String(a)); delay(1000); } |
Wir bezeichnen die Variable a als global, da wir von allen Seiten Zugriff auf sie haben. Das heißt, wir können sowohl von der Funktion setup als auch von loop auf ihren Wert zugreifen. Über die serielle Schnittstelle würden wir Folgendes erhalten: 
Lokaler Gültigkeitsbereich
Dies sind Variablen, die nur in dem Gültigkeitsbereich existieren, indem sie erstellt wurden. Zum schnelleren Verständnis, ein Gültigkeitsbereich ist das, was wir in geschweiften Klammern finden. Verwenden wir sie außerhalb ihres Gültigkeitsbereichs, tritt ein Kompilierungsfehler auf. Da sie nur innerhalb ihres Bereiches exisitieren, könnte mein Programm den gleichen Variablennamen in verschiedenen Bereichen verwenden. Sehen wir uns ein paar Beispiele an, um dies genauer zu erklären:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
void setup() { int a= 5; //die Variable a existiert nur in der Funktion setup // Serial initialisieren Serial.begin(9600); // Baudrate 9600 Serial.println(String(a)); Serial.println("fin setup"); } void loop() { //beim Kompilieren tritt ein Fehler auf, da a nicht in loop existiert a = a + 1; Serial.println(String(a)); delay(1000); } |
Beim Kompilieren dieses Programms erhalten wir einen Code-Fehler, denn die Variable int a stammt aus dem lokalen Gültigkeitsbereich und es gibt sie nur in der Funktion setup. Daher können wir sie nicht in der Funktion loop verwenden. Was würde mit diesem Code passieren?
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
void setup() { int a = 5; //die Variable a existiert nur in der Funktion setup // Serial initialisieren Serial.begin(9600); // Baudrate 9600 Serial.println(String(a)); Serial.println("fin setup"); } void loop() { int a = 0; a = a + 1; Serial.println(String(a)); delay(1000); } |
Kompiliert er? Ja, denn a wurde sowohl in der Funktion loop als auch in der Funktion setup erstellt. Was würde auf den seriellen Monitor geschrieben werden?
|
1 2 3 4 5 |
5 fin setup 1 1 1 |
Bestimmt hast du gedacht, dass 1 2 3 4 erscheinen würde, oder? Das hätte wahrscheinlich jeder erwartet. Warum ist das nicht der Fall? Es liegt daran, dass die Variable a der Funktion Loop in jeder Iteration neu erstellt und zerstört wird. Daher beginnt sie immer bei 0 und es kommt 1 dazu… Daher entspricht sie in der Funktion loop immer 1. Und die anderen Programme? Mal sehen ob du darauf kommst. Erstelle sie selbst, um das Ergebnis zu überprüfen.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
int a = 0; void setup() { int a = 5; //die Variable a existiert nur in der Funktion setup // Serial initialisieren Serial.begin(9600); // Baudrate 9600 Serial.println(String(a)); Serial.println("fin setup"); } void loop() { a = a + 1; Serial.println(String(a)); delay(1000); } |
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
int a = 0; void setup() { int a = 5; a = a + 1; // initialize Serial Serial.begin(9600); // baudrate 9600 Serial.println(String(a)); Serial.println("fin setup"); } void loop() { a = a + 1; Serial.println(String(a)); delay(1000); } |
Wenn du dich traust, trage in den Kommentaren ein, was dabei herauskommen müsste (bevor du es überprüfst). Mal sehen ob du richtig liegst 
