id
stringlengths 14
16
| text
stringlengths 10
1.45k
| source
stringlengths 46
118
|
|---|---|---|
2f4c6fabc86a-1
|
Wird verwendet, um eine Anweisung zu beenden.
Beispielcode
int a = 13;
float b = 17.1;
Anmerkungen und Warnungen
Wenn du vergisst, eine Zeile in einem Semikolon zu beenden, wird ein Compiler-Fehler ausgegeben.
Der Fehlertext kann offensichtlich sein und sich auf ein fehlendes Semikolon beziehen oder nicht.Wenn ein undurchdringlicher oder
scheinbar unlogischer Compiler-Fehler auftritt, ist eines der ersten zu überprüfenden Dinge ein fehlendes Semikolon in unmittelbarer Nähe
vor der Zeile, in der sich der Compiler beschwert hat.
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/further-syntax/semicolon/index.html
|
5a1e2ea50c60-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
> Further syntax
> Singlelinecomment
//
[Further Syntax]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/further-syntax/singlelinecomment/index.html
|
5a1e2ea50c60-1
|
//
[Further Syntax]
Beschreibung
Kommentare sind Zeilen im Programm, die dazu dienen, sich oder andere über die Funktionsweise des Programms zu informieren.
Sie werden vom Compiler ignoriert und nicht in den Prozessor exportiert, sodass sie keinen Platz im Flash-Speicher des Mikrocontrollers beanspruchen.
Der einzige Zweck von Kommentaren besteht darin, zu helfen (zu verstehen oder sich daran zu erinnern) oder andere über die Funktionsweise des Programms zu informieren.
Ein einzeiliger Kommentar beginnt mit // (zwei nebeneinanderliegende Schrägstriche).
Dieser Kommentar endet automatisch am Ende einer Zeile. Alles, was bis zum Ende einer Zeile auf // folgt, wird vom Compiler ignoriert.
Beispielcode
|
https://www.arduino.cc/reference/de/language/structure/further-syntax/singlelinecomment/index.html
|
5a1e2ea50c60-2
|
Beispielcode
Es gibt zwei Möglichkeiten, eine Zeile als Kommentar zu kennzeichnen:
// An Pin 13 ist an den meisten Arduino-Boards eine LED angeschlossen.
int led = 13;
digitalWrite(led, HIGH); // LED einschalten (HIGH ist der Spannungspegel)
Anmerkungen und Warnungen
Beim Experimentieren mit Code ist das Herauskommentieren von Programmteilen eine bequeme Möglichkeit, fehlerhafte Zeilen zu entfernen.
Dadurch bleiben die Zeilen im Code erhalten, werden jedoch in Kommentare umgewandelt, sodass der Compiler sie einfach ignoriert.
Dies kann besonders nützlich sein, wenn Sie versuchen, ein Problem zu finden, oder wenn ein Programm die Kompilierung ablehnt und der Compilerfehler kryptisch oder nicht hilfreich ist.
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/further-syntax/singlelinecomment/index.html
|
78f1924bc589-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
> Comparison operators
> Lessthanorequalto
<=
[Comparison Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/comparison-operators/lessthanorequalto/index.html
|
78f1924bc589-1
|
<=
[Comparison Operators]
Beschreibung
Vergleicht die linke Variable mit dem Wert oder der Variablen rechts vom Operator. Gibt true zurück, wenn der Operand links kleiner oder gleich dem Operanden rechts ist.
Syntax
x ⇐ y; // Ist true, wenn x kleiner oder gleich y ist und false, wenn x größer als y ist
Parameter
x: Variable. Erlaubte Datentypen: int, float, double, byte, short, long.
y: Variable oder Konstante. Erlaubte Datentypen: int, float, double, byte, short, long.
Beispielcode
if (x <= y) { // Prüft, ob x kleiner oder gleich y ist
// Tue etwas nur dann, wenn das Vergleichsergebnis wahr ist
}
Anmerkungen und Warnungen
|
https://www.arduino.cc/reference/de/language/structure/comparison-operators/lessthanorequalto/index.html
|
78f1924bc589-2
|
}
Anmerkungen und Warnungen
Negative Zahlen sind kleiner als positive Zahlen.
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/comparison-operators/lessthanorequalto/index.html
|
f61e3ae57829-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
> Comparison operators
> Lessthan
<
[Comparison Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/comparison-operators/lessthan/index.html
|
f61e3ae57829-1
|
<
[Comparison Operators]
Beschreibung
Vergleicht die linke Variable mit dem Wert oder der Variablen rechts vom Operator. Gibt true zurück, wenn der Operand links kleiner als der Operand rechts ist.
Syntax
x < y; // Ist true, wenn x kleiner als y ist und false, wenn x gleich oder größer als y ist
Parameter
x: Variable. Erlaubte Datentypen: int, float, double, byte, short, long.
y: Variable oder Konstante. Erlaubte Datentypen: int, float, double, byte, short, long.
Beispielcode
if (x < y) { // Prüft, ob x kleiner als y ist
// Tue etwas nur dann, wenn das Vergleichsergebnis wahr istue
}
Anmerkungen und Warnungen
|
https://www.arduino.cc/reference/de/language/structure/comparison-operators/lessthan/index.html
|
f61e3ae57829-2
|
}
Anmerkungen und Warnungen
Negative Zahlen sind kleiner als positive Zahlen.
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/comparison-operators/lessthan/index.html
|
0572853830a1-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
> Comparison operators
> Equalto
==
[Comparison Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/comparison-operators/equalto/index.html
|
0572853830a1-1
|
==
[Comparison Operators]
Beschreibung
Vergleicht die linke Variable mit dem Wert oder der Variablen rechts vom Operator. Gibt true zurück, wenn die beiden Operanden gleich sind.
Syntax
x == y; // Ist true, wenn x gleich y ist und false, wenn x nicht gleich y ist
Parameter
x: Variable. Erlaubte Datentypen: int, float, double, byte, short, long.
y: Variable oder Konstante. Erlaubte Datentypen: int, float, double, byte, short, long.
Beispielcode
if (x == y) { // Prüft, ob x gleich y ist
// Tue etwas nur dann, wenn das Vergleichsergebnis wahr ist
}
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/comparison-operators/equalto/index.html
|
5492607142a7-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
> Comparison operators
> Greaterthan
>
[Comparison Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/comparison-operators/greaterthan/index.html
|
5492607142a7-1
|
>
[Comparison Operators]
Beschreibung
Vergleicht die linke Variable mit dem Wert oder der Variablen rechts vom Operator. Gibt true zurück, wenn der linke Operand größer ist als der rechte Operand.
Syntax
x > y // Ist true, wenn x größer als y ist und ist false, wenn x kleiner oder gleich y ist
Parameter
x: Variable. Erlaubte Datentypen: int, float, double, byte, short, long.
y: Variable oder Konstante. Erlaubte Datentypen: int, float, double, byte, short, long.
Beispielcode
if (x > y) { // Prüft, ob x größer als y ist
// Tue etwas nur dann, wenn das Vergleichsergebnis wahr ist
}
Anmerkungen und Warnungen
|
https://www.arduino.cc/reference/de/language/structure/comparison-operators/greaterthan/index.html
|
5492607142a7-2
|
}
Anmerkungen und Warnungen
Positive Zahlen sind größer als negative Zahlen.
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/comparison-operators/greaterthan/index.html
|
1b3f08c5b483-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
> Comparison operators
> Greaterthanorequalto
>=
[Comparison Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/comparison-operators/greaterthanorequalto/index.html
|
1b3f08c5b483-1
|
>=
[Comparison Operators]
Beschreibung
Vergleicht die linke Variable mit dem Wert oder der Variablen rechts vom Operator. Gibt true zurück, wenn der Operand links größer als oder gleich dem Operanden rechts ist.
Syntax
x >= y; // Ist true, wenn x größer als oder gleich y ist und false, wenn x kleiner als y ist
Parameter
x: Variable. Erlaubte Datentypen: int, float, double, byte, short, long.
y: Variable oder Konstante. Erlaubte Datentypen: int, float, double, byte, short, long.
Beispielcode
if (x >= y) { // Prüft, ob x größer als oder gleich y ist
// Tue etwas nur dann, wenn das Vergleichsergebnis wahr ist
}
Anmerkungen und Warnungen
|
https://www.arduino.cc/reference/de/language/structure/comparison-operators/greaterthanorequalto/index.html
|
1b3f08c5b483-2
|
}
Anmerkungen und Warnungen
Positive Zahlen sind größer als negative Zahlen.
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/comparison-operators/greaterthanorequalto/index.html
|
151f36490e67-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
> Comparison operators
> Notequalto
!=
[Comparison Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/comparison-operators/notequalto/index.html
|
151f36490e67-1
|
!=
[Comparison Operators]
Beschreibung
Vergleicht die linke Variable mit dem Wert oder der Variablen rechts vom Operator. Gibt true zurück, wenn die beiden Operanden nicht gleich sind.
Syntax
x != y; // Ist false, wenn x gleich y ist und true, wenn x nicht gleich y ist
Parameter
x: Variable. Erlaubte Datentypen: int, float, double, byte, short, long.
y: Variable oder Konstante. Erlaubte Datentypen: int, float, double, byte, short, long.
Beispielcode
if (x != y) { / Prüft, ob x nicht gleich y ist
// Tue etwas nur dann, wenn das Vergleichsergebnis wahr ist
}
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/comparison-operators/notequalto/index.html
|
ab87b2989c6a-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
> Pointer access operators
> Dereference
*
[Pointer Access Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/pointer-access-operators/dereference/index.html
|
ab87b2989c6a-1
|
*
[Pointer Access Operators]
Beschreibung
Dereferenzierung ist eines der Features, bei denen Zeiger benötigt werden. Der Operator * wird dafür verwendet.
Wenn p ein Zeiger ist, dann ist *p der Wert, der in der Adresse enthalten ist, auf die p zeigt.
Beispielcode
Der Code zeigt ein kleines Rechenbeispiel zur Verwendung von Zeigern.
int *p; // Definiere einen Zeiger als Integerdatentyp
int i = 5;
int result = 0; // Initialisiere 'i' mit 5 und 'result' mit 0
p = &i; // 'p' enthält nun die Adress von 'i'
result = *p; // 'result' erhält nun den Wert, der an der Adress von 'i' steht
|
https://www.arduino.cc/reference/de/language/structure/pointer-access-operators/dereference/index.html
|
ab87b2989c6a-2
|
// 'result' ist also 5
Anmerkungen und Warnungen
Zeiger sind eines der komplexesten Themen für Anfänger beim Lernen von C. Es ist aber möglich, den Großteil der Arduino-Sketches ohne eine
einzige Verwendung von Zeigern zu schreiben. Zur Verwendung einiger Datenstrukturen sind Pointer aber unersätzlich und bieten eine starke
Vereinfachung des Codes an.
Siehe auch
DEFINITION Pointers
|
https://www.arduino.cc/reference/de/language/structure/pointer-access-operators/dereference/index.html
|
2c5d88fddf5e-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
> Pointer access operators
> Reference
&
[Pointer Access Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/pointer-access-operators/reference/index.html
|
2c5d88fddf5e-1
|
&
[Pointer Access Operators]
Beschreibung
Referenzierung ist eines der Features, bei denen Zeiger benötigt werden. Der Operator & wird dafür verwendet.
Wenn x eine Variable ist, dann ist &x die Adresse der Variable x.
Beispielcode
Der Code zeigt ein kleines Rechenbeispiel zur Verwendung von Zeigern.
int *p; // Definiere einen Zeiger als Integerdatentyp
int i = 5;
int result = 0; // Initialisiere 'i' mit 5 und 'result' mit 0
p = &i; // 'p' enthält nun die Adress von 'i'
result = *p; // 'result' erhält nun den Wert, der an der Adress von 'i' steht
// 'result' ist also 5
Anmerkungen und Warnungen
|
https://www.arduino.cc/reference/de/language/structure/pointer-access-operators/reference/index.html
|
2c5d88fddf5e-2
|
// 'result' ist also 5
Anmerkungen und Warnungen
Zeiger sind eines der komplexesten Themen für Anfänger beim Lernen von C. Es ist aber möglich, den Großteil der Arduino-Sketches ohne eine
einzige Verwendung von Zeigern zu schreiben. Zur Verwendung einiger Datenstrukturen sind Pointer aber unersätzlich und bieten eine starke
Vereinfachung des Codes an.
Siehe auch
DEFINITION Pointers
|
https://www.arduino.cc/reference/de/language/structure/pointer-access-operators/reference/index.html
|
0c6c04aa0b97-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
> Compound operators
> Compounddivision
/=
[Compound Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compounddivision/index.html
|
0c6c04aa0b97-1
|
/=
[Compound Operators]
Beschreibung
Dies ist eine praktische Abkürzung, um die Division einer Variablen mit einer anderen Konstante oder Variablen durchzuführen.
Syntax
x /= y; // Äquivalent zum Ausdruck x = x / y
Parameter
x: Variable. Erlaubte Datentypen: int, float, double, byte, short, long.
y: nicht null Variable oder Konstante. Erlaubte Datentypen: int, float, double, byte, short, long.
Beispielcode
x = 2;
x /= 2; // x enthält jetzt 1
Siehe auch
SPRACHE Normale Division
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compounddivision/index.html
|
3e6629909118-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
> Compound operators
> Compoundmultiplication
*=
[Compound Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compoundmultiplication/index.html
|
3e6629909118-1
|
*=
[Compound Operators]
Beschreibung
Dies ist eine praktische Abkürzung, um eine Multiplikation einer Variablen mit einer anderen Konstanten oder Variablen durchzuführen.
Syntax
x *= y; // Äquivalent zum Ausdruck x = x * y
Parameter
x: Variable. Erlaubte Datentypen: int, float, double, byte, short, long.
y: Variable oder Konstante. Erlaubte Datentypen: int, float, double, byte, short, long.
Beispielcode
x = 2;
x *= 2; // x enthält jetzt 4
Siehe auch
SPRACHE Normale Multiplikation
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compoundmultiplication/index.html
|
70b27bd81068-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
> Compound operators
> Compoundremainder
%=
[Compound Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compoundremainder/index.html
|
70b27bd81068-1
|
%=
[Compound Operators]
Beschreibung
Dies ist eine praktische Abkürzung, um den Rest zu berechnen, wenn eine ganze Zahl durch eine andere geteilt wird.
Syntax
x %= divisor; // Äquivalent zum Ausdruck x = x% divisor
Parameter
x: Variable. Erlaubte Datentypen: int.
divisor: nicht null Variable oder Konstante. Erlaubte Datentypen: int.
Beispielcode
int x = 7;
x %= 5; // x enthält jetzt 2
Anmerkungen und Warnungen
Der zusammengsetzte Rest-Operator funktioniert nicht mit floats.
Wenn der erste Operand negativ ist, ist das Ergebnis negativ (oder null).
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compoundremainder/index.html
|
70b27bd81068-2
|
Wenn der erste Operand negativ ist, ist das Ergebnis negativ (oder null).
Daher ist das Ergebnis von x% = 10 nicht immer zwischen 0 und 9, wenn x negativ sein kann.
Siehe auch
SPRACHE Rest
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compoundremainder/index.html
|
3d45bac43746-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
> Compound operators
> Compoundbitwiseor
|=
[Compound Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compoundbitwiseor/index.html
|
3d45bac43746-1
|
|=
[Compound Operators]
Beschreibung
Der zusammengesetzte bitweise OR-Operator | = wird häufig mit einer Variablen und einer Konstante verwendet, um bestimmte Bits in einer Variablen "zu setzen" (auf 1 zu setzen).
Ein Überblick über den bitweisen OR | Operator:
0 0 1 1 operand1
0 1 0 1 operand2
----------
0 1 1 1 (operand1 | operand2) - Ergebnis
Syntax
x |= y; // Äquivalent zu x = x | y
Parameter
x: Variable. Erlaubte Datentypen: char, int, long.
y: Variable oder Konstante. Erlaubte Datentypen: char, int, long.
Beispielcode
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compoundbitwiseor/index.html
|
3d45bac43746-2
|
Beispielcode
Bits, die "bitweise verODERt" mit 0 sind, bleiben unverändert, wenn myByte eine Byte-Variable ist:
myByte | B00000000 = myByte;
Bits, die "bitweise verODERt" mit 1 sind, werden auf 1 gesetzt:
myByte | B11111111 = B11111111;
Anmerkungen und Warnungen
Da es sich um einen bitweisen Operator handelt, ist es sinnvoll, den binären Formatierer mit Konstanten zu verwenden.
Die Zahlen haben in anderen Darstellungen immer noch den gleichen Wert, sie sind einfach nicht so leicht zu verstehen.
Außerdem wird B00000000 zur Verdeutlichung gezeigt, aber Null in einem beliebigen Zahlenformat ist Null.
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compoundbitwiseor/index.html
|
3d45bac43746-3
|
Um die Bits 0 und 1 einer Variablen zu setzen, während der Rest der Variablen unverändert bleibt,
verwende den zusammengesetzten bitweisen OR-Operator (| =) mit der Konstanten B00000011
1 0 1 0 1 0 1 0 Variable
0 0 0 0 0 0 1 1 Maske
----------------------
1 0 1 0 1 0 1 1
Bits unverändert
Bits gesetzt
Hier ist die gleiche Darstellung mit den Variablenbits durch das Symbol x ersetzt
x x x x x x x x Variable
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compoundbitwiseor/index.html
|
3d45bac43746-4
|
x x x x x x x x Variable
0 0 0 0 0 0 1 1 Maske
----------------------
x x x x x x 1 1
Bits unverändert
Bits gesetzt
Also ergibt:
myByte = B10101010;
myByte |= B00000011 == B10101011;
Siehe auch
SPRACHE & Bitweises OR
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compoundbitwiseor/index.html
|
d43f2d97b4a7-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
> Compound operators
> Compoundbitwiseand
&=
[Compound Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compoundbitwiseand/index.html
|
d43f2d97b4a7-1
|
&=
[Compound Operators]
Beschreibung
Der zusammengesetzte bitweise AND-Operator & = wird häufig mit einer Variablen und einer Konstanten verwendet, um bestimmte Bits in einer Variablen in den Zustand LOW (auf 0) zu bringen.
Dies wird in Programmierhandbüchern oft als "Löschen" oder "Zurücksetzen" der Bits bezeichnet.
Ein Überblick über den bitweisen AND & Operator:
0 0 1 1 operand1
0 1 0 1 operand2
----------
0 0 0 1 (operand1 & operand2) - Ergebnis
Syntax
x &= y; // Äquivalent zu x = x & y
Parameter
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compoundbitwiseand/index.html
|
d43f2d97b4a7-2
|
Syntax
x &= y; // Äquivalent zu x = x & y
Parameter
x: Variable. Erlaubte Datentypen: char, int, long.
y: Variable oder Konstante. Erlaubte Datentypen: char, int, long.
Beispielcode
Bits, die "bitweise verUNDet" mit 0 sind, werden auf 0 zurückgesetzt, wenn myByte eine Byte-Variable ist:
myByte & B00000000 = 0;
Bits die "bitweise verUNDet" mit 1 sind, werden nicht verändert:
myByte & B11111111 = myByte;
Anmerkungen und Warnungen
Da es sich um einen bitweisen Operator handelt, ist es sinnvoll, den binären Formatierer mit Konstanten zu verwenden.
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compoundbitwiseand/index.html
|
d43f2d97b4a7-3
|
Die Zahlen haben in anderen Darstellungen immer noch den gleichen Wert, sie sind einfach nicht so leicht zu verstehen.
Außerdem wird B00000000 zur Verdeutlichung gezeigt, aber Null in einem beliebigen Zahlenformat ist Null.
Um die Bits 0 & 1 einer Variablen zu löschen (auf Null zu setzen), während der Rest der Variablen unverändert bleibt,
verwende den zusammengesetzten bitweisen AND-Operator (& =) mit der Konstanten B11111100
1 0 1 0 1 0 1 0 Variable
1 1 1 1 1 1 0 0 Maske
----------------------
1 0 1 0 1 0 0 0
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compoundbitwiseand/index.html
|
d43f2d97b4a7-4
|
Bits unverändert
Bits gelöscht
Hier ist die gleiche Darstellung, wobei die Bits der Variablen durch das Symbol x ersetzt werden
x x x x x x x x Variable
1 1 1 1 1 1 0 0 Maske
----------------------
x x x x x x 0 0
Bits unverändert
Bits gelöscht
Also ergibt:
myByte = B10101010;
myByte &= B11111100; // Ergibt B10101000
Siehe auch
SPRACHE & Bitweises AND
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compoundbitwiseand/index.html
|
ef162f2e2df6-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
> Compound operators
> Increment
++
[Compound Operators]
Beschreibung
Erhöht den Wert einer Variablen um 1.
Syntax
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/increment/index.html
|
ef162f2e2df6-1
|
Erhöht den Wert einer Variablen um 1.
Syntax
x++; // x um eins erhöhen und den alten Wert von x zurückgeben
++x; // x um eins erhöhen und den neuen Wert von x zurückgeben
Parameter
x: Variable. Erlaubte Datentypen: int, long (vermutlich unsigned).
Rückgabewert
Den ursprünglichen oder den neu inkrementierten Wert der Variablen.
Beispielcode
x = 2;
y = ++x; // x enthält jetzt 3, y enthält 3
y = x++; // x enthält 4, aber y enthält noch 3
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/increment/index.html
|
45e9af76bc03-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
> Compound operators
> Compoundsubtraction
-=
[Compound Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compoundsubtraction/index.html
|
45e9af76bc03-1
|
-=
[Compound Operators]
Beschreibung
Dies ist eine praktische Abkürzung, um eine Konstante oder eine Variable von einer Variablen abzuziehen.
Syntax
x -= y; // Äquivalent zum Ausdruck x = x - y
Parameter
x: Variable. Erlaubte Datentypen: int, float, double, byte, short, long.
y: Variable oder Konstante. Erlaubte Datentypen: int, float, double, byte, short, long.
Beispielcode
x = 20;
x -= 2; // x enthält jetzt 18
Siehe auch
SPRACHE Normale Subtraktion
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compoundsubtraction/index.html
|
a45fe8bb9ea3-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
> Compound operators
> Decrement
--
[Compound Operators]
Beschreibung
Dekrementiert den Wert einer Variablen um 1.
Syntax
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/decrement/index.html
|
a45fe8bb9ea3-1
|
Dekrementiert den Wert einer Variablen um 1.
Syntax
x-- ; // Dekrementiert x um eins und gibt den alten Wert von x zurück
--x ; // Dekrementiert x um eins und gibt den neuen Wert von x zurück
Parameter
x: Variable. Erlaubte Datentypen: int, long (vermutlich unsigned).
Rückgabewert
Den ursprünglichen oder den neu dekrementierten Wert der Variablen.
Beispielcode
x = 2;
y = --x; // x enthält jetzt 1, y enthält 1
y = x--; // x enthält 0, aber y enthält noch 1
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/decrement/index.html
|
ac5ac46af98c-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
> Compound operators
> Compoundaddition
+=
[Compound Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compoundaddition/index.html
|
ac5ac46af98c-1
|
+=
[Compound Operators]
Beschreibung
Dies ist eine praktische Abkürzung, um eine Variable mit einer anderen Konstanten oder Variablen zu addieren.
Syntax
x += y; // Äquivalent zum Ausdruck x = x + y
Parameter
x: Variable. Erlaubte Datentypen: int, float, double, byte, short, long.
y: Variable oder Konstante. Erlaubte Datentypen: int, float, double, byte, short, long.
Beispielcode
x = 2;
x += 4; // x enthält jetzt 6
Siehe auch
SPRACHE Normale Addition
|
https://www.arduino.cc/reference/de/language/structure/compound-operators/compoundaddition/index.html
|
6c720d875569-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
> Arithmetic operators
> Modulo
%
[Arithmetic Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/modulo/index.html
|
6c720d875569-1
|
%
[Arithmetic Operators]
Beschreibung
Die Operation Modulo berechnet den Rest, wenn eine ganze Zahl durch eine andere geteilt wird.
Dies ist nützlich, um eine Variable innerhalb eines bestimmten Bereichs zu halten (z. B. die Größe eines Arrays).
Das % (Prozent) -Symbol wird zur Ausführung der Modulo-Operation verwendet.
Syntax
remainder = dividend % divisor
Parameter
remainder: Variable. Erlaubte Datentypen: int, float, double.
dividend: Variable oder Konstante. Erlaubte Datentypen: int.
divisor: Nicht null Variable oder Konstante. Erlaubte Datentypen: int.
Beispielcode
int x = 0;
x = 7 % 5; // x enthält jetzt 2
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/modulo/index.html
|
6c720d875569-2
|
x = 7 % 5; // x enthält jetzt 2
x = 9 % 5; // x enthält jetzt 4
x = 5 % 5; // x enthält jetzt 0
x = 4 % 5; // x enthält jetzt 4
/* Aktualisieren eines Werts in einem Array durch eine Schleife */
int values[10];
int i = 0;
void setup() {}
void loop()
{
values[i] = analogRead(0);
i = (i + 1) % 10; // Modulo-Operator überschreibt Variable
}
Anmerkungen und Warnungen
Der Modulo-Operator arbeitet nicht mit float-Werten.
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/modulo/index.html
|
578ab6a09a18-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
> Arithmetic operators
> Addition
+
[Arithmetic Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/addition/index.html
|
578ab6a09a18-1
|
+
[Arithmetic Operators]
Beschreibung
Addition ist eine der vier primären Rechenoperationen. Der Operator + (plus) bearbeitet zwei Operanden, um die Summe zu erzeugen.
Syntax
sum = operand1 + operand2
Parameter
sum: Variable. Erlaubte Datentypen: int, float, double, byte, short, long.
operand1: Variable oder Konstante. Erlaubte Datentypen: int, float, double, byte, short, long.
operand2: Variable oder Konstante. Erlaubte Datentypen: int, float, double, byte, short, long.
Beispielcode
int a = 5;
int b = 10;
int c = 0;
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/addition/index.html
|
578ab6a09a18-2
|
int b = 10;
int c = 0;
c = a + b; // Die Variable 'c' erhält einen Wert von 15, nachdem diese Anweisung ausgeführt wurde
Anmerkungen und Warnungen
Die Additionsoperation kann überlaufen, wenn das Ergebnis größer ist als das Ergebnis, das im Datentyp gespeichert werden kann (z. B. ergibt das Hinzufügen von 1 zu einer Ganzzahl mit dem Wert 32,767 den Wert -32,768).
Wenn eine der Zahlen (Operanden) vom Typ float oder vom Typ double ist, wird für die Berechnung Fließkomma-Mathematik verwendet.
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/addition/index.html
|
578ab6a09a18-3
|
Wenn die Operanden vom Datentyp float / double sind und die Variable, die die Summe speichert, eine Ganzzahl ist, wird nur die Ganzzahl gespeichert, der Bruchteil der Zahl geht verloren.
float a = 5.5
float b = 6.6;
int c = 0;
c = a + b; // Die Variable 'c' speichert nur den Wert 12 gegenüber der erwarteten Summe von 12,1
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/addition/index.html
|
8685b346e79b-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
> Arithmetic operators
> Assignment
=
[Arithmetic Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/assignment/index.html
|
8685b346e79b-1
|
=
[Arithmetic Operators]
Beschreibung
Das einfache Gleichheitszeichen = in der Programmiersprache C ++ wird als Zuweisungsoperator bezeichnet.
Es hat eine andere Bedeutung als in der Algebra, wo es eine Gleichung oder Gleichheit angibt.
Der Zuweisungsoperator weist den Mikrocontroller an, den Wert oder Ausdruck auf der rechten Seite des Gleichheitszeichens auszuwerten und in der Variablen links vom Gleichheitszeichen zu speichern.
Beispielcode
int sensVal; // Deklarieren einer Integer-Variable mit dem Namen sensVal
sensVal = analogRead(0); // Speichern der (digitalisierten) Eingangsspannung am Analogpin 0 in sensVal
Anmerkungen und Warnungen
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/assignment/index.html
|
8685b346e79b-2
|
Anmerkungen und Warnungen
Die Variable auf der linken Seite des Zuweisungsoperators (=-Zeichen) muss den darin gespeicherten Wert enthalten können. Wenn er nicht groß genug ist, um einen Wert zu speichern, ist der in der Variablen gespeicherte Wert falsch.
Verwechsele den Zuweisungsoperator = (einfaches Gleichheitszeichen) nicht mit dem Vergleichsoperator == (doppelte Gleichheitszeichen), der bewertet, ob zwei Ausdrücke gleich sind.
Siehe auch
SPRACHE if (conditional operators)
SPRACHE char
SPRACHE int
SPRACHE long
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/assignment/index.html
|
17aaab854403-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
> Arithmetic operators
> Division
/
[Arithmetic Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/division/index.html
|
17aaab854403-1
|
/
[Arithmetic Operators]
Beschreibung
Division ist eine der vier primären Rechenoperationen. Der Operator / (Schrägstrich) bearbeitet zwei Operanden, um das Ergebnis zu erzeugen.
Syntax
result = numerator / denominator
Parameter
result: Variable. Erlaubte Datentypen: int, float, double, byte, short, long.
numerator: Variable oder Konstante. Erlaubte Datentypen: int, float, double, byte, short, long.
denominator: Nicht null Variable oder Konstante. Erlaubte Datentypen: int, float, double, byte, short, long.
Beispielcode
int a = 50;
int b = 10;
int c = 0;
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/division/index.html
|
17aaab854403-2
|
int b = 10;
int c = 0;
c = a / b; // Die Variable 'c' erhält einen Wert von 5, nachdem diese Anweisung ausgeführt wurde
Anmerkungen und Warnungen
Wenn eine der Zahlen (Operanden) vom Typ float oder vom Typ double ist, wird für die Berechnung Fließkomma-Mathematik verwendet.
Wenn die Operanden vom Datentyp float / double sind und die Variable, die das Ergebnis speichert, eine Ganzzahl ist, wird nur die Ganzzahl gespeichert und der Bruchteil der Zahl geht verloren.
float a = 55.5;
float b = 6.6;
int c = 0;
c = a / b; // Die Variable 'c' speichert nur den Wert 8 im Gegensatz zum erwarteten Ergebnis von 8,409
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/division/index.html
|
17aaab854403-3
|
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/division/index.html
|
00a223298121-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
> Arithmetic operators
> Multiplication
*
[Arithmetic Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/multiplication/index.html
|
00a223298121-1
|
*
[Arithmetic Operators]
Beschreibung
Multiplikation ist eine der vier primären Rechenoperationen. Der Operator * (Sternchen) bearbeitet zwei Operanden, um das Produkt zu erzeugen.
Syntax
product = operand1 * operand2
Parameter
product: Variable. Erlaubte Datentypen: int, float, double, byte, short, long.
operand1: Variable oder Konstante. Erlaubte Datentypen: int, float, double, byte, short, long.
operand2: Variable oder Konstante. Erlaubte Datentypen: int, float, double, byte, short, long.
Beispielcode
int a = 5;
int b = 10;
int c = 0;
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/multiplication/index.html
|
00a223298121-2
|
int b = 10;
int c = 0;
c = a * b; // Die Variable 'c' erhält einen Wert von 50, nachdem diese Anweisung ausgeführt wurde
Anmerkungen und Warnungen
Die Multiplikationsoperation kann überlaufen, wenn das Ergebnis größer ist als das, welches im Datentyp gespeichert werden kann.
Wenn eine der Zahlen (Operanden) vom Typ float oder vom Typ double ist, wird für die Berechnung Fließkomma-Mathematik verwendet.
Wenn die Operanden vom Datentyp float / double sind und die Variable, in der das Produkt gespeichert wird, eine ganze Zahl ist, wird nur die Ganzzahl gespeichert und der Bruchteil der Zahl geht verloren.
float a = 5.5;
float b = 6.6;
int c = 0;
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/multiplication/index.html
|
00a223298121-3
|
float b = 6.6;
int c = 0;
c = a * b; // Die Variable 'c' speichert nur den Wert 36 und nicht das erwartete Produkt 36,3
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/multiplication/index.html
|
a1932de18a5e-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
> Arithmetic operators
> Subtraction
-
[Arithmetic Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/subtraction/index.html
|
a1932de18a5e-1
|
-
[Arithmetic Operators]
Beschreibung
Subtraktion ist eine der vier primären Rechenoperationen. Der Operator - (minus) verarbeitet zwei Operanden, um die Differenz des zweiten zum ersten zu erzeugen.
Syntax
difference = operand1 - operand2
Parameter
difference: Variable. Erlaubte Datentypen: int, float, double, byte, short, long.
operand1: Variable oder Konstante. Erlaubte Datentypen: int, float, double, byte, short, long.
operand2: Variable oder Konstante. Erlaubte Datentypen: int, float, double, byte, short, long.
Beispielcode
int a = 5;
int b = 10;
int c = 0;
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/subtraction/index.html
|
a1932de18a5e-2
|
int b = 10;
int c = 0;
c = a - b; // Die Variable 'c' erhält nach der Ausführung dieser Anweisung einen Wert von -5
Anmerkungen und Warnungen
Die Subtraktionsoperation kann überlaufen, wenn das Ergebnis kleiner als das ist, das in dem Datentyp gespeichert werden kann (z. B. ergibt das Subtrahieren von 1 von einer Ganzzahl mit dem Wert -32,768 den Wert 32,767).
Wenn eine der Zahlen (Operanden) vom Typ float oder vom Typ double ist, wird für die Berechnung Fließkomma-Mathematik verwendet.
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/subtraction/index.html
|
a1932de18a5e-3
|
Wenn die Operanden vom Datentyp float / double sind und die Variable, die die Differenz speichert, eine Ganzzahl ist, wird nur die Ganzzahl gespeichert und der Bruchteil der Zahl geht verloren.
float a = 5.5;
float b = 6.6;
int c = 0;
c = a - b; // Die Variable 'c' speichert nur den Wert -1 und nicht die erwartete Differenz von -1.1
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/arithmetic-operators/subtraction/index.html
|
379e92f5aef6-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
> Sketch
> Setup
setup()
[Sketch]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/sketch/setup/index.html
|
379e92f5aef6-1
|
> Setup
setup()
[Sketch]
Beschreibung
Die setup() wird jedes Mal aufgerufen, wenn der Sketch startet. Sie soll benutzt werden, um Variablen, Pinmodi, Bibliotheken, usw. zu initialisieren.
Die Funktion wird nur ein einziges Mal aufgerufen: Jedes Mal, wenn das Board gestartet oder resettet wird.
Beispielcode
Der Code zeigt ein kleines Beispiel, welches den einen Inputpin festlegt.
// Lege Button auf Pin 3
int buttonPin = 3;
void setup() {
// Starte die serielle Verbindung
Serial.begin(9600);
// Setze den Pin 3 als Inputpin
pinMode(buttonPin, INPUT);
}
void loop() {
// ...
}
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/sketch/setup/index.html
|
3256e309869c-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
> Sketch
> Loop
loop()
[Sketch]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/sketch/loop/index.html
|
3256e309869c-1
|
> Loop
loop()
[Sketch]
Beschreibung
Nach dem Erstellen einer setup()- Funktion, die die Anfangswerte (Variablen, Pins und Bibliotheken) initialisiert, macht die Funktion loop() genau das, was der Name andeutet.
Sie ist eine Endlosschleife, die nach jedem Durchlauf erneut aufgerufen wird. Dadurch kann dein Programm Variablen verändern, Daten lesen oder darauf reagieren.
Verwende diese Option, um das Arduino-Board aktiv zu steuern.
Beispielcode
Der Code zeigt ein kleines Beispiel, welches den einen Inputpin festlegt. Bei jedem Durchlauf wird je nach Zustand einen Wert
auf den seriellen Ausgang geschrieben. Anschließend wartet das Board eine Sekunde und beginnt den Durchlauf von Neuem.
// Lege Button auf Pin 3
|
https://www.arduino.cc/reference/de/language/structure/sketch/loop/index.html
|
3256e309869c-2
|
// Lege Button auf Pin 3
int buttonPin = 3;
void setup() {
// Starte die serielle Verbindung
Serial.begin(9600);
// Setze den Pin 3 als Inputpin
pinMode(buttonPin, INPUT);
}
// Loop checkt den Button bei jedem Durchlauf und schreibt je nach Zustand einen Wert auf den seriellen Ausgang.
void loop() {
// Wenn Pin HIGH ist, schreibe H
if (digitalRead(buttonPin) == HIGH) {
serialWrite('H');
}
// Sonst, schreibe L
else {
serialWrite('L');
}
//Warte 1 Sekunde
delay(1000);
}
Siehe auch
|
https://www.arduino.cc/reference/de/language/structure/sketch/loop/index.html
|
cfc921df1ac2-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
> Boolean operators
> Logicalnot
!
[Boolean Operators]
Beschreibung
Logical NOT führt zu einem true, wenn der Operand false ist und umgekehrt.
|
https://www.arduino.cc/reference/de/language/structure/boolean-operators/logicalnot/index.html
|
cfc921df1ac2-1
|
Logical NOT führt zu einem true, wenn der Operand false ist und umgekehrt.
Beispielcode
Dieser Operator kann in einer if-Anweisung verwendet werden.
if (!x) { // Wenn x nicht true ist
// Statement(s)
}
Es kann verwendet werden, um den booleschen Wert zu invertieren.
x = !y; // Der invertierte Wert von y wird in x gespeichert
Anmerkungen und Warnungen
Das bitweise NOT ~ (Tilde) sieht sehr anders aus als das boolesche NOT ! (Ausrufezeichen oder "Knall", wie die Programmierer sagen), aber man muss immer noch wissen, welches man will.
Siehe auch
SPRACHE ~ Bitweises NOT
|
https://www.arduino.cc/reference/de/language/structure/boolean-operators/logicalnot/index.html
|
7ebcd0c9b898-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
> Boolean operators
> Logicaland
&&
[Boolean Operators]
Beschreibung
Logisches AND führt nur zu true, wenn beide Operanden true sind.
|
https://www.arduino.cc/reference/de/language/structure/boolean-operators/logicaland/index.html
|
7ebcd0c9b898-1
|
Logisches AND führt nur zu true, wenn beide Operanden true sind.
Beispielcode
Dieser Operator kann innerhalb der Bedingung einer if-Anweisung verwendet werden.
if (digitalRead(2) == HIGH && digitalRead(3) == HIGH) { // Wenn beide Werte HIGH sind
// Statement(s)
}
Anmerkungen und Warnungen
Stelle sicher, dass der booleschen AND-Operator && (doppeltes kaufmännisches Und) nicht mit dem bitweisen AND-Operator & (einfaches kaufmännisches Und) verwechselt wird. Sie sind völlig verschieden.
Siehe auch
SPRACHE & (Bitweises UND)
|
https://www.arduino.cc/reference/de/language/structure/boolean-operators/logicaland/index.html
|
0c3619ae6b85-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
> Boolean operators
> Logicalor
||
[Boolean Operators]
Beschreibung
Logisches OR führt zu true, wenn einer der beiden Operanden true ist.
|
https://www.arduino.cc/reference/de/language/structure/boolean-operators/logicalor/index.html
|
0c3619ae6b85-1
|
Logisches OR führt zu true, wenn einer der beiden Operanden true ist.
Beispielcode
Dieser Operator kann in einer if-Anweisung verwendet werden.
if (x > 0 || y > 0) { // Wenn entweder x oder y größer als null ist
// Statement(s)
}
Anmerkungen und Warnungen
Verwechsle nicht das boolesche || (Doppel-Pipe) Operator mit dem bitweisen OR-Operator | (Einzelne Pipe).
Siehe auch
SPRACHE | Bitweises OR
|
https://www.arduino.cc/reference/de/language/structure/boolean-operators/logicalor/index.html
|
15be8fc147b8-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
> Bitwisenot
~
[Bitwise Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitwisenot/index.html
|
15be8fc147b8-1
|
~
[Bitwise Operators]
Beschreibung
Der bitweise NOT-Operator in C ++ ist das Tilde-Zeichen ~. Im Gegensatz zu & und | wird der bitweise NOT-Operator auf einen einzelnen Operanden rechts davon angewendet.
Bitweises NOT ändert jedes Bit in sein Gegenteil: 0 wird 1 und 1 wird 0.
In anderen Worten:
0 1 operand1
-----
1 0 ~operand1
Beispielcode
int a = 103; // Binär: 0000000001100111
int b = ~a; // Binär: 1111111110011000 = -104
Anmerkungen und Warnungen
Möglicherweise bist du überrascht, als Ergebnis dieses Vorgangs eine negative Zahl wie -104 zu sehen.
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitwisenot/index.html
|
15be8fc147b8-2
|
Dies liegt daran, dass das höchste Bit in einer int-Variablen das sogenannte Vorzeichenbit ist.
Wenn das höchste Bit 1 ist, wird die Zahl als negativ interpretiert.
Diese Kodierung von positiven und negativen Zahlen wird als Zweierkomplement bezeichnet.
Weitere Informationen finden sich im Wikipedia-Artikel über das Zweierkomplement.
Nebenbei bemerkt ist es interessant zu wissen, dass ~x für jede ganze Zahl x das gleiche ist wie -x-1.
Das Vorzeichenbit in einem vorzeichenbehafteten ganzzahligen Ausdruck kann manchmal zu unerwünschten Überraschungen führen.
Siehe auch
BEISPIEL BitMath-Tutorial
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitwisenot/index.html
|
f7488c8ff017-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
> Bitshiftright
>>
[Bitwise Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitshiftright/index.html
|
f7488c8ff017-1
|
>>
[Bitwise Operators]
Beschreibung
Der rechte Right-Shift-Operator bewirkt, dass die Bits des linken Operanden um die durch den rechten Operanden angegebene Anzahl von Positionen nach rechts verschoben werden.
Syntax
variable >> number_of_bits
Parameter
variable: Erlaubte Datentypen: byte, int, long.
number_of_bits: Eine Zahl < = 32. Erlaubte Datentypen: int.
Beispielcode
int a = 40; // Binär: 0000000000101000
int b = a >> 3; // Binär: 0000000000000101, oder 5 dezimal
Anmerkungen und Warnungen
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitshiftright/index.html
|
f7488c8ff017-2
|
Anmerkungen und Warnungen
Wenn x um y Bits (x >> y) nach rechts verschoben wird und das höchste Bit in x eine 1 ist, hängt das Verhalten vom genauen Datentyp von x ab.
Wenn x vom Typ int ist, ist das höchste Bit das Vorzeichenbit, das bestimmt, ob x negativ ist oder nicht, wie oben diskutiert wurde.
In diesem Fall wird das Vorzeichenbit aus esoterischen historischen Gründen in niedrigere Bits kopiert:
int x = -16; // Binär: 1111111111110000
int y = 3;
int result = x >> y; // Binär: 1111111111111110
Dieses Verhalten, das als Zeichenerweiterung bezeichnet wird, ist häufig nicht das gewünschte Verhalten.
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitshiftright/index.html
|
f7488c8ff017-3
|
Stattdessen möchte man möglicherweise, dass Nullen von links nach innen verschoben werden.
Es stellt sich heraus, dass die Rechtsverschiebungsregeln für vorzeichenlose int-Ausdrücke unterschiedlich sind.
Man kann also eine Typumwandlung verwenden, um zu verhindern, dass die von links kopierten Werte verwendet werden:
int x = -16; // Binär: 1111111111110000
int y = 3;
int result = (unsigned int)x >> y; // Binär: 0001111111111110
Wenn du die Vorzeichenerweiterung sorgfältig vermeidest, kannst du den rechten Umschaltoperator >> verwenden, um die Division durch Potenzen von 2 zu berechnen. Zum Beispiel:
int x = 1000;
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitshiftright/index.html
|
f7488c8ff017-4
|
int x = 1000;
int y = x >> 3; // Integer-Division von 1000 durch 8, wodurch y = 125.
Siehe auch
BEISPIEL BitMath-Tutorial
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitshiftright/index.html
|
56f81115f091-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
> Bitshiftleft
<<
[Bitwise Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitshiftleft/index.html
|
56f81115f091-1
|
<<
[Bitwise Operators]
Beschreibung
Der Left-Shift-Operator << bewirkt, dass die Bits des linken Operanden um die vom rechten Operanden angegebene Anzahl von Positionen nach links verschoben werden.
Syntax
variable << number_of_bits
Parameter
variable: Erlaubte Datentypen: byte, int, long.
number_of_bits: Eine Zahl < = 32. Erlaubte Datentypen: int.
Beispielcode
int a = 5; // Binär: 0000000000000101
int b = a << 3; // Binär: 0000000000101000, oder 40 als Dezimal
Anmerkungen und Warnungen
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitshiftleft/index.html
|
56f81115f091-2
|
Anmerkungen und Warnungen
Wenn du einen Wert x um y Bits (x << y) verschiebst, gehen die am weitesten links liegenden y Bits in x verloren.
int x = 5; // Binär: 0000000000000101
int y = 14;
int result = x << y; // Binär: 0100000000000000 - Die erste 1 von 101 wurde verworfen
Wenn du sicher bist, dass keine der Einsen in einem Wert in Vergessenheit gerät, ist ein einfacher Weg, sich den Operator für die linke Verschiebung vorzustellen,
dass er den linken Operanden mit 2 multipliziert, um die Potenz des rechten Operanden zu erreichen.
Um beispielsweise Potenzen von 2 zu erzeugen, können die folgenden Ausdrücke verwendet werden:
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitshiftleft/index.html
|
56f81115f091-3
|
Operation Ergebnis
--------- ------
1 << 0 1
1 << 1 2
1 << 2 4
1 << 3 8
...
1 << 8 256
1 << 9 512
1 << 10 1024
...
Das folgende Beispiel kann verwendet werden, um den Wert eines empfangenen Bytes an den seriellen Monitor auszugeben.
Verwende den linken Umschaltoperator, um das Byte von unten (LSB) nach oben (MSB) zu verschieben und seinen binären Wert auszugeben:
// Gibt den binären Wert (1 oder 0) des Bytes aus
void printOut1(int c) {
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitshiftleft/index.html
|
56f81115f091-4
|
void printOut1(int c) {
for (int bits = 7; bits > -1; bits--) {
// Vergleiche die Bits 7-0 im Byte
if (c & (1 << bits)) {
Serial.print("1");
}
else {
Serial.print("0");
}
}
}
Siehe auch
BEISPIEL BitMath-Tutorial
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitshiftleft/index.html
|
782b594c7baa-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
> Bitwiseor
|
[Bitwise Operators]
Beschreibung
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitwiseor/index.html
|
782b594c7baa-1
|
|
[Bitwise Operators]
Beschreibung
Der bitweise OR-Operator in C ++ ist das vertikale Balkensymbol |.
Wie der Operator & auch berechnet | jedes Bit in den beiden umgebenden Integer-Ausdrücken unabhängig.
Das bitweise ODER von zwei Bits ist 1, wenn eines oder beide der Eingangsbits 1 sind, andernfalls 0.
In anderen Worten:
0 0 1 1 operand1
0 1 0 1 operand2
----------
0 1 1 1 (operand1 | operand2) - Ergebnis
Beispielcode
int a = 92; // Binär: 0000000001011100
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitwiseor/index.html
|
782b594c7baa-2
|
int b = 101; // Binär: 0000000001100101
int c = a | b; // Ergebnis: 0000000001111101, oder 125 dezimal.
Eine der häufigsten Anwendungen von Bitwise OR ist das Setzen mehrerer Bits in einer mit Bits gepackten Zahl.
// Hinweis: Dieser Code ist spezifisch für die AVR-Architektur
// Richtungsbits für Pin 2 bis 7 setzen, PD0 und PD1 unberührt lassen (xx | 00 == xx)
// Wie pinMode(pin, OUTPUT) für Pin 2 bis 7 beim Uno oder Nano
DDRD = DDRD | B11111100;
Siehe auch
SPRACHE || Logisches ODER
BEISPIEL BitMath-Tutorial
|
https://www.arduino.cc/reference/de/language/structure/bitwise-operators/bitwiseor/index.html
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.