gavmac00/arduino-docs huggingface dataset:
Auf dem Arduino Uno (und anderen ATmega-basierten Boards) speichert ein int einen 16-Bit-Wert (2 Byte).
Dies ergibt einen Bereich von -32,768 bis 32,767 (Minimalwert -2^15 und Maximalwert (2^15) - 1).
Auf den Arduino Due- und SAMD-basierten Boards (wie MKR1000 und Zero) speichert ein int einen 32-Bit-Wert (4 Byte).
Dies ergibt einen Bereich von -2,147,483,648 to 2,147,483,647 (Minimalwert -2^31 und Maximalwert (2^31) - 1).
Int speichert negative Zahlen mit einer Technik namens (Zweierkomplement).
Int speichert negative Zahlen mit einer Technik namens (Zweierkomplement).
Das höchste Bit, manchmal auch als "Vorzeichen" bezeichnet, kennzeichnet die Zahl als negative Zahl. Die restlichen Bits werden invertiert und 1 wird hinzugefügt.
Der Arduino kümmert sich um den Umgang mit negativen Zahlen für dich, damit arithmetische Operationen auf die erwartete Weise transparent arbeiten.
Es kann unerwartete Komplikationen im Umgang mit dem Rechten Bitshift-Operator (>>) geben.
Syntax
int var = val
Parameter
var: Variablenname.
val: Der Wert, der der Variablen zugewiesen wird.
Beispielcode
val: Der Wert, der der Variablen zugewiesen wird.
Beispielcode
Dieser Code erstellt eine Ganzzahl namens 'countUp', die anfänglich als Zahl 0 (Null) festgelegt wird. Der Wert der Variable steigt in jeder Schleife um 1 (eins) und wird auf dem seriellen Monitor angezeigt.
int countUp = 0; // Erstellt eine variable Ganzzahl mit dem Namen 'countUp'
void setup() {
  Serial.begin(9600); // Verwende die serielle Schnittstelle, um die Nummer auszugeben
}
void loop() {
  countUp++;               // Fügt der countUp-Variable in jeder Schleife 1 hinzu
  Serial.println(countUp); // Gibt den aktuellen Stand von countUp aus
  delay(1000);
}
delay(1000);
}
Anmerkungen und Warnungen
Wenn vorzeichenbehaftete Variablen ihre maximale oder minimale Kapazität überschreiten, laufen sie über (Overflow).
Das Ergebnis eines Überlaufs ist unvorhersehbar, daher sollte dies vermieden werden.
Ein typisches Symptom für einen Überlauf ist die Variable, die von ihrer maximalen Kapazität auf das Minimum "umgedreht" wird oder umgekehrt, dies ist jedoch nicht immer der Fall.
Wenn du dieses Verhalten wünscht, verwende unsigned int.
Siehe auch
SPRACHE Ganzzahlkonstanten
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
        Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
    
    Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
    Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
    
Last Revision: Searching...
Last Build: 2023/06/30 
Bearbeite diese Seite
Reference
            >  Language
            >  Variables
            >  Data types
            > Word
          
word
          [Data Types]
          
Beschreibung
> Word
          
word
          [Data Types]
          
Beschreibung
Ein Wort kann eine vorzeichenlose Zahl von mindestens 16 Bits (von 0 bis 65535) speichern.
Syntax
word var = val
Parameter
var: Variablennamen.
val: Der Wert, der dieser Variablen zugewiesen werden soll.
Beispielcode
word w = 10000;
Siehe auch
Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
        Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.
    
    Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
    Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.
    
Last Revision: Searching...
Last Build: 2023/06/30 
Bearbeite diese Seite
Reference
            >  Language
            >  Variables
            >  Data types
            > Float
          
float
          [Data Types]
          
Beschreibung
Datentyp für Fließkommazahlen, eine Zahl mit Dezimalpunkt.
Datentyp für Fließkommazahlen, eine Zahl mit Dezimalpunkt.
Fließkommazahlen werden häufig zur Annäherung an analoge und kontinuierliche Werte verwendet, da sie eine höhere Auflösung als ganze Zahlen haben.
Fließkommazahlen können bis zu 3.4028235E+38 und bis zu -3.4028235E+38 betragen. Sie werden als 32 Bit (4 Byte) Informationen gespeichert.
Syntax
float var=val
Parameter
var: Variablenname.
val: Der Wert, der der Variablen zugewiesen wird.
Beispielcode
float myfloat;
float sensorCalbrate = 1.117;
int x;
int y;
float z;
x = 1;
int x;
int y;
float z;
x = 1;
y = x / 2;          // y enthält jetzt 0, ints können keine Brüche enthalten
z = (float)x / 2.0; // z enthält jetzt .5 (Du musst 2.0 verwenden, nicht 2)
Anmerkungen und Warnungen
Wenn du mit floats rechnest, musst du ein Dezimalzeichen hinzufügen, andernfalls wird es als int behandelt. Siehe die Fließpunkt-Konstanten-Seite für weitere Informationen.
Floats haben eine Genauigkeit von nur 6-7 Dezimalstellen. Das bedeutet die Gesamtzahl der Ziffern, nicht die Zahl rechts vom Dezimalpunkt.
Im Gegensatz zu anderen Plattformen, bei denen du durch die Verwendung eines double (z. B. bis zu 15 Ziffern) eine höhere Genauigkeit erzielen kannst, hat double auf dem Arduino die gleiche Größe wie float.
Fließkommazahlen sind nicht genau und können beim Vergleich zu seltsamen Ergebnissen führen. Zum Beispiel kann 6.0 / 3.0 nicht gleich 2.0 sein.
Du solltest stattdessen überprüfen, ob der absolute Wert der Differenz zwischen den Zahlen geringer als eine kleine Zahl ist.
Die Konvertierung von Gleitkomma- in Ganzzahl-Mathematik führt zu Kürzungen:
float x = 2.9; // Eine float-Variable
int y = x;  // 2
int y = x;  // 2
Wenn du stattdessen während des Konvertierungsprozesses abrunden möchtest, musst du 0,5 addieren:
float x = 2.9;
int y = x + 0.5;  // 3
oder die round()-Funktion nutzen:
float x = 2.9;
int y = round(x);  // 3
Die Gleitkomma-Mathematik ist bei Berechnungen auch viel langsamer als die Ganzzahl-Mathematik.
Es sollte also vermieden werden, wenn beispielsweise eine Schleife für eine kritische Timing-Funktion mit Höchstgeschwindigkeit laufen muss.
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
> 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
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
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
> 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() {
}
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
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
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
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
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
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()
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)
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
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
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
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.
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
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
> 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,
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
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
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
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.
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
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
> 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.
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
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
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
> 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";
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.
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.
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
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
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
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
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
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:
#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,+
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
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:
// 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() {
  // ...
}
}
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.
*/
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
// 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.
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:
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
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
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
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.
// 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
}
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
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
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'
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:
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'
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.
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
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
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.
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)
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)
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
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.
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,
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
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
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
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
[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
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