id
stringlengths 14
16
| text
stringlengths 10
1.45k
| source
stringlengths 46
118
|
|---|---|---|
684521bb7ad0-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Structure
> Bitwise operators
> Bitwisexor
^
[Bitwise Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitwisexor/index.html
|
684521bb7ad0-1
|
^
[Bitwise Operators]
Beschreibung
In C++ gibt es einen etwas ungewöhnlichen Operator namens bitweises exklusives OR, auch bitweises XOR genannt.
Der bitweise XOR-Operator wird mit dem Caret-Symbol ^ geschrieben.
Eine bitweise XOR-Operation führt nur dann zu einer 1, wenn die Eingangsbits unterschiedlich sind.
Andernfalls ergibt sich eine 0.
Precisely,
0 0 1 1 operand1
0 1 0 1 operand2
----------
0 1 1 0 (operand1 ^ operand2) - Ergebnis
Beispielcode
int x = 12; // Binär: 1100
int y = 10; // Binär: 1010
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitwisexor/index.html
|
684521bb7ad0-2
|
int y = 10; // Binär: 1010
int z = x ^ y; // Binär: 0110, oder dezimal 6
Der ^ -Operator wird häufig verwendet, um einige der Bits in einem ganzzahligen Ausdruck umzuschalten (d. H. Von 0 auf 1 oder von 1 auf 0 zu wechseln).
Wenn in einer bitweisen ODER-Operation eine 1 im Maskenbit vorhanden ist, wird dieses Bit invertiert.
Wenn es eine 0 gibt, wird das Bit nicht invertiert und bleibt gleich.
// Hinweis: Dieser Code verwendet Register, die für AVR-Mikrocontroller spezifisch sind (Uno, Nano, Leonardo, Mega usw.).
// Es wird für andere Architekturen nicht kompilieren
void setup() {
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitwisexor/index.html
|
684521bb7ad0-3
|
void setup() {
DDRB = DDRB | B00100000; // Setzen von PB5 (Pin 13 beim Uno / Nano, Pin 9 beim Leonardo / Micro, Pin 11 beim Mega) als OUTPUT
Serial.begin(9600);
}
void loop() {
PORTB = PORTB ^ B00100000; // PB5 invertieren, andere unberührt lassen
delay(100);
}
Siehe auch
BEISPIEL BitMath-Tutorial
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitwisexor/index.html
|
55248ac95917-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Structure
> Bitwise operators
> Bitwiseand
&
[Bitwise Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitwiseand/index.html
|
55248ac95917-1
|
&
[Bitwise Operators]
Beschreibung
Der bitweise AND-Operator in C ++ ist ein einzelnes kaufmännisches Und &, das zwischen zwei anderen Ganzzahlausdrücken verwendet wird.
Das Bitweise AND bearbeitet die Bitpositionen der umgebenden Ausdrücke unabhängig voneinander gemäß dieser Regel:
Wenn beide Eingangsbits 1 sind, ist das resultierende Ergebnis 1, andernfalls ist das Ergebnis 0.
Eine andere Möglichkeit, dies auszudrücken, ist:
0 0 1 1 operand1
0 1 0 1 operand2
----------
0 0 0 1 (operand1 & operand2) - Ergebnis
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitwiseand/index.html
|
55248ac95917-2
|
In Arduino ist der Typ int ein 16-Bit-Wert. Wenn & zwischen zwei int-Ausdrücken verwendet wird, werden 16 UND-Operationen gleichzeitig ausgeführt.
Beispielcode
In einem Codefragment wie:
int a = 92; // Binär: 0000000001011100
int b = 101; // Binär: 0000000001100101
int c = a & b; // Ergebnis: 0000000001000100, oder 68 dezimal.
Jedes der 16 Bits in a und b wird unter Verwendung des bitweisen AND verarbeitet, und alle 16 resultierenden Bits werden in c gespeichert.
Dies führt zu einem binären Wert von 01000100, der als Dezimalzahl 68 ist.
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitwiseand/index.html
|
55248ac95917-3
|
Eine der häufigsten Anwendungen von bitweisem AND ist die Auswahl eines bestimmten Bits (oder einiger Bits) aus einem Integer-Wert, der oft als Maskierung bezeichnet wird.
Unten findest du ein Beispiel (spezifisch für die AVR-Architektur).
PORTD = PORTD & B00000011; // Löschen der Bits 2 - 7 und Pins PD0 und PD1 (xx & 11 == xx) nicht ändern.
Siehe auch
SPRACHE && Logisches Und
BEISPIEL BitMath-Tutorial
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitwiseand/index.html
|
572ab122bacc-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Structure
> Control structure
> Break
break
[Control Structure]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/control-structure/break/index.html
|
572ab122bacc-1
|
> Break
break
[Control Structure]
Beschreibung
break wird benutzt, um aus for, while oder do…while-Schleifen zu springen, wobei
die normalen condition übersprungen werden. Es wird auch benutzt, um aus switch case-Statements zu springen.
Syntax
while (condition) {
//Statement(s)
break;
//Statement(s)
}
Parameter
Keine.
Rückgabewert
Nichts.
Beispielcode
Der folgende Code springt aus der for-Schleife, wenn der Sensorwert den Threshold übersteigt.
// Iteriere über die Zahlen von 0 bis 255
for (int x = 0; x < 255; x++) {
// Schreibe auf den LED-Pin
analogWrite(PWMpin, x);
|
https://www.arduino.cc/reference/de/language/structure/control-structure/break/index.html
|
572ab122bacc-2
|
analogWrite(PWMpin, x);
// Lies den Sensorwert ein
sens = analogRead(sensorPin);
// Wenn der Wert größer als der Threshold ist
if (sens > 40){
// Setze x auf 0
x = 0;
// Springe raus
break;
}
// Warte 50 Millisekunden
delay(50);
}
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/control-structure/break/index.html
|
c225d23dc6b7-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Structure
> Control structure
> If
if
[Control Structure]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/control-structure/if/index.html
|
c225d23dc6b7-1
|
> If
if
[Control Structure]
Beschreibung
Das if-Statement checkt, ob eine Bedingung true ist und führt dann den Code aus, der innerhalb der Klammern steht.
Syntax
if (condition) {
//statement(s)
}
Parameter
condition: Ein Booleanausdruck, kann true oder false sein.
Rückgabewert
Nichts.
Beispielcode
Die Klammern nach einem if-Statement können weggelassen werden. Wenn dies getan wird, wird die nächste Zeile die einzige, die nach der Bedingung
ausgeführt wird.
if (x > 120) digitalWrite(LEDpin, HIGH);
if (x > 120)
digitalWrite(LEDpin, HIGH);
if (x > 120) { digitalWrite(LEDpin, HIGH);}
|
https://www.arduino.cc/reference/de/language/structure/control-structure/if/index.html
|
c225d23dc6b7-2
|
if (x > 120) { digitalWrite(LEDpin, HIGH);}
if (x > 120) {
digitalWrite(LEDpin1, HIGH);
digitalWrite(LEDpin2, HIGH);
}
// Alle Anweisungen sind korrekt
Anmerkungen und Warnungen
Die Statements in der condition müssen dabei mindestens einen der Operatoren unten benutzen.
Vergleichsoperatoren:
x == y (x ist gleich y)
x != y (x ist nicht gleich y)
x < y (x ist kleiner als y)
x > y (x ist größer als y)
x <= y (x ist kleiner als oder gleich zu y)
x >= y (x ist größer als oder gleich zu y)
|
https://www.arduino.cc/reference/de/language/structure/control-structure/if/index.html
|
c225d23dc6b7-3
|
x >= y (x ist größer als oder gleich zu y)
Achtung: Nicht zufällig ein einzelnes =-Zeichen in der Bedingung verwenden (z.B. if (x = 10)). Ein einfaches =-Zeichen ist ein Zuweisungsoperator und setzt x auf 10.
Benutze stattdessen == (z.B. if (x == 10)). Dies vergleicht die Werte von x und der Konstante 10. Das 2. Beispiel wird nur true, wenn x genau gleich 10 ist, das
1. Statement wird immer true.
Das passiert, weil C++ wie folgt evaluiert: 10 wird auf x zugewiesen (= ist der Zuweisungsoperator), weshalb x nun den Wert 10
|
https://www.arduino.cc/reference/de/language/structure/control-structure/if/index.html
|
c225d23dc6b7-4
|
enthält. Daraufhin evaluiert die If-Bedingung zu 10. 10 ist immer true, da jede Zahl, die nicht 0 ist, immer true ist. Dies ist meistens nicht erwünscht, also bitte darauf achten.
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/control-structure/if/index.html
|
f963133cfaca-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Structure
> Control structure
> Else
else
[Control Structure]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/control-structure/else/index.html
|
f963133cfaca-1
|
> Else
else
[Control Structure]
Beschreibung
if…else erlaubt mehr Optionen als das einfache if. Es erlaubt, mehrere Variablen hintereinander abzufragen. Der else-Teil wird dann ausgeführt,
wenn die Bedingung im if-Teil false ist. Auf den else-Teil kann wieder ein if folgen, sodass viele sich gegenseitig ausschließende Konditionen gestestet werden können.
Dabei wird immer weiter fortgefahren, bis ein Test auf true evaluiert wird. Daraufhin wird dessen zugehöriger Code ausgeführt, woraufhin das Programm ans Ende des kompletten
|
https://www.arduino.cc/reference/de/language/structure/control-structure/else/index.html
|
f963133cfaca-2
|
if…else-Konstrukts springt. Wenn ein Default-else-Teil vorhanden ist, wird dieser ausgeführt, wenn alle anderen Tests auf false evaluiert wurden.
Ein else if-Block kann benutzt werden ohne einen terminierenden else-Block und umgekehrt. Somit ist eine unbegrenzte Anzahl an `else if`s möglich.
Syntax
if (condition1) {
// Tue Task 1
}
else if (condition2) {
// Tue Task 2
}
else {
// Tue Task 3
}
Parameter
condition: Die Bedingung, die abgeprüft wird. Evaluiert zu true oder false.
Rückgabewert
Nichts.
Beispielcode
Der folgende Code testet einige Werte in den Bedingungen ab. Im Detail handelt es sich um ein simples Temperaturwarnsystem.
|
https://www.arduino.cc/reference/de/language/structure/control-structure/else/index.html
|
f963133cfaca-3
|
if (temperature >= 70) {
// Schalte das System ab.
}
else if (temperature >= 60) // 60 <= temperature < 70
// Schicke dem Benutzer eine Warnung.
}
else { // temperature < 60
// Keine Probleme erkannt.
}
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/control-structure/else/index.html
|
5d209dd25ae5-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Structure
> Control structure
> For
for
[Control Structure]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/control-structure/for/index.html
|
5d209dd25ae5-1
|
> For
for
[Control Structure]
Beschreibung
Das for-Statement wiederholt die in Klammern nachfolgenden Anweisungen. Meistens wird eine Zählervariable verwendet, welche hochgezählt wird und die Schleife irgendwann beendet.
Das for-Statement wird häufig zur Iteration über Arrays oder Listen von Daten oder Pins verwendet.
Syntax
for (initialization; condition; increment) {
// Statement(s);
}
Parameter
initialization: Passiert genau einmal am Anfang der Schleife.
condition: Wird bei jedem Schleifendurchlauf getestet. Wenn sie true ist, werden alle Statements in den Klammern ausgeführt und increment hochgezählt. Wenn
die condition false ist, wird die Schleife abgebrochen.
|
https://www.arduino.cc/reference/de/language/structure/control-structure/for/index.html
|
5d209dd25ae5-2
|
die condition false ist, wird die Schleife abgebrochen.
increment: Wird hochgezählt, wenn die condition true ist.
Rückgabewert
Nichts.
Beispielcode
Eine LED wird über einen PWM-Pin gedimmt.
int PWMpin = 10; // LED in Serie mit 470-Ohm-Widerstand auf Pin 10
void setup() {
// Nichts
}
void loop() {
// Wiederhole 255 Mal:
for (int i=0; i <= 255; i++){
// Schreibe den Wert von "i" auf den LED-Pin
analogWrite(PWMpin, i);
// Warte 10 Millisekunden
delay(10);
}
}
Anmerkungen und Warnungen
|
https://www.arduino.cc/reference/de/language/structure/control-structure/for/index.html
|
5d209dd25ae5-3
|
delay(10);
}
}
Anmerkungen und Warnungen
Die for-Schleife in C++ ist deutlich ausgeprägter als in anderen Sprachen wie z.B. BASIC. Einige oder sogar alle der 3 Parameter können weggelassen werden,
allerdings sind die Strichpunkte immer nötig. Alle 3 Parameter können mit beliebigen Variablen belegt werden und jeden Datentyp inklusive float nutzen.
Die Beispiele unten zeigen die Verwendung einiger Spezialformen der for-Schleife.
Eine Multiplikation im increment generiert ein logarithmisches Verhalten:
for(int x = 2; x < 100; x = x * 1.5) {
println(x);
}
Gibt aus: 2,3,4,6,9,13,19,28,42,63,94
|
https://www.arduino.cc/reference/de/language/structure/control-structure/for/index.html
|
5d209dd25ae5-4
|
LED hoch- und runterdimmen in einer Schleife:
void loop() {
// Globale Zählervariable "x"
int x = 1;
// Laufe über die Variable solange i größer -1 ist und zähle i um x hoch
for (int i = 0; i > -1; i = i + x){
// Schreibe auf den LED-Pin
analogWrite(PWMpin, i);
if (i == 255) {
x = -1; // Ändere die Richtung des Dimmens auf dem "Peek"
// Warte 10 Millisekunden
delay(10);
}
}
}
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/control-structure/for/index.html
|
a6189fc3d6e5-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Structure
> Control structure
> Goto
goto
[Control Structure]
Beschreibung
Springt im Programmfluss zu einem bestimmten benannten Punkt.
Syntax
|
https://www.arduino.cc/reference/de/language/structure/control-structure/goto/index.html
|
a6189fc3d6e5-1
|
Springt im Programmfluss zu einem bestimmten benannten Punkt.
Syntax
label:
goto label; // Springt zu dem Label.
Parameter
label: Das Label an der Stelle, zu der gesprungen werden soll.
Rückgabewert
Nichts.
Beispielcode
Der Code zeigt, wie goto aus einem Programm mit 3 Schleifen an eine bestimmte Stelle springt.
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 bailout;}
// Weitere Statements
}
}
}
bailout:
// Weitere Statements
Anmerkungen und Warnungen
|
https://www.arduino.cc/reference/de/language/structure/control-structure/goto/index.html
|
a6189fc3d6e5-2
|
}
bailout:
// Weitere Statements
Anmerkungen und Warnungen
Es wird nicht empfohlen, goto in der C++-Programmierung zu verwenden. Viele Autoren sagen sogar, dass der goto-Operator unnötig ist.
Das Problem mit goto ist, dass der Code schnell nahezu unlesbar wird und nicht mehr zu debuggen ist.
Manchmal kann ein goto nützlich sein. Z.B um aus einer hohen Schleifentiefe wie im Beispielcode oben herauszuspringen (Obwohl dies mit return auch klappen würde).
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/control-structure/goto/index.html
|
0d24ff7757c5-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Structure
> Control structure
> Return
return
[Control Structure]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/control-structure/return/index.html
|
0d24ff7757c5-1
|
> Return
return
[Control Structure]
Beschreibung
Beendet eine Funktion und gibt einen Wert an die aufrufende Funktion zurück, wenn gewünscht.
Syntax
return
return value; // Beide Formen davon sind gültig
Parameter
value: Beliebige Variable oder Parameter. Erlaubte Datentypen: Beliebiger Datentyp.
Rückgabewert
Den Datentyp des Parameters value.
Beispielcode
Vergleicht einen Sensorwert mit einem Thresholdwert.
int checkSensor() {
// Lies Wer von Sensor ein und vergleiche diesen mit der Konstante 400
if (analogRead(0) > 400) {
// Wenn Sensorwert größer als 400: Gib 1 zurück
return 1;
}
else {
|
https://www.arduino.cc/reference/de/language/structure/control-structure/return/index.html
|
0d24ff7757c5-2
|
return 1;
}
else {
// Sonst gib 0 zurück
return 0;
}
}
Das return-Keywort kann dazu dienen, Codeabschnitte zu testen ohne viel Code auskommentieren zu müssen.
void loop() {
// Codeidee, die getestet werden soll, hier.
return;
// Der Rest des Sketches hier.
// Wird niemals ausgeführt
}
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/control-structure/return/index.html
|
9eff10c956b5-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Structure
> Control structure
> Dowhile
do...while
[Control Structure]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/control-structure/dowhile/index.html
|
9eff10c956b5-1
|
do...while
[Control Structure]
Beschreibung
do…while funktioniert genauso wie eine while-Schleife. Der einzige Unterschied ist, dass do…while immer mindestens einmal ausgeführt wird,
da die Bedingung erst am Schluss der Schleife getestet wird.
Syntax
do {
//Statement(s)
} while (condition);
Parameter
condition: Ein Ausdruck, der auf true oder false evaluiert.
Rückgabewert
Nichts.
Beispielcode
Liest in do-while-Schleife 100 Mal einen Sensorwert aus.
// Initialisiere x mit Wert 0
int x = 0;
do {
delay(50); // Warte 50 Millieskunden, bis der Sensor wieder einen stabilen Wert liefert.
|
https://www.arduino.cc/reference/de/language/structure/control-structure/dowhile/index.html
|
9eff10c956b5-2
|
x = readSensor(); // Lies den Sensorwert
} while (x < 100); // Wiederhole das ganze 100 Mal
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/control-structure/dowhile/index.html
|
4b7267096321-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Structure
> Control structure
> Continue
continue
[Control Structure]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/control-structure/continue/index.html
|
4b7267096321-1
|
> Continue
continue
[Control Structure]
Beschreibung
Das continue-Statement überspringt die restliche Iteration einer Schleife (for, while oder do…while).
Das continue-Statement checkt anschließend die condition und durchläuft die Schleife erneut, bis die Abbruchbedingung erreicht ist.
Syntax
while (condition) {
//Statement(s)
continue;
//Statement(s)
}
Parameter
Keine.
Rückgabewert
Nichts.
Beispielcode
Der Code schreibt die Werte von 0 bis 255 auf den LED-Pin, aber überspringt Werte zwischen 41 und 119.
// Iteriere über die Werte von 0 bis 255
for (int x = 0; x <= 255; x ++) {
|
https://www.arduino.cc/reference/de/language/structure/control-structure/continue/index.html
|
4b7267096321-2
|
for (int x = 0; x <= 255; x ++) {
// Springe bei den Werten zwischen 40 und 120 weiter
if (x > 40 && x < 120){
continue;
}
// Schreibe den Wert auf den LED-Pin
analogWrite(PWMpin, x);
// Warte 50 Millieskunden
delay(50);
}
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/control-structure/continue/index.html
|
b38cd5a759ec-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Structure
> Control structure
> Switchcase
switch...case
[Control Structure]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/control-structure/switchcase/index.html
|
b38cd5a759ec-1
|
switch...case
[Control Structure]
Beschreibung
Wie auch if-Statements, erlaubt es auch switch case, dass abhängig von der Bedingung in verschiedenen Situationen unterschiedlicher Code ausgeführt wird.
Im Detail vergleicht switch case die Variablenwerte mit denen in den case-Statements. Wenn ein passendes case-Statement gefunden wird, so wird der Code in diesem
case-Statement ausgeführt.
Das break-Keywort beendet das switch case-Statement und wird üblicherweise am Ende jedes case-Statements verwendet. Wenn kein break-Keywort
verwendet wird, führt switch case alle Statements aus, bis ein break-Keywort auftaucht oder das switch case zu Ende ist.
Syntax
switch (var) {
case label1:
// Statement(s)
break;
case label2:
// Statement(s)
|
https://www.arduino.cc/reference/de/language/structure/control-structure/switchcase/index.html
|
b38cd5a759ec-2
|
break;
case label2:
// Statement(s)
break;
default:
// Statement(s)
break; // Wird nicht benötigt, wenn Statement(s) vorhanden sind
}
Parameter
var: Eine Variable, die mit den eizelnen Fällen verglichen werden sollen. Erlaubte Datentypen: int, char.
label1, label2: Konstanten. Erlaubte Datentypen: int, char.
Rückgabewert
Nichts.
Beispielcode
Das Code-Beispiel zeigt die Verwendung des switch-case-Statements.
switch (var) {
case 1:
// Tue etwas, wenn "var" 1 ist
break;
case 2:
// Tue etwas, wenn "var" 2 ist
break;
default:
|
https://www.arduino.cc/reference/de/language/structure/control-structure/switchcase/index.html
|
b38cd5a759ec-3
|
break;
default:
// Tue etwas, im Defaultfall
// Dieser Fall ist optional
break; // Wird nicht benötigt, wenn Statement(s) vorhanden sind
}
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/control-structure/switchcase/index.html
|
b8cf815c08b3-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Structure
> Control structure
> While
while
[Control Structure]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/control-structure/while/index.html
|
b8cf815c08b3-1
|
> While
while
[Control Structure]
Beschreibung
Eine while-Schleife läuft solange weiter (Eventuell auch unendlich), bis die Bedingung in den Klammern () false wird. Wenn die Variable in der Schleife
sich nie ändert, läuft die Schleife unendlich. Dies kann z.B. durch das Hochzählen einer Variable oder das Lesen eines Sensorwertes erfolgen.
Syntax
while(condition) {
// Statement(s)
}
Parameter
condition: Ein Ausdruck, der auf true oder false evaluiert.
Rückgabewert
Nichts.
Beispielcode
Dieser Code zählt eine Variable 200-mal um 1 hoch.
var = 0;
// Wiederhole etwas 200 Mal
while(var < 200) {
|
https://www.arduino.cc/reference/de/language/structure/control-structure/while/index.html
|
b8cf815c08b3-2
|
// Wiederhole etwas 200 Mal
while(var < 200) {
// Zähle Variable x um 1 hoch
var++;
}
Siehe auch
BEISPIEL While
|
https://www.arduino.cc/reference/de/language/structure/control-structure/while/index.html
|
8c190ef5eed3-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Variables
> Variable scope qualifiers
> Volatile
volatile
[Data Types]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/variable-scope-qualifiers/volatile/index.html
|
8c190ef5eed3-1
|
volatile
[Data Types]
Beschreibung
volatile ist ein Variablenkennzeichner. Dieser wird normalerweise vor dem Datentyp der Variable angegeben. Der Compiler behandelt je nach Kennzeichner dann die
Variable auf andere Art.
Eine volatile- Variable ist eine Direktive für den Compiler. Der Compiler ist eine Software, die deinen C/C++-Code in Maschinencode übersetzt, der dann die "richtigen"
Anweisungen für den Arduino enthält.
Im Detail zeigt volatile dem Compiler, dass er die Variable aus dem RAM und nicht aus dem Speicherregister laden soll. Unter bestimmten Bedingungen können die Variablen
in den Registern ungenau sein.
|
https://www.arduino.cc/reference/de/language/variables/variable-scope-qualifiers/volatile/index.html
|
8c190ef5eed3-2
|
in den Registern ungenau sein.
Eine Variable sollte als volatile deklariert werden, wenn sie von irgendwo anders geändert werden kann außer in dem Codeteil, in dem sie auftaucht. Beispiele dafür sind
Threads, die parallel ausgeführt werden. Im Arduino kann das nur bei Interrupts vorkommen, in sogennanten Interrupt Service Routinen.
int oder long volatile Variablen
Wenn die Variable größer als Byte ist (also z.B. ein 16-Bit-Integer oder ein 32-Bit-Long), kann der Mikrocontroller sie nicht in einem Durchgang lesen, da es ein
8-Bit-Mikrocontroller ist. Das bedeutet, das während das Hauptprogramm die ersten 8 Bit der Variable liest, kann der Interrupt bereits die zweiten 8 Bit geändert haben.
|
https://www.arduino.cc/reference/de/language/variables/variable-scope-qualifiers/volatile/index.html
|
8c190ef5eed3-3
|
Das kann zufällig und unvorhersehbare Ergebnisse liefern.
Gegenmaßnahme:
Während die Variable gelesen wird, müssen Interrupts deaktiviert werden, sodass diese die Bits nicht verändern können während sie gelesen werden.
Es gibt mehrere Möglichkeiten, das zu tun:
SPRACHE noInterrupts
Das ATOMIC_BLOCK-Makro. Atomare Operationen sind einzelne MCU-Operationen-Die kleinste mögliche Einheit.
Beispielcode
Der Modifikator volatile stellt sicher, dass Änderungen an der Variablen state sofort in loop() sichtbar sind.
Ohne den Modifikator volatile kann die Variable state beim Eingeben der Funktion in ein Register geladen werden und wird erst nach Beendigung der Funktion aktualisiert.
// Die LED wird angeschaltet, wenn der Interrupt-Pin den Status ändert.
|
https://www.arduino.cc/reference/de/language/variables/variable-scope-qualifiers/volatile/index.html
|
8c190ef5eed3-4
|
// Die LED wird angeschaltet, wenn der Interrupt-Pin den Status ändert.
volatile byte changed = 0;
void setup() {
// Deklariere den LED-Pin als Output-Pin
pinMode(LED_BUILTIN, OUTPUT);
// Setze einen Interrupt
attachInterrupt(digitalPinToInterrupt(2), toggle, CHANGE);
}
void loop() {
if (changed == 1) {
// toggle() wurde vom Interrupt aus aufgerufen!
// changed auf 0 zurücksetzen
changed = 0;
// LED für 200 ms blinken lassen
digitalWrite(LED_BUILTIN, HIGH);
delay(200);
digitalWrite(LED_BUILTIN, LOW);
}
}
void toggle() {
// Invertiere den Status, dass die LED blinkt
changed = 1;
}
|
https://www.arduino.cc/reference/de/language/variables/variable-scope-qualifiers/volatile/index.html
|
8c190ef5eed3-5
|
changed = 1;
}
Verwenden Sie das Makro ATOMIC_BLOCK, um auf eine Variable zuzugreifen, deren Größe größer ist als der 8-Bit-Datenbus des Mikrocontrollers.
Das Makro stellt sicher, dass die Variable in einer atomaren Operation gelesen wird, d.H. ihr Inhalt kann nicht geändert werden, während sie gelesen wird.
#include <util/atomic.h> // Diese Bibliothek fügt das ATOMIC_BLOCK-Makro ein.
volatile int input_from_interrupt;
// Irgendwo im Code, z.B. in loop()
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
// Code mit geblockten Interrupts hier (Mehrere atomare Operationen hintereinander werden nicht durch Interrupts unterbrochen)
int result = input_from_interrupt;
}
Siehe auch
SPRACHE attachInterrupt
|
https://www.arduino.cc/reference/de/language/variables/variable-scope-qualifiers/volatile/index.html
|
de1238aa33d0-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Variables
> Variable scope qualifiers
> Const
const
[Data Types]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/variable-scope-qualifiers/const/index.html
|
de1238aa33d0-1
|
> Const
const
[Data Types]
Beschreibung
Das const-Keywort steht für Konstanten. Es ist ein Variablenkennzeichner, der das Verhalten der Variable verändert. In diesem Fall wird die Variable "read-only".
Das bedeutet, dass die Variable wie alle anderen Variablen des gleichen Typs benutzt werden kann, aber dass der Wert unveränderlich ist. Wenn du der Variable einen
neuen Wert zuweist, bekommst du einen Compiler-Fehler.
Konstanten, die mit const versehen sind, folgen den Regeln des Variablenscopes. Dieses Vorgehen und die Fallen bei der Verwendung von
#define sorgt dafür, dass const bevorzugt vor #define
benutzt werden sollte.
Beispielcode
Der Code zeigt die Verwendung von konstanten Variablen.
|
https://www.arduino.cc/reference/de/language/variables/variable-scope-qualifiers/const/index.html
|
de1238aa33d0-2
|
Beispielcode
Der Code zeigt die Verwendung von konstanten Variablen.
// Definiere Pi als Konstante
const float pi = 3.14;
// Variable x zum Speichern des Ergebnisses
float x;
// ....
x = pi * 2; // Das ist erlaubt.
pi = 7; // Illegal-Konstante darf/kann nicht verändert werden.
Anmerkungen und Warnungen
#define oder const
Du kannst entweder const oder #define für Konstanten verwenden. Für Arrays
musst du const verwenden. Generell wird const vor #define vorgezogen.
Siehe auch
SPRACHE #define
|
https://www.arduino.cc/reference/de/language/variables/variable-scope-qualifiers/const/index.html
|
aeb9aa36fd52-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Variables
> Variable scope qualifiers
> Scope
scope
[Data Types]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/variable-scope-qualifiers/scope/index.html
|
aeb9aa36fd52-1
|
> Scope
scope
[Data Types]
Beschreibung
Variablen in der C++-Programmiersprache, auf die Arduino aufbaut, haben eine Eigenschaft, die sich Scope nennt. Im Gegensatz zu früheren Programmiersprachen,
wie z.B. BASIC, sind in C nicht alle Variablen global verfügar.
Eine globale Variable ist eine Variable, die von jeder Funktion in dem Programm "gesehen" werden kann. Lokale Variablen sind nur gültig in der Funktion, in der
sie deklariert wurden und können von außerhalb nicht verändert werden. In der Arduino-Umgebung ist jede Variable, die außerhalb einer Funktion (z.B. setup(), loop(), etc. )
definiert wird, eine globale Variable.
|
https://www.arduino.cc/reference/de/language/variables/variable-scope-qualifiers/scope/index.html
|
aeb9aa36fd52-2
|
definiert wird, eine globale Variable.
Wenn Programme größer und komplexer werden, sind lokale Variablen eine Möglichkeit, sicherzustellen, dass nur die Funktion Zugriff auf die Variable hat, die dies wirklich benötigt.
Das verhindert unter Anderem, dass Funktionen unabsichtlich die Variablen anderer Funktionen ändern und damit unvorhersehbare Ergebnisse produzieren.
Manchmal macht es auch Sinn, eine Variable direkt in einer for-Schleife zu initialisieren. Diese Variable ist dann nur innerhalb der for-Schleife gültig.
Beispielcode
Der Code beschreibt den Unterschied zwischen lokalen und globalen Variablen.
int gPWMval; // Globale Variable, die jede Funktion "sehen" kann
void setup() {
// ...
}
void loop() {
|
https://www.arduino.cc/reference/de/language/variables/variable-scope-qualifiers/scope/index.html
|
aeb9aa36fd52-3
|
void setup() {
// ...
}
void loop() {
int i; // "i" ist nur "sichtbar" innerhalb von "loop"
float f; // "f" ist nur "sichtbar" innerhalb von "loop"
// ...
for (int j = 0; j <100; j++) {
// Variable j kann nur innerhalb der Schleife benutzt werden
}
}
Siehe auch
|
https://www.arduino.cc/reference/de/language/variables/variable-scope-qualifiers/scope/index.html
|
8173df735347-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Variables
> Variable scope qualifiers
> Static
static
[Data Types]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/variable-scope-qualifiers/static/index.html
|
8173df735347-1
|
> Static
static
[Data Types]
Beschreibung
Das static-Keywort ermöglicht es, dass Variablen nur für eine Funktion sichtbar sind. Anders als lokale Variablen, die bei jedem Funktionsaufruf neu belegt werden,
behalten statische Variablen deren Wert über das Funktionsende hinaus bei.
Statische Variablen werden nur einmal erstellt, wenn die Funktion das erste Mal aufgerufen wird.
Beispielcode
Der Code wandert zufällig zwischen 2 Endpunkten umher.
/* RandomWalk
* Paul Badger 2007
* RandomWalk wandert zufällig zwischen 2 Endpunkten umher.
* Die maximale Bewegug pro Schritt wird über "stepsize" festgelegt.
* Eine statische Variable wird dazu um einen zufälligen Wert hoch- bzw.
|
https://www.arduino.cc/reference/de/language/variables/variable-scope-qualifiers/static/index.html
|
8173df735347-2
|
* Eine statische Variable wird dazu um einen zufälligen Wert hoch- bzw.
* heruntergezählt.
* Das ist auch bekannt als "pink noise" und "drunken walk".
*/
// Definiere die maximale und minimale Beschränkung der Funktion
#define randomWalkLowRange -20
#define randomWalkHighRange 20
// Variable für die Schrittweite pro Durchlauf
int stepsize;
// Variable zur Speicherung des aktuellen Ergebnisses der RandomWalk-Funktion
int thisTime;
int total;
void setup() {
// Initialisiere die serielle Verbindung
Serial.begin(9600);
}
void loop() {
// Initialisiere die Schrittweite
stepsize = 5;
// Rufe die randomWalk-Funktion auf und speichere das Ergebnis
|
https://www.arduino.cc/reference/de/language/variables/variable-scope-qualifiers/static/index.html
|
8173df735347-3
|
// Rufe die randomWalk-Funktion auf und speichere das Ergebnis
// in der Variable "thisTime"
thisTime = randomWalk(stepsize);
// Gib den Wert der Variable "thisTime" aus
Serial.println(thisTime);
// Warte 10 ms
delay(10);
}
int randomWalk(int moveSize) {
// Variable, um den Wert in der randomWalk-Funktion zu speichern
// Nur diese Funktion kann den Wert ändern, der Wert ist aber von
// Aufruf zu Aufruf wieder verfügbar
static int place;
// Zufällige Bewegung
place = place + (random(-moveSize, moveSize + 1));
// Check, ob die Limits verletzt wurden
if (place < randomWalkLowRange) {
|
https://www.arduino.cc/reference/de/language/variables/variable-scope-qualifiers/static/index.html
|
8173df735347-4
|
if (place < randomWalkLowRange) {
// Korrigiere den aktuellen Schritt in die positive Richtung
place = randomWalkLowRange + (randomWalkLowRange - place);
}
else if(place > randomWalkHighRange) {
// Korrigiere den aktuellen Schritt in die negative Richtung
place = randomWalkHighRange - (place - randomWalkHighRange);
}
// Gib die neue Position zurück
return place;
}
|
https://www.arduino.cc/reference/de/language/variables/variable-scope-qualifiers/static/index.html
|
f32b7c5e0108-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Variables
> Conversion
> Bytecast
byte()
[Conversion]
Beschreibung
Konvertiert einen Wert in den byte-Datentyp.
Syntax
byte(x)
|
https://www.arduino.cc/reference/de/language/variables/conversion/bytecast/index.html
|
f32b7c5e0108-1
|
Konvertiert einen Wert in den byte-Datentyp.
Syntax
byte(x)
(byte)x (Typ-Konvertierung wie in C)
Parameter
x: Ein Wert beliebigen Typs. Erlaubte Datentypen: Beliebiger Datentyp.
Rückgabewert
Datentyp: byte.
Siehe auch
SPRACHE byte
|
https://www.arduino.cc/reference/de/language/variables/conversion/bytecast/index.html
|
6174ff1ecffc-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Variables
> Conversion
> Wordcast
word()
[Conversion]
Beschreibung
Konvertiert einen Wert in den word-Datentyp.
Syntax
|
https://www.arduino.cc/reference/de/language/variables/conversion/wordcast/index.html
|
6174ff1ecffc-1
|
Beschreibung
Konvertiert einen Wert in den word-Datentyp.
Syntax
word(h, l)
(word)x (Typ-Konvertierung wie in C)
Parameter
x: Ein Wert beliebigen Typs. Erlaubte Datentypen: Beliebiger Datentyp.
h: Das high-order (linkeste) byte des Words.
l: Das low-order (rechteste) byte des Words.
Rückgabewert
Datentyp: word.
Siehe auch
SPRACHE word
|
https://www.arduino.cc/reference/de/language/variables/conversion/wordcast/index.html
|
94cb327a5eb7-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Variables
> Conversion
> Intcast
int()
[Conversion]
Beschreibung
Konvertiert einen Wert in den int-Datentyp.
Syntax
int(x)
|
https://www.arduino.cc/reference/de/language/variables/conversion/intcast/index.html
|
94cb327a5eb7-1
|
Konvertiert einen Wert in den int-Datentyp.
Syntax
int(x)
(int)x (Typ-Konvertierung wie in C)
Parameter
x: Ein Wert beliebigen Typs. Erlaubte Datentypen: Beliebiger Datentyp.
Rückgabewert
Datentyp: int.
Siehe auch
SPRACHE int
|
https://www.arduino.cc/reference/de/language/variables/conversion/intcast/index.html
|
ba9de44e4f00-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Variables
> Conversion
> Charcast
char()
[Conversion]
Beschreibung
Konvertiert einen Wert in den char-Datentyp.
Syntax
char(x)
|
https://www.arduino.cc/reference/de/language/variables/conversion/charcast/index.html
|
ba9de44e4f00-1
|
Konvertiert einen Wert in den char-Datentyp.
Syntax
char(x)
(char)x (Typ-Konvertierung wie in C)
Parameter
x: Ein Wert beliebigen Typs. Erlaubte Datentypen: Beliebiger Datentyp.
Rückgabewert
Datentyp: char.
Siehe auch
SPRACHE char
|
https://www.arduino.cc/reference/de/language/variables/conversion/charcast/index.html
|
1c70c250bc23-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Variables
> Conversion
> Unsignedlongcast
(unsigned long)
[Conversion]
Beschreibung
Konvertiert einen Wert in den unsigned long-Datentyp.
Syntax
|
https://www.arduino.cc/reference/de/language/variables/conversion/unsignedlongcast/index.html
|
1c70c250bc23-1
|
Konvertiert einen Wert in den unsigned long-Datentyp.
Syntax
(unsigned long)x
Parameter
x: Ein Wert beliebigen Typs. Erlaubte Datentypen: Beliebiger Datentyp.
Rückgabewert
Datentyp: unsigned long.
Siehe auch
LANGUAGE unsigned long
|
https://www.arduino.cc/reference/de/language/variables/conversion/unsignedlongcast/index.html
|
02a4888367c6-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Variables
> Conversion
> Floatcast
float()
[Conversion]
Beschreibung
Konvertiert einen Wert in den float-Datentyp.
Syntax
float(x)
|
https://www.arduino.cc/reference/de/language/variables/conversion/floatcast/index.html
|
02a4888367c6-1
|
Konvertiert einen Wert in den float-Datentyp.
Syntax
float(x)
(float)x (Typ-Konvertierung wie in C)
Parameter
x: Ein Wert beliebigen Typs. Erlaubte Datentypen: Beliebiger Datentyp.
Rückgabewert
Datentyp: float.
Anmerkungen und Warnungen
Siehe die Referenz des Datentyps float für Details über Präzision und Fließkommazahlen auf dem Arduino.
Siehe auch
SPRACHE float
|
https://www.arduino.cc/reference/de/language/variables/conversion/floatcast/index.html
|
e5f7ae280f87-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Variables
> Conversion
> Longcast
long()
[Conversion]
Beschreibung
Konvertiert einen Wert in den long-Datentyp.
Syntax
long(x)
|
https://www.arduino.cc/reference/de/language/variables/conversion/longcast/index.html
|
e5f7ae280f87-1
|
Konvertiert einen Wert in den long-Datentyp.
Syntax
long(x)
(long)x (Typ-Konvertierung wie in C)
Parameter
x: Ein Wert beliebigen Typs. Erlaubte Datentypen: Beliebiger Datentyp.
Rückgabewert
Datentyp: long.
Siehe auch
SPRACHE long
|
https://www.arduino.cc/reference/de/language/variables/conversion/longcast/index.html
|
880d99662595-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Variables
> Conversion
> Unsignedintcast
(unsigned int)
[Conversion]
Beschreibung
Konvertiert einen Wert in den unsigned int-Datentyp.
Syntax
|
https://www.arduino.cc/reference/de/language/variables/conversion/unsignedintcast/index.html
|
880d99662595-1
|
Konvertiert einen Wert in den unsigned int-Datentyp.
Syntax
(unsigned int)x
Parameter
x: Ein Wert beliebigen Typs. Erlaubte Datentypen: Beliebiger Datentyp.
Rückgabewert
Datentyp: unsigned int.
Siehe auch
LANGUAGE unsigned int
|
https://www.arduino.cc/reference/de/language/variables/conversion/unsignedintcast/index.html
|
8e8120eba239-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Variables
> Data types
> String
string
[Data Types]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/data-types/string/index.html
|
8e8120eba239-1
|
> String
string
[Data Types]
Beschreibung
Textzeichenfolgen können auf zwei Arten dargestellt werden. Du kannst den String-Datentyp verwenden, der ab Version 0019 Teil des Kerns ist oder du kannst einen
String aus einem Array des Typs char erstellen und ihn mit einem Nullterminator abschließen.
Diese Seite beschreibt die letztere Methode. Für weitere Informationen zum String-Objekt, das mehr Funktionalität auf Kosten von mehr Arbeitsspeicher bietet, siehe die string object-Seite.
Syntax
Alle folgenden Angaben sind gültige Deklarationen für Strings.
char Str1[15];
char Str2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'};
|
https://www.arduino.cc/reference/de/language/variables/data-types/string/index.html
|
8e8120eba239-2
|
char Str3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'};
char Str4[ ] = "arduino";
char Str5[8] = "arduino";
char Str6[15] = "arduino";
Möglichkeiten zur Deklaration von Strings
Deklariere ein Array von Zeichen, ohne es wie in Str1 zu initialisieren
Deklariere ein Array von chars (mit einem zusätzlichen char) und der Compiler fügt das erforderliche Nullzeichen wie in Str2 hinzu
Füge das Nullzeichen explizit hinzu, Str3
|
https://www.arduino.cc/reference/de/language/variables/data-types/string/index.html
|
8e8120eba239-3
|
Füge das Nullzeichen explizit hinzu, Str3
Initialisiere mit einer String-Konstante in Anführungszeichen. Der Compiler passt die Größe des Arrays an die String-Konstante und fügt ein abschließendes Nullzeichen an, Str4
Initialisiere das Array mit einer expliziten Größen- und Zeichenfolgekonstante, Str5
Initialisiere das Array und lasse zusätzlichen Platz für eine größere Zeichenfolge, Str6
Null-Termination
Im Allgemeinen werden Zeichenfolgen mit einem Nullzeichen (ASCII-Code 0) abgeschlossen. Dadurch können Funktionen (wie Serial.print()) erkennen, wo das Ende eines Strings ist.
Andernfalls würden sie nachfolgende Speicherbytes lesen, die eigentlich nicht Teil der Zeichenfolge sind.
|
https://www.arduino.cc/reference/de/language/variables/data-types/string/index.html
|
8e8120eba239-4
|
Das bedeutet, dass die Zeichenfolge Platz für ein Zeichen mehr als den gewünschten Text haben muss.
Aus diesem Grund müssen Str2 und Str5 acht Zeichen haben, obwohl "Arduino" nur sieben hat - die letzte Position wird automatisch mit einem Nullzeichen gefüllt.
Str4 wird automatisch in acht Zeichen umgewandelt, eines für die zusätzliche Null. In Str3 haben wir das Nullzeichen (geschrieben als '\0') selbst explizit eingefügt.
Beachte, dass es möglich ist, eine Zeichenfolge ohne ein abschließendes Nullzeichen zu verwenden (z. B. wenn du die Länge von Str2 mit sieben statt mit acht angegeben hättest).
Dadurch werden die meisten Funktionen, die Zeichenfolgen verwenden, nicht mehr richtig funktionieren.
|
https://www.arduino.cc/reference/de/language/variables/data-types/string/index.html
|
8e8120eba239-5
|
Wenn du feststellst, dass sich etwas merkwürdig verhält (mit Zeichen, die sich nicht in der Zeichenfolge befinden), kann dies jedoch das Problem sein.
Einfache oder doppelte Anführungszeichen?
Strings werden immer in doppelten Anführungszeichen ("Abc") und chars in einfachen Anführungszeichen ('A') definiert.
Lange strings umbrechen
Du kannst lange Zeichenfolgen wie folgt umbrechen:
char myString[] = "This is the first line"
" this is the second line"
" etcetera";
Arrays von Strings
Wenn du mit großen Textmengen arbeitest, z. B. bei einem Projekt mit LCD-Display, ist es oft praktisch, ein String-Array zu erstellen.
|
https://www.arduino.cc/reference/de/language/variables/data-types/string/index.html
|
8e8120eba239-6
|
Da Strings selbst Arrays sind, handelt es sich eigentlich um ein zweidimensionales Array.
In dem folgenden Code zeigt das Sternchen hinter dem Datentyp char “char*” an, dass dies ein Array von “Zeigern” ist.
Alle Array-Namen sind eigentlich Zeiger, daher ist dies zum Erstellen eines Arrays aus Arrays erforderlich. Zeiger sind eine der eher esoterischen Komponenten von C ++,
die für Anfänger schwer verständlich sind, aber es ist nicht notwendig,Zeiger im Detail zu verstehen, um sie hier effektiv zu verwenden.
Beispielcode
char* myStrings[]={ "This is string 1", "This is string 2", "This is string 3",
"This is string 4", "This is string 5","This is string 6"};
void setup() {
Serial.begin(9600);
}
|
https://www.arduino.cc/reference/de/language/variables/data-types/string/index.html
|
8e8120eba239-7
|
void setup() {
Serial.begin(9600);
}
void loop() {
for (int i = 0; i < 6; i++) {
Serial.println(myStrings[i]);
delay(500);
}
}
Siehe auch
SPRACHE PROGMEM
|
https://www.arduino.cc/reference/de/language/variables/data-types/string/index.html
|
5a25d991d681-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Variables
> Data types
> Void
void
[Data Types]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/data-types/void/index.html
|
5a25d991d681-1
|
> Void
void
[Data Types]
Beschreibung
Das Schlüsselwort void wird nur in Funktionsdeklarationen verwendet. Es zeigt an, dass die Funktion voraussichtlich keine Informationen an die Funktion zurückgibt, von der sie aufgerufen wurde.
Beispielcode
Der Code zeigt, wie void verwendet wird.
// Aktionen werden in den Funktionen `setup()` und `loop()` ausgeführt.
// Es werden jedoch keine Informationen an das größere Programm gemeldet.
void setup() {
// ...
}
void loop() {
// ...
}
Siehe auch
SPRACHE Ganzzahlkonstanten
|
https://www.arduino.cc/reference/de/language/variables/data-types/void/index.html
|
25d3b5d1a7ec-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Variables
> Data types
> Int
int
[Data Types]
Beschreibung
Ganzzahlen sind der primäre Datentyp für die Nummernspeicherung.
|
https://www.arduino.cc/reference/de/language/variables/data-types/int/index.html
|
25d3b5d1a7ec-1
|
Auf dem Arduino Uno (und anderen ATmega-basierten Boards) speichert ein int einen 16-Bit-Wert (2 Byte).
Dies ergibt einen Bereich von -32,768 bis 32,767 (Minimalwert -2^15 und Maximalwert (2^15) - 1).
Auf den Arduino Due- und SAMD-basierten Boards (wie MKR1000 und Zero) speichert ein int einen 32-Bit-Wert (4 Byte).
Dies ergibt einen Bereich von -2,147,483,648 to 2,147,483,647 (Minimalwert -2^31 und Maximalwert (2^31) - 1).
Int speichert negative Zahlen mit einer Technik namens (Zweierkomplement).
|
https://www.arduino.cc/reference/de/language/variables/data-types/int/index.html
|
25d3b5d1a7ec-2
|
Int speichert negative Zahlen mit einer Technik namens (Zweierkomplement).
Das höchste Bit, manchmal auch als "Vorzeichen" bezeichnet, kennzeichnet die Zahl als negative Zahl. Die restlichen Bits werden invertiert und 1 wird hinzugefügt.
Der Arduino kümmert sich um den Umgang mit negativen Zahlen für dich, damit arithmetische Operationen auf die erwartete Weise transparent arbeiten.
Es kann unerwartete Komplikationen im Umgang mit dem Rechten Bitshift-Operator (>>) geben.
Syntax
int var = val
Parameter
var: Variablenname.
val: Der Wert, der der Variablen zugewiesen wird.
Beispielcode
|
https://www.arduino.cc/reference/de/language/variables/data-types/int/index.html
|
25d3b5d1a7ec-3
|
val: Der Wert, der der Variablen zugewiesen wird.
Beispielcode
Dieser Code erstellt eine Ganzzahl namens 'countUp', die anfänglich als Zahl 0 (Null) festgelegt wird. Der Wert der Variable steigt in jeder Schleife um 1 (eins) und wird auf dem seriellen Monitor angezeigt.
int countUp = 0; // Erstellt eine variable Ganzzahl mit dem Namen 'countUp'
void setup() {
Serial.begin(9600); // Verwende die serielle Schnittstelle, um die Nummer auszugeben
}
void loop() {
countUp++; // Fügt der countUp-Variable in jeder Schleife 1 hinzu
Serial.println(countUp); // Gibt den aktuellen Stand von countUp aus
delay(1000);
}
|
https://www.arduino.cc/reference/de/language/variables/data-types/int/index.html
|
25d3b5d1a7ec-4
|
delay(1000);
}
Anmerkungen und Warnungen
Wenn vorzeichenbehaftete Variablen ihre maximale oder minimale Kapazität überschreiten, laufen sie über (Overflow).
Das Ergebnis eines Überlaufs ist unvorhersehbar, daher sollte dies vermieden werden.
Ein typisches Symptom für einen Überlauf ist die Variable, die von ihrer maximalen Kapazität auf das Minimum "umgedreht" wird oder umgekehrt, dies ist jedoch nicht immer der Fall.
Wenn du dieses Verhalten wünscht, verwende unsigned int.
Siehe auch
SPRACHE Ganzzahlkonstanten
|
https://www.arduino.cc/reference/de/language/variables/data-types/int/index.html
|
c506b4a4fa2f-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Variables
> Data types
> Word
word
[Data Types]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/data-types/word/index.html
|
c506b4a4fa2f-1
|
> Word
word
[Data Types]
Beschreibung
Ein Wort kann eine vorzeichenlose Zahl von mindestens 16 Bits (von 0 bis 65535) speichern.
Syntax
word var = val
Parameter
var: Variablennamen.
val: Der Wert, der dieser Variablen zugewiesen werden soll.
Beispielcode
word w = 10000;
Siehe auch
|
https://www.arduino.cc/reference/de/language/variables/data-types/word/index.html
|
2e7fe65a39f7-0
|
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
> Language
> Variables
> Data types
> Float
float
[Data Types]
Beschreibung
Datentyp für Fließkommazahlen, eine Zahl mit Dezimalpunkt.
|
https://www.arduino.cc/reference/de/language/variables/data-types/float/index.html
|
2e7fe65a39f7-1
|
Datentyp für Fließkommazahlen, eine Zahl mit Dezimalpunkt.
Fließkommazahlen werden häufig zur Annäherung an analoge und kontinuierliche Werte verwendet, da sie eine höhere Auflösung als ganze Zahlen haben.
Fließkommazahlen können bis zu 3.4028235E+38 und bis zu -3.4028235E+38 betragen. Sie werden als 32 Bit (4 Byte) Informationen gespeichert.
Syntax
float var=val
Parameter
var: Variablenname.
val: Der Wert, der der Variablen zugewiesen wird.
Beispielcode
float myfloat;
float sensorCalbrate = 1.117;
int x;
int y;
float z;
x = 1;
|
https://www.arduino.cc/reference/de/language/variables/data-types/float/index.html
|
2e7fe65a39f7-2
|
int x;
int y;
float z;
x = 1;
y = x / 2; // y enthält jetzt 0, ints können keine Brüche enthalten
z = (float)x / 2.0; // z enthält jetzt .5 (Du musst 2.0 verwenden, nicht 2)
Anmerkungen und Warnungen
Wenn du mit floats rechnest, musst du ein Dezimalzeichen hinzufügen, andernfalls wird es als int behandelt. Siehe die Fließpunkt-Konstanten-Seite für weitere Informationen.
Floats haben eine Genauigkeit von nur 6-7 Dezimalstellen. Das bedeutet die Gesamtzahl der Ziffern, nicht die Zahl rechts vom Dezimalpunkt.
|
https://www.arduino.cc/reference/de/language/variables/data-types/float/index.html
|
2e7fe65a39f7-3
|
Im Gegensatz zu anderen Plattformen, bei denen du durch die Verwendung eines double (z. B. bis zu 15 Ziffern) eine höhere Genauigkeit erzielen kannst, hat double auf dem Arduino die gleiche Größe wie float.
Fließkommazahlen sind nicht genau und können beim Vergleich zu seltsamen Ergebnissen führen. Zum Beispiel kann 6.0 / 3.0 nicht gleich 2.0 sein.
Du solltest stattdessen überprüfen, ob der absolute Wert der Differenz zwischen den Zahlen geringer als eine kleine Zahl ist.
Die Konvertierung von Gleitkomma- in Ganzzahl-Mathematik führt zu Kürzungen:
float x = 2.9; // Eine float-Variable
int y = x; // 2
|
https://www.arduino.cc/reference/de/language/variables/data-types/float/index.html
|
2e7fe65a39f7-4
|
int y = x; // 2
Wenn du stattdessen während des Konvertierungsprozesses abrunden möchtest, musst du 0,5 addieren:
float x = 2.9;
int y = x + 0.5; // 3
oder die round()-Funktion nutzen:
float x = 2.9;
int y = round(x); // 3
Die Gleitkomma-Mathematik ist bei Berechnungen auch viel langsamer als die Ganzzahl-Mathematik.
Es sollte also vermieden werden, wenn beispielsweise eine Schleife für eine kritische Timing-Funktion mit Höchstgeschwindigkeit laufen muss.
|
https://www.arduino.cc/reference/de/language/variables/data-types/float/index.html
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.