id
stringlengths 14
16
| text
stringlengths 10
1.45k
| source
stringlengths 46
118
|
|---|---|---|
2e7fe65a39f7-5
|
Programmierer gehen oft etwas in die Länge und konvertieren Gleitkomma-Berechnungen in Ganzzahl-Mathematik, um die Geschwindigkeit zu erhöhen.
Siehe auch
|
https://www.arduino.cc/reference/de/language/variables/data-types/float/index.html
|
a25ebecde9d1-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
> Long
long
[Data Types]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/data-types/long/index.html
|
a25ebecde9d1-1
|
> Long
long
[Data Types]
Beschreibung
Long-Variablen sind Variablen mit erweiterter Größe für die Nummernspeicherung und speichern 32 Bit (4 Byte), von -2,147,483,648 bis 2,147,483,647.
Wenn du mit ganzzahligen Zahlen rechnest, muss mindestens einer der Werte vom Typ long sein, entweder ein Integer gefolgt von einem L oder eine long-Variable. Dadurch wird eine Long-Zahl erzwungen.
Siehe auch die Ganzzahlkonstanten-Seite für mehr Details.
Syntax
long var = val
Beschreibung
var: Variablenname.
val: Der Wert, der der Variablen zugewiesen wird.
Beispielcode
|
https://www.arduino.cc/reference/de/language/variables/data-types/long/index.html
|
a25ebecde9d1-2
|
val: Der Wert, der der Variablen zugewiesen wird.
Beispielcode
long speedOfLight_km_s = 300000L; // Auf der Ganzzahlkonstanten-Seite findest du Erläuterungen zu dem 'L'.
Siehe auch
SPRACHE Ganzzahlkonstanten
|
https://www.arduino.cc/reference/de/language/variables/data-types/long/index.html
|
58938ef3f5b3-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
> Boolean
boolean
[Data Types]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/data-types/boolean/index.html
|
58938ef3f5b3-1
|
> Boolean
boolean
[Data Types]
Beschreibung
boolean ist ein nicht standardmäßiger Typalias für bool, welcher von Arduino definiert wurde. Es wird empfohlen, stattdessen den Standardtyp bool zu verwenden, der identisch ist.
Siehe auch
|
https://www.arduino.cc/reference/de/language/variables/data-types/boolean/index.html
|
75454ea58494-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
> Bool
bool
[Data Types]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/data-types/bool/index.html
|
75454ea58494-1
|
> Bool
bool
[Data Types]
Beschreibung
Ein bool enthält einen von zwei Werten, true oder false. (Jede bool-Variable belegt ein Byte Speicher.)
Syntax
bool var = val
Parameter
var: Variablenname.
val: Der Wert, der der Variablen zugewiesen wird.
Beispielcode
Dieser Code zeigt, wie der bool-Datentyp verwendet wird.
int LEDpin = 5; // LED auf Pin 5
int switchPin = 13; // Momentschalter auf 13, andere Seite mit Masse verbunden
bool running = false;
void setup() {
pinMode(LEDpin, OUTPUT);
pinMode(switchPin, INPUT);
digitalWrite(switchPin, HIGH); // Pullup-Widerstand einschalten
}
void loop() {
|
https://www.arduino.cc/reference/de/language/variables/data-types/bool/index.html
|
75454ea58494-2
|
}
void loop() {
if (digitalRead(switchPin) == LOW) { // Schalter wird gedrückt - Pullup hält den Pin normalerweise hoch
delay(100); // Verzögerung zum Entprellen des Schalters
running = !running; // Laufvariable umschalten
digitalWrite(LEDpin, running); // Über LED anzeigen
}
}
Siehe auch
SPRACHE Konstanten
|
https://www.arduino.cc/reference/de/language/variables/data-types/bool/index.html
|
545c610f3411-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
> Stringobject
String()
[Data Types]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/data-types/stringobject/index.html
|
545c610f3411-1
|
String()
[Data Types]
Beschreibung
Erstellt eine Instanz der String-Klasse. Es gibt mehrere Versionen, die Strings aus verschiedenen Datentypen erstellen (d. h. als Zeichenfolgen formatieren), darunter:
Eine konstante Zeichenfolge in Anführungszeichen (d. h. ein Char-Array)
Ein einzelnes konstantes Zeichen in einfachen Anführungszeichen
Eine andere Instanz des String-Objekts
Ein konstanter int oder long int
Ein konstanter int oder long int, der eine angegebene Basis verwendet
Eine konstante int oder long int Variable
Eine konstante int oder long int Variable, die eine angegebene Basis verwendet
Ein float oder double mit einer bestimmten Anzahl Dezimalstellen
|
https://www.arduino.cc/reference/de/language/variables/data-types/stringobject/index.html
|
545c610f3411-2
|
Ein float oder double mit einer bestimmten Anzahl Dezimalstellen
Beim Konstruieren einer Zeichenfolge aus einer Zahl wird eine Zeichenfolge erstellt, die die ASCII-Darstellung dieser Zahl enthält. Der Standard ist also Basis zehn:
String thisString = String(13);
Gibt den String "13" zurück. Du kannst jedoch auch andere Basen verwenden. Zum Beispiel:
String thisString = String(13, HEX);
Gibt den String "D" zurück. Dies ist die hexadezimale Darstellung des Dezimalwerts 13. Oder, wenn du das Binärformat bevorzugst:
String thisString = String(13, BIN);
Gibt den String "1101" zurück. Das ist die binäre Darstellung von 13.
Syntax
String(val)
String(val, base)
String(val, decimalPlaces)
Parameter
|
https://www.arduino.cc/reference/de/language/variables/data-types/stringobject/index.html
|
545c610f3411-3
|
String(val)
String(val, base)
String(val, decimalPlaces)
Parameter
val: Eine Variable, die als String formatiert werden soll. Erlaubte Datentypen: string, char, byte, int, long, unsigned int, unsigned long, float, double.
base (Optional): Die Basis, in der ein ganzzahliger Wert formatiert werden soll.
decimalPlaces (Nur, wenn val float oder double ist): Die gewünschten Dezimalstellen.
Rückgabewert
Eine Instanz der String-Klasse.
Beispielcode
Alle folgenden Angaben sind gültige Deklarationen für Strings.
String stringOne = "Hello String"; // Ein konstanter String
String stringOne = String('a'); // Konvertieren eines konstanten char in einen String
|
https://www.arduino.cc/reference/de/language/variables/data-types/stringobject/index.html
|
545c610f3411-4
|
String stringTwo = String("This is a string"); // Konvertieren eines konstanten String in ein String-Objekt
String stringOne = String(stringTwo + " with more"); // Zwei Strings konkatenieren
String stringOne = String(13); // Ein konstanter int
String stringOne = String(analogRead(0), DEC); // Ein int mit einer Basis
String stringOne = String(45, HEX); // Ein int mit einer Basis (Hexadezimal)
String stringOne = String(255, BIN); // Ein int mit einer Basis (Binär)
String stringOne = String(millis(), DEC); // Ein long mit einer Basis
String stringOne = String(5.698, 3); // Ein float mit Dezimalstellen
Funktionen
SPRACHE charAt()
SPRACHE compareTo()
|
https://www.arduino.cc/reference/de/language/variables/data-types/stringobject/index.html
|
545c610f3411-5
|
Funktionen
SPRACHE charAt()
SPRACHE compareTo()
SPRACHE concat()
SPRACHE c_str()
SPRACHE endsWith()
SPRACHE equals()
SPRACHE equalsIgnoreCase()
SPRACHE getBytes()
SPRACHE indexOf()
SPRACHE lastIndexOf()
SPRACHE length()
SPRACHE remove()
SPRACHE replace()
SPRACHE reserve()
SPRACHE setCharAt()
SPRACHE StartsWith()
SPRACHE substring()
SPRACHE toCharArray()
SPRACHE toDouble()
SPRACHE toInt()
SPRACHE toFloat()
SPRACHE toLowerCase()
SPRACHE toUpperCase()
SPRACHE trim()
Operatoren
SPRACHE [] (Elementzugriff)
SPRACHE + (Verkettung)
|
https://www.arduino.cc/reference/de/language/variables/data-types/stringobject/index.html
|
545c610f3411-6
|
SPRACHE + (Verkettung)
SPRACHE += (Anhängen)
SPRACHE == (Vergleich)
SPRACHE > (Größer als)
SPRACHE >= (Größer als oder gleich)
SPRACHE < (Kleiner als)
SPRACHE <= (Kleiner als oder gleich)
SPRACHE != (Ungleich)
BEISPIEL String-Tutorials
Siehe auch
|
https://www.arduino.cc/reference/de/language/variables/data-types/stringobject/index.html
|
c60768073968-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
> Size t
size_t
[Data Types]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/data-types/size_t/index.html
|
c60768073968-1
|
size_t
[Data Types]
Beschreibung
size_t ist ein Datentyp, der die Größe eines Objekts in Bytes darstellen kann.
Beispiele für die Verwendung von size_t sind der Rückgabetyp von sizeof() and Serial.print().
Syntax
size_t var = val
Parameter
var: Variablenname.
val: Der Wert, der der Variablen zugewiesen wird.
Siehe auch
|
https://www.arduino.cc/reference/de/language/variables/data-types/size_t/index.html
|
4b7abf0ceba6-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
> Short
short
[Data Types]
Beschreibung
Ein short ist ein 16-Bit-Datentyp.
|
https://www.arduino.cc/reference/de/language/variables/data-types/short/index.html
|
4b7abf0ceba6-1
|
Beschreibung
Ein short ist ein 16-Bit-Datentyp.
Auf allen Arduinos (ATMega und ARM-basiert) speichert ein Short einen 16-Bit-Wert (2 Byte). Dies ergibt einen Bereich von -32,768 bis 32,767 (Minimalwert von -2^15 und Maximalwert von (2^15) - 1).
Syntax
short var = val
Parameter
var: Variablenname.
val: Der Wert, der der Variablen zugewiesen wird.
Beispielcode
short ledPin = 13
Siehe auch
SPRACHE Ganzzahlkonstanten
|
https://www.arduino.cc/reference/de/language/variables/data-types/short/index.html
|
64aeef662ffe-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
> Double
double
[Data Types]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/data-types/double/index.html
|
64aeef662ffe-1
|
> Double
double
[Data Types]
Beschreibung
Fließkommazahl mit doppelter Genauigkeit. Auf dem Uno und anderen ATMEGA-basierten Boards belegt dies 4 Bytes.
Das heißt, die double-Implementierung entspricht genau dem float, ohne dass die Genauigkeit zunimmt.
Auf dem Arduino Due haben doubles eine Genauigkeit von 8 Byte (64 Bit).
Syntax
double var = val
Parameter
var: Variablenname.
val: Der Wert, der der Variablen zugewiesen wird.
Anmerkungen und Warnungen
Benutzer, die sich Code aus anderen Quellen leihen, der double-Variablen enthält, möchten möglicherweise den Code untersuchen, um zu sehen,
|
https://www.arduino.cc/reference/de/language/variables/data-types/double/index.html
|
64aeef662ffe-2
|
ob sich die implizierte Genauigkeit von der tatsächlich bei ATMEGA-basierten Arduinos erreichten unterscheidet.
Siehe auch
|
https://www.arduino.cc/reference/de/language/variables/data-types/double/index.html
|
8dd7d0fa52fa-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
> Unsignedchar
unsigned char
[Data Types]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/data-types/unsignedchar/index.html
|
8dd7d0fa52fa-1
|
unsigned char
[Data Types]
Beschreibung
Ein vorzeichenloser Datentyp belegt 1 Byte Speicher. Genauso wie der byte-Datentyp.
Der vorzeichenlose char-Datentyp codiert Zahlen von 0 bis 255.
Für die Konsistenz des Arduino-Programmierstils ist der byte-Datentyp zu bevorzugen.
Syntax
unsigned char var = val
Parameter
var: Variablenname.
val: Der Wert, der der Variablen zugewiesen wird.
Beispielcode
unsigned char myChar = 240;
Siehe auch
SPRACHE Serial.println
|
https://www.arduino.cc/reference/de/language/variables/data-types/unsignedchar/index.html
|
da37eef447c1-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
> Unsignedint
unsigned int
[Data Types]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/data-types/unsignedint/index.html
|
da37eef447c1-1
|
unsigned int
[Data Types]
Beschreibung
Auf Uno und anderen ATMEGA-basierten Boards sind vorzeichenlose Ganzzahlen (unsigned int) die gleichen wie int, da sie einen 2-Byte-Wert speichern.
Anstatt negative Zahlen zu speichern, speichern sie jedoch nur positive Werte, was einen Bereich von 0 bis 65,535 (2^16 - 1) ergibt.
The Due stores a 4 byte (32-bit) value, ranging from 0 bis 4,294,967,295 (2^32 - 1).
Der Unterschied zwischen vorzeichenlosen int und signed int liegt in der Art und Weise, wie das höchste Bit, manchmal als "Vorzeichen" bezeichnet, interpretiert wird.
|
https://www.arduino.cc/reference/de/language/variables/data-types/unsignedint/index.html
|
da37eef447c1-2
|
Wenn im Arduino int-Typ (der mit Vorzeichen versehen ist) das High-Bit eine "1" ist, wird die Zahl als negative Zahl interpretiert und die anderen 15 Bits werden interpretiert
mit dem (Zweierkomplement).
Syntax
unsigned int var = val
Parameter
var: Variablenname.
val: Der Wert, der der Variablen zugewiesen wird.
Beispielcode
unsigned int ledPin = 13;
Anmerkungen und Warnungen
Wenn Variablen ohne Vorzeichen ihre maximale Kapazität überschreiten, "rollen" sie wieder auf 0 zurück und umgekehrt:
unsigned int x;
x = 0;
x = x - 1; // x enthält jetzt 65535
x = x + 1; // x enthält jetzt 0
Siehe auch
|
https://www.arduino.cc/reference/de/language/variables/data-types/unsignedint/index.html
|
da37eef447c1-3
|
x = x + 1; // x enthält jetzt 0
Siehe auch
SPRACHE Ganzzahlkonstanten
|
https://www.arduino.cc/reference/de/language/variables/data-types/unsignedint/index.html
|
492cf8622743-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
> Char
char
[Data Types]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/data-types/char/index.html
|
492cf8622743-1
|
> Char
char
[Data Types]
Beschreibung
Ein Datentyp zum Speichern eines Zeichenwerts. Zeichenliterale werden in einfache Anführungszeichen geschrieben: 'A' (für mehrere Zeichen - Zeichenfolgen - verwende doppelte Anführungszeichen: "ABC").
Zeichen werden jedoch als Zahlen gespeichert. Du kannst die spezifische Kodierung im ASCII-Chart sehen.
Dies bedeutet, dass es möglich ist, Zeichen zu berechnen, bei denen der ASCII-Wert des Zeichens verwendet wird (z. B. hat 'A' + 1 den Wert 66, da der ASCII-Wert des Großbuchstaben A 65 ist).
Siehe Serial.println für weitere Informationen, wie Zeichen in Zahlen übersetzt werden.
|
https://www.arduino.cc/reference/de/language/variables/data-types/char/index.html
|
492cf8622743-2
|
Siehe Serial.println für weitere Informationen, wie Zeichen in Zahlen übersetzt werden.
Die Größe des char-Datentyps beträgt mindestens 8 Bit. Es wird empfohlen, char nur zum Speichern von Zeichen zu verwenden. Verwende für einen vorzeichenlosen 1-Byte-Datentyp (8 Bit) den byte-Datentyp.
Beispielcode
char myChar = 'A';
char myChar = 65; // Beide sind gleichwertig
Siehe auch
SPRACHE Serial.println
|
https://www.arduino.cc/reference/de/language/variables/data-types/char/index.html
|
835cfee2732f-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
> Byte
byte
[Data Types]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/data-types/byte/index.html
|
835cfee2732f-1
|
> Byte
byte
[Data Types]
Beschreibung
Ein Byte speichert eine vorzeichenlose 8-Bit-Zahl von 0 bis 255.
Syntax
byte var = val
Parameter
var: Variablenname.
val: Der Wert, der der Variablen zugewiesen wird.
Siehe auch
SPRACHE byte()
|
https://www.arduino.cc/reference/de/language/variables/data-types/byte/index.html
|
a2e55ccc71fb-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
> Array
array
[Data Types]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/data-types/array/index.html
|
a2e55ccc71fb-1
|
> Array
array
[Data Types]
Beschreibung
Ein Array ist eine Sammlung von Variablen, auf die mit einer Indexnummer zugegriffen wird.
Arrays in der Programmiersprache C ++, in der Arduino-Skizzen geschrieben sind, sind zwar kompliziert, aber die Verwendung einfacher Arrays ist relativ unkompliziert.
Array erstellen / deklarieren
Alle folgenden Methoden sind gültige Methoden zum Erstellen (Deklarieren) eines Arrays.
int myInts[6];
int myPins[] = {2, 4, 8, 3, 6};
int mySensVals[6] = {2, 4, -8, 3, 2};
char message[6] = "hello";
|
https://www.arduino.cc/reference/de/language/variables/data-types/array/index.html
|
a2e55ccc71fb-2
|
char message[6] = "hello";
Du kannst ein Array deklarieren, ohne es wie in myInts initialisieren zu müssen.
In myPins deklarieren wir ein Array, ohne explizit eine Größe zu wählen. Der Compiler zählt die Elemente und erstellt ein Array der entsprechenden Größe.
Schließlich können wir das Array wie in mySensVals sowohl initialisieren als auch skalieren.
Beachte, dass beim Deklarieren eines Arrays vom Typ char ein weiteres Element als Initialisierung erforderlich ist, um das erforderliche Nullzeichen zu enthalten.
Zugriff auf ein Array
Arrays sind nullindiziert, das heißt, bezogen auf die Array-Initialisierung oben, befindet sich das erste Element des Arrays am Index 0.
|
https://www.arduino.cc/reference/de/language/variables/data-types/array/index.html
|
a2e55ccc71fb-3
|
mySensVals[0] == 2, mySensVals[1] == 4, und so weiter.
Das bedeutet auch, dass in einem Array mit zehn Elementen der Index neun das letzte Element ist. Daher:
int myArray[10]={9, 3, 2, 4, 3, 2, 7, 8, 9, 11};
// myArray[9] enthält 11
// myArray[10] ist ungültig und enthält zufällige Informationen (andere Speicheradresse)
Aus diesem Grund solltet du beim Zugriff auf Arrays vorsichtig sein.
Beim Zugriff auf das Ende eines Arrays (mit einer Indexnummer, die größer ist als die von dir deklarierte Arraygröße - 1), wird aus dem Speicher gelesen, der für andere Zwecke verwendet wird.
|
https://www.arduino.cc/reference/de/language/variables/data-types/array/index.html
|
a2e55ccc71fb-4
|
Das Lesen an diesen Orten wird wahrscheinlich nicht viel bewirken, außer ungültige Daten liefern. Das Schreiben in zufällige Speicherorte ist definitiv eine schlechte Idee und
kann oft zu unglücklichen Ergebnissen wie Abstürzen oder Programmstörungen führen. Dies kann auch ein schwieriger Fehler sein.
Im Gegensatz zu BASIC oder JAVA überprüft der C ++ - Compiler nicht, ob der Array-Zugriff innerhalb der zulässigen Grenzen der von Ihnen angegebenen Array-Größe liegt.
So weist du einem Array einen Wert zu:
mySensVals[0] = 10;
So rufst du einen Wert aus einem Array ab:
x = mySensVals[4];
Arrays und FOR-Schleifen
|
https://www.arduino.cc/reference/de/language/variables/data-types/array/index.html
|
a2e55ccc71fb-5
|
x = mySensVals[4];
Arrays und FOR-Schleifen
Arrays werden oft innerhalb von Schleifen bearbeitet, wobei der Schleifenzähler als Index für jedes Array-Element verwendet wird.
Wenn du beispielsweise die Elemente eines Arrays über den seriellen Anschluss ausgeben möchtest, kannst du Folgendes tun:
for (byte i = 0; i < 5; i = i + 1) {
Serial.println(myPins[i]);
}
Beispielcode
Ein vollständiges Programm, das die Verwendung von Arrays demonstriert, findest du im (Knight Rider-Beispiel) des (Tutorials).
Siehe auch
SPRACHE PROGMEM
|
https://www.arduino.cc/reference/de/language/variables/data-types/array/index.html
|
c1f267070826-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
> Unsignedlong
unsigned long
[Data Types]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/data-types/unsignedlong/index.html
|
c1f267070826-1
|
unsigned long
[Data Types]
Beschreibung
Long-Variablen ohne Vorzeichen sind Variablen mit erweiterter Größe für die Nummernspeicherung und speichern 32 Bit (4 Byte).
Im Gegensatz zu Standard-Longs werden bei unsigned Longs keine negativen Zahlen gespeichert, sodass der Bereich zwischen 0 und 4,294,967,295 (2^32 - 1) liegt.
Syntax
unsigned long var = val
Parameter
var: Variablenname.
val: Der Wert, der der Variablen zugewiesen wird.
Beispielcode
unsigned long time;
void setup() {
Serial.begin(9600);
}
void loop() {
Serial.print("Time: ");
time = millis();
// Gibt die Zeit seit dem Programmstart aus
|
https://www.arduino.cc/reference/de/language/variables/data-types/unsignedlong/index.html
|
c1f267070826-2
|
time = millis();
// Gibt die Zeit seit dem Programmstart aus
Serial.println(time);
// Wartet eine Sekunde, um keine riesigen Datenmengen zu senden
delay(1000);
}
Siehe auch
SPRACHE Ganzzahlkonstanten
|
https://www.arduino.cc/reference/de/language/variables/data-types/unsignedlong/index.html
|
1a13ba7d34c5-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
> Utilities
> Progmem
PROGMEM
[Utilities]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/utilities/progmem/index.html
|
1a13ba7d34c5-1
|
PROGMEM
[Utilities]
Beschreibung
Speichere Daten im Flash-/Programm-Speicher statt im SRAM. Eine Beschreibung der unterschiedlichen Arten von Speicher des Arduinos
findest du hier.
PROGMEM ist ein Variablenmodifikator, welcher nur mit den Datentypen in pgmspace.h
verwendet werden sollte. Es ist eine Anweisung an den Compiler, um die Daten im Flash-/Programm-Speicher statt im SRAM zu speichern.
PROGMEM gehört zur pgmspace.h-Softwarebibliothek. Diese ist in allen modernen IDE-Versionen
standardmäßig enthalten. Solltest du eine IDE-Version niedriger als 1.0 (von 2011) besitzen, musst du die Bibliothek erst händisch einbinden. Dies funktioniert wie folgt:
|
https://www.arduino.cc/reference/de/language/variables/utilities/progmem/index.html
|
1a13ba7d34c5-2
|
#include <avr/pgmspace.h>
Syntax
const dataType variableName[] PROGMEM = {data0, data1, data3…};
dataType - Beliebiger Variablentyp
variableName - Der Variablenname
PROGMEM ist ein variabler Modifikator, weshalb die Arduino-IDE alle folgenden synonymen Versionen der Syntax akzeptiert. Durch Experimente wurde allerdings festgestellt,
dass in einigen Versionen der Arduino-IDE (Durch die unterschiedlichen GCC-Versionen) an einigen Stellen funktioniert und an anderen nicht. Die Beispiele unten funktionieren
mit der Arduino IDE Version 13. Frühere Versionen der IDE arbeiten besser, wenn PROGMEM nach dem Variablennamen eingefügt wird.
const dataType variableName[] PROGMEM = {}; // Benutze dies
const PROGMEM dataType variableName[] = {}; // oder das,+
|
https://www.arduino.cc/reference/de/language/variables/utilities/progmem/index.html
|
1a13ba7d34c5-3
|
const PROGMEM dataType variableName[] = {}; // oder das,+
const dataType PROGMEM variableName[] = {}; // aber nicht diese Version!
PROGMEM kann auch für einzelne Variablen benutzt werden, dies ist aber nur sinnvoll, wenn ein großer Block von Daten gespeichert werden soll. Normalerweise ist das bei Arrays,
Strings (die auch Arrays sind) und weiteren komplizierteren Datenstrukturen der Fall.
Die Benutzung von PROGMEM erfolgt in 2 Schritten. Nachdem die Daten in den Flash-/Programm-Speicher geladen wurden, müssen spezielle Methoden verwendet werden, um diese Variablen
wieder auszulesen und zu bearbeiten. Diese sind auch in der pgmspace.h-Softwarebibliothek definiert.
Beispielcode
|
https://www.arduino.cc/reference/de/language/variables/utilities/progmem/index.html
|
1a13ba7d34c5-4
|
Beispielcode
Das folgende Code-Fragment zeigt, wie ein unsigned chars (bytes) und ints (2 bytes) in PROGMEM geschrieben und wieder ausgelesen werden können.
// Speichere einige unsigned ints
const PROGMEM uint16_t charSet[] = { 65000, 32796, 16843, 10, 11234};
// Speichere einen String
const char signMessage[] PROGMEM = {"I AM PREDATOR, UNSEEN COMBATANT. CREATED BY THE UNITED STATES DEPART"};
unsigned int displayInt; // Rückgabewert der Funktion zum Auslesen der Daten
char myChar; // Definiere einen Char, um diesen zu bearbeiten
void setup() {
Serial.begin(9600); // Initialisiere den seriellen Port
while (!Serial); // Warte, bis der serielle Port verbunden ist
// Setup code:
|
https://www.arduino.cc/reference/de/language/variables/utilities/progmem/index.html
|
1a13ba7d34c5-5
|
// Setup code:
// Lies einen 2-Byte-Int
for (byte k = 0; k < 5; k++) {
displayInt = pgm_read_word_near(charSet + k); // Lies den charSet-Wert wieder aus dem Flash-/Programm-Speicher
Serial.println(displayInt); // Gib den gelesenen Wert aus
}
Serial.println(); // Schreibe eine neue Zeile
// Lies einen Char
for (byte k = 0; k < strlen_P(signMessage); k++) {
myChar = pgm_read_byte_near(signMessage + k); // Lies den signMessage-Wert wieder aus dem Flash-/Programm-Speicher
Serial.print(myChar); // Gib den gelesenen Wert aus
}
Serial.println(); // Schreibe eine neue Zeile
}
void loop() {
// ...
}
|
https://www.arduino.cc/reference/de/language/variables/utilities/progmem/index.html
|
1a13ba7d34c5-6
|
}
void loop() {
// ...
}
Array von Strings
Wenn mit einer großen Menge an Text gearbeitet wird (Beispiel: Projekt mit LCD-Display), ist es häufig nötig, Texte in ein Array von Strings zu packen.
Dadurch, dass Strings bereits selbst Arrays sind, entsteht dadurch ein 2-dimensionales Array.
Diese großen Datenstrukturen können in den Flash-/Programm-Speicher geladen werden. Das Beispiel unten zeigt das.
/*
PROGMEM string demo
Wie man ein Stringarray in den Flash-/Programm-Speicher lädt und wieder liest.
Für weitere Informationen siehe:
http://www.nongnu.org/avr-libc/user-manual/pgmspace.html
Stringarrays in den Flash-/Programm-Speicher zu laden, ist etwas komplizierter,
das Beispiel ziegt dies jedoch.
*/
|
https://www.arduino.cc/reference/de/language/variables/utilities/progmem/index.html
|
1a13ba7d34c5-7
|
das Beispiel ziegt dies jedoch.
*/
#include <avr/pgmspace.h>
const char string_0[] PROGMEM = "String 0"; // Definiere deine Strings "String 0" ist hier nur ein Beispiel
const char string_1[] PROGMEM = "String 1"; // Definiere deine Strings "String 1" ist hier nur ein Beispiel
const char string_2[] PROGMEM = "String 2"; // Definiere deine Strings "String 2" ist hier nur ein Beispiel
const char string_3[] PROGMEM = "String 3"; // Definiere deine Strings "String 3" ist hier nur ein Beispiel
const char string_4[] PROGMEM = "String 4"; // Definiere deine Strings "String 4" ist hier nur ein Beispiel
const char string_5[] PROGMEM = "String 5"; // Definiere deine Strings "String 5" ist hier nur ein Beispiel
|
https://www.arduino.cc/reference/de/language/variables/utilities/progmem/index.html
|
1a13ba7d34c5-8
|
// Initialisiere die Tabelle von Strings
const char* const string_table[] PROGMEM = { string_0, string_1, string_2, string_3, string_4, string_5 };
char buffer[30]; // Der Buffer zum Lesen der Daten muss so lang sein wie der längste String!
void setup() {
Serial.begin(9600); // Initialisiere den seriellen Port
while(!Serial); // Warten, bis der serielle Port verfügbar ist
Serial.println("OK"); // Schreibe "OK" auf den seriellen Port
}
void loop() {
/* Spezielle Funktionen zum Lesen der Daten sind nötig. "strcpy_P" kopiert den String vom
Flash-/Programm-Speicher in dem SRAM/ den Buffer. Stelle sicher, dass der empfangende
String lang genug ist für den String.
|
https://www.arduino.cc/reference/de/language/variables/utilities/progmem/index.html
|
1a13ba7d34c5-9
|
String lang genug ist für den String.
*/
// Iteriere über das Array: 6-mal, da 6 Strings im Array sind
for (int i = 0; i < 6; i++) {
strcpy_P(buffer, (char*)pgm_read_word(&(string_table[i]))); // Casts und Dereferenzierung des Speichers
Serial.println(buffer); // Gib den gelesenen Wert aus
delay(500); // Warte eine halbe Sekunde
}
}
Anmerkungen und Warnungen
Bitte beachte, dass die Variablen entweder global definiert oder als static definiert sein müssen, um mit PROGMEM zu funktionieren.
Der folgende Code wird nicht funktionieren, wenn er in einer Funktion ausgeführt wird:
|
https://www.arduino.cc/reference/de/language/variables/utilities/progmem/index.html
|
1a13ba7d34c5-10
|
Der folgende Code wird nicht funktionieren, wenn er in einer Funktion ausgeführt wird:
const char long_str[] PROGMEM = "Hi, I would like to tell you a bit about myself.\n";
Der folgende Code wird funktionieren, wenn er in einer Funktion ausgeführt wird:
const static char long_str[] PROGMEM = "Hi, I would like to tell you a bit about myself.\n"
Das F()-Makro
Wenn eine Instruktion wie
Serial.print("Write something on the Serial Monitor");
benutzt wird, wird der String bevor er auf den seriellen Ausgang geschrieben wird, normalerweise in den RAM gespeichert. Der RAM kann aber sehr leicht volllaufen, wenn der Code
|
https://www.arduino.cc/reference/de/language/variables/utilities/progmem/index.html
|
1a13ba7d34c5-11
|
sehr viel auf den seriellen Port schreibt. Wenn du noch freien Flash-/Programm-Speicher hast, kannst du dem Compiler sagen, dass er die Werte in den Flash-/Programm-Speicher
schreiben soll:
Serial.print(F("Write something on the Serial Monitor that is stored in FLASH"));
Siehe auch
BEISPIEL Arten von Speicher auf dem Arduino
DEFINITION array
DEFINITION string
|
https://www.arduino.cc/reference/de/language/variables/utilities/progmem/index.html
|
606a54ed751b-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
> Utilities
> Sizeof
sizeof()
[Utilities]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/utilities/sizeof/index.html
|
606a54ed751b-1
|
sizeof()
[Utilities]
Beschreibung
sizeof gibt die Anzahl an Bytes in einem Variablentyp oder die Anzahl an Bytes eines Arrays zurück.
Syntax
sizeof(variable)
Parameter
variable: Erlaubte Datentypen: Beliebiger Datentyp.
Rückgabewert
Die Anzahl der Bytes in einer Variablen oder die Bytes, die in einem Array belegt sind. Datentyp: size_t.
Beispielcode
Der sizeof-Operator ist nützlich, um mit Arrays (wie z.B. Strings) umzugehen. Dort ist es Standard, dass die Größe des Arrays sich ändert, ohne
dass das ganze restliche Programm umgeschrieben werden muss.
Das Programm gibt einen Text zeichenweise aus. Versuche, den Text zu ändern, das Programm wird weiter funktionieren.
|
https://www.arduino.cc/reference/de/language/variables/utilities/sizeof/index.html
|
606a54ed751b-2
|
// Definiere Text und Zählervariable
char myStr[] = "this is a test";
void setup() {
// Initialisiere seriellen Port
Serial.begin(9600);
}
void loop() {
// Laufe über das Array (den String), egal, wie lange dieser ist
for (byte i = 0; i < sizeof(myStr) - 1; i++) {
// Gib die Zeichennummer als Dezimalzahl aus
Serial.print(i, DEC);
// Gib ein Gleichheitszeichen aus
Serial.print(" = ");
// Gib das Zeichen des Strings an Stelle "i" aus
Serial.write(myStr[i]);
// Schreibe eine neue Zeile
Serial.println();
}
delay(5000); // Warte 5 Sekunden
}
Anmerkungen und Warnungen
|
https://www.arduino.cc/reference/de/language/variables/utilities/sizeof/index.html
|
606a54ed751b-3
|
}
Anmerkungen und Warnungen
sizeof gibt die Anzahl an Bytes zurück. Für Arrays größerer Variablentypen, wie z.B. int, sieht die Schleife wie folgt aus:
int myValues[] = {123, 456, 789};
// Diese for-Schleife funktioniert ordnungsgemäß mit einem Array eines beliebigen Typs und jeder Größe
for (byte i = 0; i < (sizeof(myValues)/sizeof(myValues[0])); i++) {
// Tue etwas mit myValues[i]
}
Beachte zusätzlich, dass ein richtig formattierter String mit dem NULL-Symbol beendet wird, also dem ASCII-Zeichen mit Nummer 0.
Siehe auch
|
https://www.arduino.cc/reference/de/language/variables/utilities/sizeof/index.html
|
c8ba8b5e353e-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
> Constants
> Integerconstants
Integer-Konstanten
[Constants]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/constants/integerconstants/index.html
|
c8ba8b5e353e-1
|
Integer-Konstanten
[Constants]
Beschreibung
Integerkonstanten sind Nummern, die direkt im Code genutzt werden, z.B. 123. Per default werden diese Konstanten als int definiert.
Dies kannst du aber mit den U- und L-Attributen ändern (Siehe unten).
Normalerweise werden Integerkonstanten als Dezimalzahlen behandelt (Basis 10). Spezielle Notationen (Formatierer) erlauben die Eingabe in Bezug zu anderen Basen.
Basis
Beispiel
Formatierer
Kommentar
10 (Dezimal)
123
Keiner
2 (Binär)
B1111011
Führendes 'B'
|
https://www.arduino.cc/reference/de/language/variables/constants/integerconstants/index.html
|
c8ba8b5e353e-2
|
2 (Binär)
B1111011
Führendes 'B'
Funktioniert nur mit 8-Bit-Werten (0 bis 255); Nur die Ziffern 0&1 sind gültig
8 (Oktal)
0173
Führende "0"
Nur die Ziffern 0-7 sind gültig
16 (Hexadezimal)
0x7B
Führendes "0x"
Nur die Zeichen 0-9, A-F, a-f sind gültig
Dezimal (Basis 10)
Der "Standardfall". Alle Konstanten ohne spezielle Präfixe werden als Dezimalformat interpretiert.
Beispielcode:
|
https://www.arduino.cc/reference/de/language/variables/constants/integerconstants/index.html
|
c8ba8b5e353e-3
|
Beispielcode:
n = 101; // = 101 in Dezimal ((1 * 10^2) + (0 * 10^1) + 1)
Binär (Basis 2)
Nur die Zahlen 0 und 1 sind gültig.
Beispielcode:
n = B101; // = 5 in Dezimal ((1 * 2^2) + (0 * 2^1) + 1)
Der Binärformatierer funktioniert nur für Zahlen bis 8 Bit zwischen 0 (B0) und 255 (B11111111). Wenn du eine 16-Bit-Zahl angeben willst,
solltest du dies in der folgenden Art tun:
myInt = (B11001100 * 256) + B10101010; // B11001100 ist dann das 'High byte'
|
https://www.arduino.cc/reference/de/language/variables/constants/integerconstants/index.html
|
c8ba8b5e353e-4
|
Octal (Basis 8)
Nur die Zahlen 0 bis 7 sind erlaubt. Oktalzahlen werden durch das Präfix "0" (Null) identifiziert.
Beispielcode:
n = 0101; // = 65 in Dezimal ((1 * 8^2) + (0 * 8^1) + 1)
Es ist leicht, unabsichtlich schwer zu findende Fehler in den Code einzubauen, wenn eine führende Null for einer Konstante steht und der
Compiler diese als Oktalzahl interpretiert.
Hexadecimal (Basis 16)
Valide Zeichen sind 0 bis 9 und A bis F: A hat den Wert 10, B den Wert 11, C den Wert 12, D den Wert 13, E den Wert 14 und F den Wert 15.
|
https://www.arduino.cc/reference/de/language/variables/constants/integerconstants/index.html
|
c8ba8b5e353e-5
|
A bis F können auch in lower case (a bis f) verwendet werden.
Beispielcode:
n = 0x101; // = 257 in Dezimal ((1 * 16^2) + (0 * 16^1) + 1)
Anmerkungen und Warnungen
U- & L-Formatierer:
Per default werdem Integerkonstanten als Integer behandelt. Zur Verwendung von Integerkonstanten als andere Datentypen, siehe die folgenden Formatierer:
'u' oder 'U': Ändert den Datentyp der Konstante auf unsigned int. Beispiel: 33u
a 'l' oder 'L': Ändert den Datentyp der Konstante auf long. Beispiel: 100000L
|
https://www.arduino.cc/reference/de/language/variables/constants/integerconstants/index.html
|
c8ba8b5e353e-6
|
a 'ul' oder 'UL': Ändert den Datentyp der Konstante auf unsigned long. Beispiel: 32767ul
Siehe auch
|
https://www.arduino.cc/reference/de/language/variables/constants/integerconstants/index.html
|
efffa5d784a0-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
> Constants
> Constants
Konstanten
[Constants]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/constants/constants/index.html
|
efffa5d784a0-1
|
Konstanten
[Constants]
Beschreibung
Konstanten sind vordefinierte Ausdrücke der Arduinosprache. Sie werden benutzt, um Programmcode leichter lesbar zu machen.
Die Konstanten könnein Gruppen unterteilt werden:
Logische Level: true und false (Booleankonstanten)
Um Wahr- und Falschwerte darzustellen, sind in der Arduinosprache 2 Konstanten definiert: true und false.
false
false ist die einfacher zu definierende Konstante. false ist 0 (Null).
true
Häufig wird behauptet, dass true als 1 definiert ist. Das ist zwar richtig, allerdings hat true eine weiterreichende Definition.
|
https://www.arduino.cc/reference/de/language/variables/constants/constants/index.html
|
efffa5d784a0-2
|
Jeder Integer, der nicht 0 (Null) ist, ist true im Booleanzusammenhang. D.h. -1, -2 und -200 sind auch true.
true und false werden im Gegensatz zu HIGH, LOW, INPUT, und OUTPUT klein geschrieben.
Pinlevel: HIGH und LOW
Wenn von einem Digitalpin gelesen oder auf einen Digitalpin geschrieben wird, gibt es nur 2 Möglichkeiten: HIGH und LOW.
HIGH
Die Bedeutung von HIGH (In Bezug auf den Pin) ist unterschiedlich, je nachdem, ob der Pin als INPUT oder OUTPUT definiert ist.
Wenn ein Pin als INPUT mit pinMode() definiert wird und mit
digitalRead() gelesen wird, gibt der Arduino (ATmega) HIGH zurück, wenn:
eine Spannung größer als 3,0V an dem Pin anliegt (5V-Boards)
|
https://www.arduino.cc/reference/de/language/variables/constants/constants/index.html
|
efffa5d784a0-3
|
eine Spannung größer als 2,0V an dem Pin anliegt (3,3V-Boards)
Ein Pin kann mit pinMode() auch als INPUT definiert werden und mit
digitalWrite() auf HIGH gesetzt werden. Das aktiviert den internen 20K-Pullup-Widerstand,
welcher den Inputpin auf HIGH zieht, bis dieser von extern wieder auf LOW gesetzt wird. So funktioniert auch INPUT_PULLUP. Die genaue
Definition davon findest du weiter unten.
Wenn ein Pin mit pinMode() als OUTPUT definiert wird und mit
digitalWrite() auf HIGH gesetzt wird, liegen an dem Pin:
5V an (5V-Boards)
3,3V an (3,3V-Boards)
|
https://www.arduino.cc/reference/de/language/variables/constants/constants/index.html
|
efffa5d784a0-4
|
3,3V an (3,3V-Boards)
In diesem Zustand kann z.B. eine LED angeschaltet werden, die über einen Vorschaltwiderstand auf Masse verbunden ist.
LOW
Die Bedeutung von LOW (In Bezug auf den Pin) ist ebenfalls unterschiedlich, je nachdem, ob der Pin als INPUT oder OUTPUT definiert ist.
Wenn ein Pin als INPUT mit pinMode() definiert wird und mit
digitalRead() gelesen wird, gibt der Arduino (ATmega) LOW zurück, wenn:
eine Spannung kleiner als 1,5V an dem Pin anliegt (5V-Boards)
eine Spannung kleiner als 1,0V (circa) an dem Pin anliegt (3,3V-Boards)
Wenn ein Pin mit pinMode() als OUTPUT definiert wird und mit
|
https://www.arduino.cc/reference/de/language/variables/constants/constants/index.html
|
efffa5d784a0-5
|
Wenn ein Pin mit pinMode() als OUTPUT definiert wird und mit
digitalWrite() auf LOW gesetzt wird, liegen an ihm 0V an (Auf 5V- und 3,3V-Boards).
In diesem Zustand kann z.B. eine LED ausgeschaltet werden, die über einen Vorschaltwiderstand auf Masse verbunden ist.
Digitale Pinmodi: INPUT, INPUT_PULLUP, und OUTPUT
Digitalpins können als INPUT, INPUT_PULLUP, oder OUTPUT genutzt werden. Wenn ein Pin mit pinMode()
auf einen anderen Modus umgeschalten wird, ändert sich dessen elektrisches Verhalten.
INPUT
Arduino (ATmega)-Pins, die mit pinMode() als INPUT definiert werden, sind in einem hochohmigen Zustand.
|
https://www.arduino.cc/reference/de/language/variables/constants/constants/index.html
|
efffa5d784a0-6
|
Inputpins stellen sehr geringe Zusatzanforderungen an die Schaltung, die sie benutzen. Lediglich ein Vorschaltwiderstand von 100MOhm vor dem Pin ist nötig.
Das macht sie sehr nützlich, um Sensoren auszulesen.
Wenn ein Pin als INPUT definiert ist und einen Schalter einliest, wird der Inputpin unvorhersehbare Ergebnisse liefern, wenn der Schalter offen ist.
Um ein korrektes Einlesen zu garantieren, wenn der Schalter offen ist, muss ein Pullup- oder Pulldown-Widerstand benutzt werden. Der Sinn davon ist es,
den Schalter auf einen validen Zustand zu ziehen, wenn er offen ist. Üblicherweise wird dazu ein 10KOhm-Widerstand verwendet, da dieser klein genug ist,
|
https://www.arduino.cc/reference/de/language/variables/constants/constants/index.html
|
efffa5d784a0-7
|
um die schwankenden Messwerte zu verhindern und zusätzlich groß genug, um nicht zu viel Spannung auf die Schaltung zu schicken, wenn der Schalter geschlossen
wird. Siehe auch das Digital Read Serial-Tutorial für weitere Informationen.
Wenn ein Pulldown-Widerstand benutzt wird, ist der Zustand des Schalters LOW, wenn der Schalter offen ist und HIGH, wenn der Schalter geschlossen ist.
Wenn ein Pullup-Widerstand benutzt wird, ist der Zustand des Schalters HIGH, wenn der Schalter offen ist und LOW, wenn der Schalter geschlossen ist.
INPUT_PULLUP
Der ATmega-Mikrocontroller auf dem Arduino hat interne Pullup-Widerstände, auf die zugegriffen werden kann. Wenn du diese statt externen Pullup-Widerstände
|
https://www.arduino.cc/reference/de/language/variables/constants/constants/index.html
|
efffa5d784a0-8
|
verwenden möchtest, kannst du pinMode() mit der Konstante INPUT_PULLUP als Argument verwenden.
Siehe auch das Input Pullup Serial-Tutorial für weitere Informationen.
Pins, die als INPUT oder INPUT_PULLUP definiert sind, können beschädigt oder zerstört werden, wenn diese Spannungen ausgesetzt werden, die negativ sind
oder über der maximalen Spannungsversorgung des Mikrocontrollers liegen (5V oder 3,3V).
OUTPUT
Pins, die mit pinMode() als OUTPUT definiert werden, sind in einem niederohmigen Zustand. Das bedeutet, dass sie einen
wesentlichen Teil an Spannung an andere Schaltkreise weitergeben können. ATmega-Pins können Strom bis 40 mA aufnehmen oder abgeben. Das macht sie nützlich, um z.B. LEDs
|
https://www.arduino.cc/reference/de/language/variables/constants/constants/index.html
|
efffa5d784a0-9
|
zu versorgen, da diese üblicherweise 40 mA nutzen. Motoren z.B. (Alles, das mehr als 40mA benötigt), brauchen dagegen einen Transistor.
Outputpins können beschädigt oder zerstört werden, wenn sie auf Masse oder auf positive Stromschienen verbunden werden.
Defining built-ins: LED_BUILTIN
Die meisten Arduinos haben einen Pin, der eine on-board LED über einen Vorschaltwiderstand ansteuert. Die on-board LED ist über die Konstante LED_BUILTIN ansteuerbar.
Die meisten Boards haben die LED auf Digitalpin 13 verbunden.
Siehe auch
|
https://www.arduino.cc/reference/de/language/variables/constants/constants/index.html
|
6786cbe42ca4-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
> Constants
> Floatingpointconstants
Gleitkommazahlkonstanten
[Constants]
Beschreibung
|
https://www.arduino.cc/reference/de/language/variables/constants/floatingpointconstants/index.html
|
6786cbe42ca4-1
|
[Constants]
Beschreibung
Ähnlich zu Integerkonstanten werden Gleitkommazahlkonstanten benutzt, um den Code lesbarer zu machen. Gleitkommazahlkonstanten werden zur Compilezeit
auf den Wert, den der Ausdruck ergibt, gesetzt.
Beispielcode
n = 0.005; // 0.005 ist eine Gleitkommazahlkonstante
Anmerkungen und Warnungen
Gleitkommazahlkonstanten können auch wissenschaftliche Notationen enthalten. 'E' und 'e' werden als Exponentenindikatoren verwendet.
Gleitkommazahlkonstanten
wird zu:
wird auch zu:
10.0
10
2.34E5
2.34 * 10^5
234000
67e-12
|
https://www.arduino.cc/reference/de/language/variables/constants/floatingpointconstants/index.html
|
6786cbe42ca4-2
|
2.34 * 10^5
234000
67e-12
67.0 * 10^-12
0.000000000067
Siehe auch
|
https://www.arduino.cc/reference/de/language/variables/constants/floatingpointconstants/index.html
|
5ff7738c71ae-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
> Functions
> Digital io
> Digitalread
digitalRead()
[Digital I/O]
Beschreibung
|
https://www.arduino.cc/reference/de/language/functions/digital-io/digitalread/index.html
|
5ff7738c71ae-1
|
digitalRead()
[Digital I/O]
Beschreibung
Liest einen Wert von einem vorgegebenen Digitalpin ein, entweder HIGH oder LOW.
Syntax
digitalRead(pin)
Parameter
pin: Die Nummer des Arduino-Digitalpins, welcher gelesen werden soll.
Rückgabewert
HIGH oder LOW.
Beispielcode
Setzt Pin 13 auf den gleichen Wert wie Pin 7, welcher als Eingang definiert ist.
int ledPin = 13; // LED verbunden mit Digitalpin 13
int inPin = 7; // Button verbunden mit Digitalpin 7
int val = 0; // Variable, um den gelesenen Wert zu speichern
void setup() {
pinMode(ledPin, OUTPUT); // Setzt den Digitalpin 13 als Outputpin
|
https://www.arduino.cc/reference/de/language/functions/digital-io/digitalread/index.html
|
5ff7738c71ae-2
|
pinMode(ledPin, OUTPUT); // Setzt den Digitalpin 13 als Outputpin
pinMode(inPin, INPUT); // Setzt den Digitalpin 7 als Intputpin
}
void loop() {
val = digitalRead(inPin); // Liest den Inputpin
digitalWrite(ledPin, val); // Setzt die LED auf den Wert des Buttons
}
Anmerkungen und Warnungen
Wenn der Pin nicht mit irgendetwas verbunden ist, kann digitalRead() entweder HIGH oder LOW (das passiert völlig zufällig) zurückgeben.
Die analogen Inputpins können als Digitalpins verwendet werden mit den Namen A0, A1, etc. Eine Ausnahme bilden die Pins A6 und A7 von Arduino Nano, Pro Mini und Mini, die nur als analoge Eingänge verwendet werden können.
Siehe auch
|
https://www.arduino.cc/reference/de/language/functions/digital-io/digitalread/index.html
|
5ff7738c71ae-3
|
Siehe auch
BEISPIEL-Tutorial: (Beschreibung der digitalen Pins)
|
https://www.arduino.cc/reference/de/language/functions/digital-io/digitalread/index.html
|
b8177cb62f2d-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
> Functions
> Digital io
> Digitalwrite
digitalWrite()
[Digital I/O]
Beschreibung
Schreibt einen HIGH- oder LOW-Wert auf einen Digitalpin.
|
https://www.arduino.cc/reference/de/language/functions/digital-io/digitalwrite/index.html
|
b8177cb62f2d-1
|
Beschreibung
Schreibt einen HIGH- oder LOW-Wert auf einen Digitalpin.
Wenn der Pin mit pinMode() als Outputpin gesetzt wird, wird die Spannung auf den Wert 5V (oder 3,3V) für HIGH gesetzt, 0V für LOW. Es wird empfohlen, den Pin mit pinMode() auf INPUT_PULLUP zu setzen, um den internen Pull-Up-Widerstand zu nutzen. Für mehr Informationen siehe: Tutorial zu Digitalpins.
Wenn du pinMode() nicht auf OUTPUT setzt, aber eine LED auf den Pin anschließt, kann die LED mit digitalWrite(HIGH) gedimmt erscheinen. Wenn pinMode() nicht explicit gesetzt wird, verwendet digitalWrite() den Pull-Up-Widerstand, der als eine Art großer spannungslimitierender Widerstand wirkt.
Syntax
digitalWrite(pin, value)
Parameter
pin: Die Arduino-Pinnummer.
|
https://www.arduino.cc/reference/de/language/functions/digital-io/digitalwrite/index.html
|
b8177cb62f2d-2
|
Syntax
digitalWrite(pin, value)
Parameter
pin: Die Arduino-Pinnummer.
value: HIGH oder LOW.
Rückgabewert
Nichts.
Beispielcode
Der Code deklariert Digitalpin 13 als OUTPUT und alterniert auf diesem Pin von HIGH auf LOW mit einem Abstand von einer Sekunde.
void setup() {
pinMode(13, OUTPUT); // Setzt den Digitalpin 13 als Outputpin
}
void loop() {
digitalWrite(13, HIGH); // Setzt den Digitalpin 13 auf HIGH = "Ein"
delay(1000); // Wartet eine Sekunde
digitalWrite(13, LOW); // Setzt den Digitalpin 13 auf LOW = "Aus"
delay(1000); // Wartet eine Sekunde
}
Anmerkungen und Warnungen
|
https://www.arduino.cc/reference/de/language/functions/digital-io/digitalwrite/index.html
|
b8177cb62f2d-3
|
}
Anmerkungen und Warnungen
Die analogen Inputpins können als Digitalpins verwendet werden mit den Namen A0, A1, etc. Die Ausnahme sind der Arduino Nano, Pro Mini, und die Arduino Mini-Pins A6 und A7, welche nur
als analoge Inputs genutzt werden können.
Siehe auch
BEISPIEL-Tutorial: (Beschreibung der digitalen Pins)
|
https://www.arduino.cc/reference/de/language/functions/digital-io/digitalwrite/index.html
|
24a5aa5534a8-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
> Functions
> Digital io
> Pinmode
pinMode()
[Digital I/O]
Beschreibung
|
https://www.arduino.cc/reference/de/language/functions/digital-io/pinmode/index.html
|
24a5aa5534a8-1
|
pinMode()
[Digital I/O]
Beschreibung
Konfiguriert den spezifizierten Pin als Input oder Output. Für mehr Informationen siehe: Beschreibung der digitalen Pins.
Seit Arduino 1.0.1 ist es möglich, den internen Pull-Up-Widerstand mit dem Modus INPUT_PULLUP zu setzen. Der INPUT-Modus deaktiviert den internen Pull-Up-Widerstand komplett.
Syntax
pinMode(pin, mode)
Parameter
pin: Die Arduino-Pinnummer, auf der der Pinmodus gesetzt werden soll.
mode: INPUT, OUTPUT oder INPUT_PULLUP. (Für mehr Informationen siehe: Beschreibung der digitalen Pins.)
Rückgabewert
Nichts.
Beispielcode
|
https://www.arduino.cc/reference/de/language/functions/digital-io/pinmode/index.html
|
24a5aa5534a8-2
|
Rückgabewert
Nichts.
Beispielcode
Der Code deklariert Digitalpin 13 als OUTPUT und alterniert auf diesem Pin von HIGH auf LOW mit einem Abstand von einer Sekunde.
void setup() {
pinMode(13, OUTPUT); // Setzt den Digitalpin 13 als Outputpin
}
void loop() {
digitalWrite(13, HIGH); // Setzt den Digitalpin 13 auf HIGH = "Ein"
delay(1000); // Wartet eine Sekunde
digitalWrite(13, LOW); // Setzt den Digitalpin 13 auf LOW = "Aus"
delay(1000); // Wartet eine Sekunde
}
Anmerkungen und Warnungen
Die analogen Inputpins können als Digitalpins verwendet werden mit den Namen A0, A1, etc.
Siehe auch
|
https://www.arduino.cc/reference/de/language/functions/digital-io/pinmode/index.html
|
24a5aa5534a8-3
|
Siehe auch
BEISPIEL-Tutorial: (Beschreibung der digitalen Pins)
|
https://www.arduino.cc/reference/de/language/functions/digital-io/pinmode/index.html
|
3eb3dbf8a438-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
> Functions
> Bits and bytes
> Highbyte
highByte()
[Bits and Bytes]
Beschreibung
|
https://www.arduino.cc/reference/de/language/functions/bits-and-bytes/highbyte/index.html
|
3eb3dbf8a438-1
|
highByte()
[Bits and Bytes]
Beschreibung
Liest das most-significant (linkeste) Bit eines Wortes (oder das zweitkleinste Bit eines größeren Datentypes).
Syntax
highByte(x)
Parameter
x: Wert von beliebigen Typ.
Rückgabewert
Das geforderte Byte. Datentyp: byte.
Siehe auch
SPRACHE word()
|
https://www.arduino.cc/reference/de/language/functions/bits-and-bytes/highbyte/index.html
|
e1c189da8d3e-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
> Functions
> Bits and bytes
> Bitread
bitRead()
[Bits and Bytes]
Beschreibung
Liest ein Bit aus einer Zahlenvariable.
Syntax
|
https://www.arduino.cc/reference/de/language/functions/bits-and-bytes/bitread/index.html
|
e1c189da8d3e-1
|
Beschreibung
Liest ein Bit aus einer Zahlenvariable.
Syntax
bitRead(x, n)
Parameter
x: Die Zahlenvariable, aus der gelesen werden soll.
n: Welches Bit gelesen werden soll; Startet bei 0 für das least-significant (rechteste) Bit.
Rückgabewert
Den Wert des Bits (0 oder 1).
Siehe auch
|
https://www.arduino.cc/reference/de/language/functions/bits-and-bytes/bitread/index.html
|
20ac89a4c2d2-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
> Functions
> Bits and bytes
> Bitwrite
bitWrite()
[Bits and Bytes]
Beschreibung
Schreibt ein Bit einer Zahlenvariable.
Syntax
|
https://www.arduino.cc/reference/de/language/functions/bits-and-bytes/bitwrite/index.html
|
20ac89a4c2d2-1
|
Beschreibung
Schreibt ein Bit einer Zahlenvariable.
Syntax
bitWrite(x, n, b)
Parameter
x: Die Zahlenvariable, auf die geschrieben werden soll.
n: Welches Bit der Zahlenvariable geschrieben werden soll; Startet bei 0 für das least-significant (rechteste) Bit.
b: Der Wert, der auf das Bit geschrieben werden soll (0 oder 1).
Rückgabewert
Nichts.
Beispielcode
Demonstriert die Verwendung von bitWrite, indem der Wert einer Variablen vor und nach der Verwendung von bitWrite() auf dem seriellen Monitor geschrieben wird.
void setup() {
Serial.begin(9600);
|
https://www.arduino.cc/reference/de/language/functions/bits-and-bytes/bitwrite/index.html
|
20ac89a4c2d2-2
|
void setup() {
Serial.begin(9600);
while (!Serial) {} // Warten, bis die serielle Schnittstelle verbunden ist. Wird nur für den nativen USB-Anschluss benötigt
byte x = 0b10000000; // Das 0b-Präfix gibt eine binäre Konstante an
Serial.println(x, BIN); // 10000000
bitWrite(x, 0, 1); // Schreibe 1 auf das niedrigstwertige Bit von x
Serial.println(x, BIN); // 10000001
}
void loop() {
// ...
}
Siehe auch
|
https://www.arduino.cc/reference/de/language/functions/bits-and-bytes/bitwrite/index.html
|
e451fca2171b-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
> Functions
> Bits and bytes
> Lowbyte
lowByte()
[Bits and Bytes]
Beschreibung
|
https://www.arduino.cc/reference/de/language/functions/bits-and-bytes/lowbyte/index.html
|
e451fca2171b-1
|
lowByte()
[Bits and Bytes]
Beschreibung
Liest das least-significant (rechteste) Bit eines Wortes oder größeren Datentypes.
Syntax
lowByte(x)
Parameter
x: Wert von beliebigen Typ.
Rückgabewert
Das geforderte Byte. Datentyp: byte.
Siehe auch
SPRACHE word()
|
https://www.arduino.cc/reference/de/language/functions/bits-and-bytes/lowbyte/index.html
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.