Kommentare
 

in
Quelltexten

Kommentare im Quelltext helfen Anderen das Programm besser zu verstehen und Ihnen auch nach Jahren sich wieder zu Recht zu finden.

Quelltext ist der Text den Sie schreiben, dieser muss noch kompiliert werden, damit er vom ARDUINO in für ihn „lesbarer“ Form vorliegt. Bei der Kompilierung (das ist die Übersetzung des Quelltextes in eine Maschinensprache) werden Kommentare des Quelltextes fortgelassen und vergeuden somit keinen wertvollen Speicherplatz.

Befehle in Schwarz und fett,

alles Andere grau

Erklärungen

\\ einzeiliger Kommentar

hinter // können beliebige Zeichen als Kommentar folgen

\*
    mehrzeiliger
    Kommentar
    beliebiger Länge
*\

zwischen /* und */ kann ein mehrzeiliger Kommentar stehen.

Beachte am Anfang und nach dem Ende des Kommentars auf die jeweilige Reihenfolge der Befehlszeichen Backslash und Sternchen!

\*******************************

etwas deutlich hervorheben

********************************\

Zwischen /******** und ********/ kann ein Kommentar stehen.

Um lediglich einen Programmabschnitt vom folgenden zu kennzeichnen (ohne Kommentar dazwischen) genügt auch /**********************/

Steuerzeichen

Zeichen, welche eine grundsätzliche Rolle spielen

Befehle
in Schwarz und fett,

alles Andere grau

Erklärungen

(   )

„( )“ runde Klammern

{   }

„{ }„ geschweifte Klammern
Steuerzeichen für den Compiler (das ist ein Interpreter, der den Quelltext interpretiert, um in dann korrekt in eine Maschinensprache übersetzen zu können), dass ein Codeblock folgt. Innerhalb der geschweiften Klammern stehen Anweisungen.

;

„;“ Semikolon (=Strichpunkt)
wird verwendet, um Befehle abzuschließen; mit anderen Worten „Befehl-Ende“ für den Compiler.

,

„,“ Komma
oft innerhalb von Befehlen (siehe und beachte unter Befehle),

.

„.“ Punkt
oft innerhalb von Befehlen (siehe und beachte unter Befehle),
sowie als Dezimalpunkt bei Zahlen (statt Komma verwenden!)

Variablen-Typen

Zur Definition von Variabeln

Befehle in Schwarz und fett,

alles Andere grau

Erklärungen

boolean
z.B.:
boolean X = true;
oder:
boolean Meinung = false;

kann nur zwei Zustände annehmen: true (wahr) und false (falsch)
true ist gleichbedeutend mit dem Wert 1
false ist gleichbedeutend mit !=1, d.h. „nicht 1“, und nicht zwingend 0 (Null), wie oft fälschlicher Weise angenommen wird.
Benötigter Speicherplatz: 1 Byte

byte
z.B.: byte x = 128;

eine so definierte Variable kann Werte von 0 bis 255 aufnehmen.
Speicherbelegung: 1 Byte = 8 Bit => 2⁸=256 => Wertebereich = {0 bis 255}

char

z.B.:
char Buchstabe = ’A’;
char Wort = “HALLO“;

Eine so definierte Variable speichert den ASCII-Code von Zeichen.
Ein Charakter ist 1 Byte groß.
Charaktere können Werte zwischen -127 und +127 aufnehmen.
Zuweisung eines einzelnen Zeichens wird in Hochkomme gesetzt.
Zuweisung mehrerer Zeichen erfolgt in Anführungszeichen.
Z. B. hat `’A’ den ASCII-Code 65

unsigned char

unsigned = unsigniert,
also ohne Vorzeichen,
d. h. nur pos. Werte!

Eine so definierte Variable speichert den ASCII-Code von Zeichen.
Ein Charakter ist 1 Byte groß.
Charaktere können Werte zwischen 0 und 255 aufnehmen.
Zuweisung eines einzelnen Zeichens wird in Hochkomme gesetzt.
Zuweisung mehrerer Zeichen erfolgt in Anführungszeichen.
Z. B. hat `’A’ den ASCII-Code 65

int
z. B.:
int x = -12;
int y =  12;

Integer = „Ganzzahl“.
Variablen können Werte von -32768 bis +32768 aufnehmen.
Speicherbelegung: 2 Byte = 16 Bit => 2¹⁶=65536 =>
Wertebereich = {-32768 bis +32768}

unsigned int
z. B.:
int y = 12;

unsignierte „Ganzzahl“, ohne Vorzeichen => nur positive ganze Zahlen.
Variablen können Werte von 0 bis +65535 aufnehmen.
Speicherbelegung: 2 Byte = 16 Bit => 2¹⁶=65536 =>
Wertebereich = {0 bis 65535}

long
z. B.:
long x = -2000000000;
long y =  2000000000;

long = lang
Variablen können Werte von -2.147.483.648 bis +2.147.483.648 aufnehmen.
Speicherbelegung: 4 Byte = 16 Bit => 2³²=4.294.967.296 =>
Wertebereich = {-2147483648 bis +2147483648}

unsigned long
z. B.:
long y =  4000000000;

unsigned = unsigniert (ohne Vorzeichen)
Variablen können nur positive Werte von 0 bis + 4.294.967.295 aufnehmen (4294967295 = 4,294967295*10⁹ = 2³²-1).
Speicherbelegung: 4 Byte = 16 Bit => 2³²=4.294.967.296 =>
Wertebereich = {0 bis 4294967295}

float
z. B.:
float x = -60000.75;
float y =..60000.75;

Flat = „Fließkommazahl“.
Variablen können Werte 32 Bit und Vorzeichen speichern.
Wertebereich von –3,4028235*10³⁸ bis +3,4028235*10³⁸.
Speicherbelegung: 4 Byte.

Typenumwandlung

Wandelt den Typ einer definierten Variablen in einen anderen Typ um.

Befehle in Schwarz und fett,

alles Andere grau

Erklärungen

Byte()

Wandelt einen Wert in ein Byte um

Char()

Wandelt einen Wert in einen Charakter um

Int()

Wandelt einen Wert in ein Integer um

Long()

Wandelt einen Wert in eine Long um

Float()

Wandelt einen Wert in eine Float um

Operatoren

Je nach Datentyp stehen Operatoren zur Verfügung.
Diese werden nachfolgend für den ARDUINO aufgelistet.

Operatoren

Arithmetik

Befehle in Schwarz und fett,

alles Andere grau

Erklärungen

=
i = 1 + 1;

Zuweisung eines Ergebnisses.
i ergibt sich aus i+1; i wird also um 1 erhöht, z. B. bei for-Schleifen

+

Addition

-

Subtraktion

*

Multiplikation

/

Division

%

Modulo – Rest.
........a modulo b = [a/b-(integer a/b)]*2
Z.B.: 7 modulo 2 = [7/2-(integer 7/2)]*2 = [3,5 – 3]*2 = 0,5*2 = 1

Operatoren

Vergleiche

Befehle in Schwarz und fett,

alles Andere grau

Erklärungen

==

gleich, identisch (Beispiel: A == B)

!=

Ungleich (Beispiel: A != B)

<

Kleiner (Beispiel: A < B)

>

größer (Beispiel: A > B)

<=

Kleiner oder gleich (Beispiel: A <= B)

>=

Größer oder gleich (Beispiel: A >= B)

Operatoren

Bitweise Arithmetik

Befehle in Schwarz und fett,

alles Andere grau

Erklärungen

&

UND (=AND) bitweise (Beispiel: 01& 01 = 10)

|

ODER (=OR) bitweise (Beispiel: 01 | 10 = 11)

~

NICHT (NOT) bitweise (Beispiel: ~ 01 = 10)

Operatoren

Boolsche Arithmetik

Befehle in Schwarz und fett,

alles Andere grau

Erklärungen

&&

UND bei Ausdrücken Beispiel: if A && B = true {….}

||

ODER bei Ausdrücken Beispiel: if A || B = true {….}

!

NICHT bei Ausdrücken Beispiel: if A ! B = true {….}

Operatoren

Inkrement (=“erhöhen“) und Dekrement („vermindern“)

Befehle in Schwarz und fett,

alles Andere grau

Erklärungen

++

Inkrementieren; Beispiel: i++; in Worten: i ergibt sich aus i+1

--

Dekrementieren; Beispiel: i--; in Worten: i ergibt sich aus i-1

+=

Inkrement; Beispiel: i += 8; in Worten; i ergibt sich aus i+8

-=

Dekrement; Beispiel: i -= 8; in Worten; i ergibt sich aus i-8

*=

Multiplikation; Beispiel: i *= 2; in Worten; i ergibt sich aus i*2

/=

Division; Beispiel: i /= 2; in Worten; i ergibt sich aus i/2

Operatoren

Konstanten

Befehle in Schwarz und fett,

alles Andere grau

 Erklärungen

HIGH

HIGH = 1

LOW

LOW = 0

true

true = 1

false

false = nicht 1 , also !=1 (kann alles Andere nur nicht 1 sein)

INPUT

INPUT =0

OUTPUT

OUTPUT = 1

String [ ]

String = Zeichenkette, beinhaltet eine Zusammensetzung von Zeichen.
Ein einzelnes Zeichen benötigt 1 Byte.
Ein String, bestehend aus n Zeichen, benötigt n Byte + 1 Byte zur Terminierung.

Befehle in Schwarz und fett,

alles Andere grau

 


Erklärungen

Var.Def. Var.Name [ ] = “ “;
 

z. B.:
char Satz[ ] = “Hallo Welt”;

Nach Variablen-Definition und Variablen-Name wird ein String durch [ ] gekennzeichnet, durch = folgt die Zuweisung des Wertes.
Nicht vergessen den Befehl mit Semikolon abschließen.
Für „Hallo Welt“ werden 11 Byte benötigt: 10 Byte für die Zeichen (ein Leerzeichen ist auch ein Zeichen!) + 1 Byte zur Terminierung!
Im links stehenden Beispiel ist „char“ die Variablen-Definition und „Satz“ der Variablen-Name; der zugewiesene Wert ist „Hallo Welt“

Array

Array = Feld
Im Allgemeinen versteht man in der Informatik unter einem Array eine indizierte Datenstruktur, welche auch mehrdimensional sein kann.
Darauf wollen wir nicht in aller Einzelheit eingehen und uns nur auf das beschränken, was der ARDUINO beherrscht:
Arrays müssen als Datentyp integer deklariert werden.
Der Index startet mit 0.
Nur 1-dimensionale Indizierung ist möglich (Stand 2016)

Befehle in Schwarz und fett,

alles Andere grau

Erklärungen

z. B.:
int Array_1[3];
int Array_2[ ] = {1,2,3};

Array-Feld:
Index_0 , Index_1, …, Index_i, … , Index_n (indiziert von i=0 bis n.
(Nähere Einzelheiten siehe unter Beispiele)

Kontrollstrukturen

Im Allgemeinen handelt es sich hier um Abfragen oder Bedingungen, welche je Erfüllungsstand (erfüllt oder nicht erfüllt) ein Programm verzweigungen.

Befehle in Schwarz und fett,

alles Andere grau

 


Erklärungen

if(Bedingung)
{
Ausführungsanweisungen
}

If (=falls);
Hinter if folgt in runden Klammern eine Bedingung und danach in geschweiften Klammern Aneisungen, welche nur dann ausgeführt werden, wenn die Bedingung erfüllt ist. Ansonsten wird nach der schließenden geschweiften Klammer fortgefahren.

else if

if (Bedingung)
{
Ausführungsanweisungen
}
else if (Bedingung)
{
Ausführungsanweisungen
}

else(=sonst) if(=fals); dabei kann else if mehrfach folgen!

Wenn die Bedingung erfüllt (wahr, true) ist,

dann führe diese Anweisungen durch,

sonst überprüfe diese Bedingung,

und führe diese Anweisungen aus.

Wenn nichts zutrifft, mache nach der geschweiften Klammer weiter.

switch case

switch(x)
{
case 1:
Ausführungsanweisungen 1
case 2:
Ausführungsanweisungen 2
}

Switch (=Schalter, case (=Fall). Bedeutet: wenn ein Schalter x gesetzt ist, dann führe Fall x aus

 

Bei x=1 wird case 1 ausgeführt;

Bei X=2 wird case 2 ausgeführt.

Ist x weder 1 noch 2, wird nichts ausgeführt.

Nach der geschweiften Klammer wird fortgesetzt.

Schleifen

Innerhalb einer Schleife wird ein Programmteil solange durchlaufen, wie eine zuvor definierte Start-/Stopp-Bedingung erfüllt wird.

Befehle in Schwarz und fett,

alles Andere grau

Erklärungen

for 

for(i=Start : i=Stop : i=i+d)
{
Ausführungsanweisungen
}

for (=für) 

für die Startbedingung i=Start (z.B. Start=0) und der Stoppbedingung i=Stop (z.B. Stop=9) erhöhe bei jedem Schleifendurchlauf i um d (ist d=1, so wird i jedes Mal um 1 erhöht (also i={0,1,2,3,4,5,6,7,8,9}) und damit die Ausführungsanweisungen innerhalb von der geschweiften Klammer 10 mal durchlaufen.
d muss nicht 1 sein; kann auch negativ sein (zähle rückwärts), dann muss natürlich Start > Stop sein.

while

while
{
Bedingung
Ausführungsanweisungen
}
while
{

}

whiel (=während)

diese Schleife wird erst durchlaufen und dann erst die Bedingung geprüft; ist diese erfüllt, wird die Schleife erneut durchlaufen, bis die Bedingung nicht mehr erfüllt ist. D. h. die Schleife wird auf jeden Fall mindestens einmal durchlaufen; aus diesem Grund kann der while-Befehl auch zur Ausführung von Endlosschleifen zur Anwendung kommen (man braucht dazu nur eine Bedingung stellen, die immer erfüllt ist; beispielsweise steht innerhalb der geschweiften Klammer nichts, so wird die while-Schleife endlos durchlaufen, denn keine Bedingung ist immer erfüllt!). Die Schleife kann mit break abgebrochen werden.

do while 

while
{
Bedingung
Ausführungsanweisungen
}
do
{
Bedingung
Ausführungsanweisungen
}

do while (=mache während)

wie while, nur wird hier vor Schleifenausführung die Bedingung geprüft.

Dabei kann do while auch mehrfach folgen!

Funktionen und Routinen

- machen ein Programm übersichtlicher.
- eigene Befehle können damit verwirklicht werden.
- Unterprogramme mit Rückgabewert, welche auch in anderen
  Projekten verfügbar sind (im Gegensatz zu Prozeduren, welche keinen
  Rückgabewert ermöglichen!).
- in einer Funktion können beispielsweise mathematische
  Berechnungen durchgeführt werden, deren Ergebnis an eine Über-
  gabevariablen zurückgegeben wird.

Eigene Funktionen:
-                     ein Block von Programmcodes, der einen Namen hat.
-                     enthaltene Anweisungen werden beim Funktionsaufruf ausgeführt.

Zuerst wird der Typ der Funktion definiert und muss identisch mit dem Datentyp des zurückzugebenden Wertes sein.
Danach wird der Name und in Klammern alle Parameter, welche der Funktion zu übergeben sind, festgelegt.

Befehle in Schwarz und fett,

alles Andere grau

Erklärungen

-------------------------------------

Auf Grund der Komplexität dieser Funktionen wird auf den Beispielteil verwiesen

continue

continue (= fortsetzen)
Diese Anweisung kommt innerhalb von Schleifen zum Einsatz.
Continue überspringt den nach dieser Anweisung stehenden Teil einer Schleife.

Befehle in Schwarz und fett,

alles Andere grau

Erklärungen

….
for (Anweisung)
{
if (Bedingung)
{
continue;
}
Anweisungen;
}

Prinzip-Beispiel:
Schleife 

Bedingung

Wenn Bedingung erfüllt, überspringe den Rest der Schleife,

ansonsten
fahre in der Schleife fort.