Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
        Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.

    Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
    Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.

Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
            >  Language
            >  Structure
            >  Control structure
            > Goto

goto
          [Control Structure]

Beschreibung
Springt im Programmfluss zu einem bestimmten benannten Punkt.
Syntax


Springt im Programmfluss zu einem bestimmten benannten Punkt.
Syntax
label:
goto label; // Springt zu dem Label.
Parameter
label: Das Label an der Stelle, zu der gesprungen werden soll.
Rückgabewert
Nichts.
Beispielcode
Der Code zeigt, wie goto aus einem Programm mit 3 Schleifen an eine bestimmte Stelle springt.
for(byte r = 0; r < 255; r++) {
  for(byte g = 255; g > -1; g--) {
    for(byte b = 0; b < 255; b++){
      if (analogRead(0) > 250){ goto bailout;}
        // Weitere Statements
      }
  }
}
bailout:
// Weitere Statements
Anmerkungen und Warnungen


}
bailout:
// Weitere Statements
Anmerkungen und Warnungen
Es wird nicht empfohlen, goto in der C++-Programmierung zu verwenden. Viele Autoren sagen sogar, dass der goto-Operator unnötig ist.
Das Problem mit goto ist, dass der Code schnell nahezu unlesbar wird und nicht mehr zu debuggen ist.
Manchmal kann ein goto nützlich sein. Z.B um aus einer hohen Schleifentiefe wie im Beispielcode oben herauszuspringen (Obwohl dies mit return auch klappen würde).
Siehe auch


Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
        Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.

    Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
    Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.

Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
            >  Language
            >  Structure
            >  Control structure
            > Return

return
          [Control Structure]

Beschreibung


> Return

return
          [Control Structure]

Beschreibung
Beendet eine Funktion und gibt einen Wert an die aufrufende Funktion zurück, wenn gewünscht.
Syntax
return
return value; // Beide Formen davon sind gültig
Parameter
value: Beliebige Variable oder Parameter. Erlaubte Datentypen: Beliebiger Datentyp.
Rückgabewert
Den Datentyp des Parameters value.
Beispielcode
Vergleicht einen Sensorwert mit einem Thresholdwert.
int checkSensor() {
  // Lies Wer von Sensor ein und vergleiche diesen mit der Konstante 400
  if (analogRead(0) > 400) {
    // Wenn Sensorwert größer als 400: Gib 1 zurück
    return 1;
  }
  else {


return 1;
  }
  else {
    // Sonst gib 0 zurück
    return 0;
  }
}
Das return-Keywort kann dazu dienen, Codeabschnitte zu testen ohne viel Code auskommentieren zu müssen.
void loop() {
  // Codeidee, die getestet werden soll, hier.
  return;
  // Der Rest des Sketches hier.
  // Wird niemals ausgeführt
}
Siehe auch


Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
        Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.

    Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
    Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.

Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
            >  Language
            >  Structure
            >  Control structure
            > Dowhile

do...while
          [Control Structure]

Beschreibung


do...while
          [Control Structure]

Beschreibung
do…while funktioniert genauso wie eine while-Schleife. Der einzige Unterschied ist, dass do…while immer mindestens einmal ausgeführt wird,
da die Bedingung erst am Schluss der Schleife getestet wird.
Syntax
do {
   //Statement(s)
} while (condition);
Parameter
condition: Ein Ausdruck, der auf true oder false evaluiert.
Rückgabewert
Nichts.
Beispielcode
Liest in do-while-Schleife 100 Mal einen Sensorwert aus.
// Initialisiere x mit Wert 0
int x = 0;
do {
  delay(50);          // Warte 50 Millieskunden, bis der Sensor wieder einen stabilen Wert liefert.


x = readSensor();   // Lies den Sensorwert
} while (x < 100);    // Wiederhole das ganze 100 Mal
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
            >  Structure
            >  Control structure
            > Continue

continue
          [Control Structure]

Beschreibung


> Continue

continue
          [Control Structure]

Beschreibung
Das continue-Statement überspringt die restliche Iteration einer Schleife (for, while oder do…while).
Das continue-Statement checkt anschließend die condition und durchläuft die Schleife erneut, bis die Abbruchbedingung erreicht ist.
Syntax
while (condition) {
   //Statement(s)
   continue;
   //Statement(s)
}
Parameter
Keine.
Rückgabewert
Nichts.
Beispielcode
Der Code schreibt die Werte von 0 bis 255 auf den LED-Pin, aber überspringt Werte zwischen 41 und 119.
// Iteriere über die Werte von 0 bis 255
for (int x = 0; x <= 255; x ++) {


for (int x = 0; x <= 255; x ++) {
  // Springe bei den Werten zwischen 40 und 120 weiter
  if (x > 40 && x < 120){
    continue;
  }
  // Schreibe den Wert auf den LED-Pin
  analogWrite(PWMpin, x);
  // Warte 50 Millieskunden
  delay(50);
}
Siehe auch


Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
        Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.

    Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
    Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.

Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
            >  Language
            >  Structure
            >  Control structure
            > Switchcase

switch...case
          [Control Structure]

Beschreibung


switch...case
          [Control Structure]

Beschreibung
Wie auch if-Statements, erlaubt es auch switch case, dass abhängig von der Bedingung in verschiedenen Situationen unterschiedlicher Code ausgeführt wird.
Im Detail vergleicht switch case die Variablenwerte mit denen in den case-Statements. Wenn ein passendes case-Statement gefunden wird, so wird der Code in diesem
case-Statement ausgeführt.
Das break-Keywort beendet das switch case-Statement und wird üblicherweise am Ende jedes case-Statements verwendet. Wenn kein break-Keywort
verwendet wird, führt switch case alle Statements aus, bis ein break-Keywort auftaucht oder das switch case zu Ende ist.
Syntax
switch (var) {
  case label1:
    // Statement(s)
    break;
  case label2:
    // Statement(s)


break;
  case label2:
    // Statement(s)
    break;
  default:
    // Statement(s)
    break; // Wird nicht benötigt, wenn Statement(s) vorhanden sind
}
Parameter
var: Eine Variable, die mit den eizelnen Fällen verglichen werden sollen. Erlaubte Datentypen: int, char.
label1, label2: Konstanten. Erlaubte Datentypen: int, char.
Rückgabewert
Nichts.
Beispielcode
Das Code-Beispiel zeigt die Verwendung des switch-case-Statements.
switch (var) {
  case 1:
    // Tue etwas, wenn "var" 1 ist
    break;
  case 2:
    // Tue etwas, wenn "var" 2 ist
    break;
  default:


break;
  default:
    // Tue etwas, im Defaultfall
    // Dieser Fall ist optional
    break; // Wird nicht benötigt, wenn Statement(s) vorhanden sind
}
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
            >  Structure
            >  Control structure
            > While

while
          [Control Structure]

Beschreibung


> While

while
          [Control Structure]

Beschreibung
Eine while-Schleife läuft solange weiter (Eventuell auch unendlich), bis die Bedingung in den Klammern () false wird. Wenn die Variable in der Schleife
sich nie ändert, läuft die Schleife unendlich. Dies kann z.B. durch das Hochzählen einer Variable oder das Lesen eines Sensorwertes erfolgen.
Syntax
while(condition) {
  // Statement(s)
}
Parameter
condition: Ein Ausdruck, der auf true oder false evaluiert.
Rückgabewert
Nichts.
Beispielcode
Dieser Code zählt eine Variable 200-mal um 1 hoch.
var = 0;
// Wiederhole etwas 200 Mal
while(var < 200) {


// Wiederhole etwas 200 Mal
while(var < 200) {
  // Zähle Variable x um 1 hoch
  var++;
}
Siehe auch
BEISPIEL While


Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
        Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.

    Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
    Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.

Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
            >  Language
            >  Variables
            >  Variable scope qualifiers
            > Volatile

volatile
          [Data Types]

Beschreibung


volatile
          [Data Types]

Beschreibung
volatile ist ein Variablenkennzeichner. Dieser wird normalerweise vor dem Datentyp der Variable angegeben. Der Compiler behandelt je nach Kennzeichner dann die
Variable auf andere Art.
Eine volatile- Variable ist eine Direktive für den Compiler. Der Compiler ist eine Software, die deinen C/C++-Code in Maschinencode übersetzt, der dann die "richtigen"
Anweisungen für den Arduino enthält.
Im Detail zeigt volatile dem Compiler, dass er die Variable aus dem RAM und nicht aus dem Speicherregister laden soll. Unter bestimmten Bedingungen können die Variablen
in den Registern ungenau sein.


in den Registern ungenau sein.
Eine Variable sollte als volatile deklariert werden, wenn sie von irgendwo anders geändert werden kann außer in dem Codeteil, in dem sie auftaucht. Beispiele dafür sind
Threads, die parallel ausgeführt werden. Im Arduino kann das nur bei Interrupts vorkommen, in sogennanten Interrupt Service Routinen.
int oder long volatile Variablen
Wenn die Variable größer als Byte ist (also z.B. ein 16-Bit-Integer oder ein 32-Bit-Long), kann der Mikrocontroller sie nicht in einem Durchgang lesen, da es ein
8-Bit-Mikrocontroller ist. Das bedeutet, das während das Hauptprogramm die ersten 8 Bit der Variable liest, kann der Interrupt bereits die zweiten 8 Bit geändert haben.


Das kann zufällig und unvorhersehbare Ergebnisse liefern.
Gegenmaßnahme:
Während die Variable gelesen wird, müssen Interrupts deaktiviert werden, sodass diese die Bits nicht verändern können während sie gelesen werden.
Es gibt mehrere Möglichkeiten, das zu tun:
SPRACHE noInterrupts
Das ATOMIC_BLOCK-Makro. Atomare Operationen sind einzelne MCU-Operationen-Die kleinste mögliche Einheit.
Beispielcode
Der Modifikator volatile stellt sicher, dass Änderungen an der Variablen state sofort in loop() sichtbar sind.
Ohne den Modifikator volatile kann die Variable state beim Eingeben der Funktion in ein Register geladen werden und wird erst nach Beendigung der Funktion aktualisiert.
// Die LED wird angeschaltet, wenn der Interrupt-Pin den Status ändert.


// Die LED wird angeschaltet, wenn der Interrupt-Pin den Status ändert.
volatile byte changed = 0;
void setup() {
  // Deklariere den LED-Pin als Output-Pin
  pinMode(LED_BUILTIN, OUTPUT);
  // Setze einen Interrupt
  attachInterrupt(digitalPinToInterrupt(2), toggle, CHANGE);
}
void loop() {
  if (changed == 1) {
    // toggle() wurde vom Interrupt aus aufgerufen!
    // changed auf 0 zurücksetzen
    changed = 0;
    // LED für 200 ms blinken lassen
    digitalWrite(LED_BUILTIN, HIGH);
    delay(200);
    digitalWrite(LED_BUILTIN, LOW);
  }
}
void toggle() {
  // Invertiere den Status, dass die LED blinkt
  changed = 1;
}


changed = 1;
}
Verwenden Sie das Makro ATOMIC_BLOCK, um auf eine Variable zuzugreifen, deren Größe größer ist als der 8-Bit-Datenbus des Mikrocontrollers.
Das Makro stellt sicher, dass die Variable in einer atomaren Operation gelesen wird, d.H. ihr Inhalt kann nicht geändert werden, während sie gelesen wird.
#include <util/atomic.h> // Diese Bibliothek fügt das ATOMIC_BLOCK-Makro ein.
volatile int input_from_interrupt;
// Irgendwo im Code, z.B. in loop()
ATOMIC_BLOCK(ATOMIC_RESTORESTATE) {
  // Code mit geblockten Interrupts hier (Mehrere atomare Operationen hintereinander werden nicht durch Interrupts unterbrochen)
  int result = input_from_interrupt;
}
Siehe auch
SPRACHE attachInterrupt


Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
        Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.

    Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
    Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.

Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
            >  Language
            >  Variables
            >  Variable scope qualifiers
            > Const

const
          [Data Types]

Beschreibung


> Const

const
          [Data Types]

Beschreibung
Das const-Keywort steht für Konstanten. Es ist ein Variablenkennzeichner, der das Verhalten der Variable verändert. In diesem Fall wird die Variable "read-only".
Das bedeutet, dass die Variable wie alle anderen Variablen des gleichen Typs benutzt werden kann, aber dass der Wert unveränderlich ist. Wenn du der Variable einen
neuen Wert zuweist, bekommst du einen Compiler-Fehler.
Konstanten, die mit const versehen sind, folgen den Regeln des Variablenscopes. Dieses Vorgehen und die Fallen bei der Verwendung von
#define sorgt dafür, dass const bevorzugt vor #define
benutzt werden sollte.
Beispielcode
Der Code zeigt die Verwendung von konstanten Variablen.


Beispielcode
Der Code zeigt die Verwendung von konstanten Variablen.
// Definiere Pi als Konstante
const float pi = 3.14;
// Variable x zum Speichern des Ergebnisses
float x;
// ....
x = pi * 2; // Das ist erlaubt.
pi = 7;     // Illegal-Konstante darf/kann nicht verändert werden.
Anmerkungen und Warnungen
#define oder const
Du kannst entweder const oder #define für Konstanten verwenden. Für Arrays
musst du const verwenden. Generell wird const vor #define vorgezogen.
Siehe auch
SPRACHE #define


Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
        Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.

    Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
    Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.

Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
            >  Language
            >  Variables
            >  Variable scope qualifiers
            > Scope

scope
          [Data Types]

Beschreibung


> Scope

scope
          [Data Types]

Beschreibung
Variablen in der C++-Programmiersprache, auf die Arduino aufbaut, haben eine Eigenschaft, die sich Scope nennt. Im Gegensatz zu früheren Programmiersprachen,
wie z.B. BASIC, sind in C nicht alle Variablen global verfügar.
Eine globale Variable ist eine Variable, die von jeder Funktion in dem Programm "gesehen" werden kann. Lokale Variablen sind nur gültig in der Funktion, in der
sie deklariert wurden und können von außerhalb nicht verändert werden. In der Arduino-Umgebung ist jede Variable, die außerhalb einer Funktion (z.B. setup(), loop(), etc. )
definiert wird, eine globale Variable.


definiert wird, eine globale Variable.
Wenn Programme größer und komplexer werden, sind lokale Variablen eine Möglichkeit, sicherzustellen, dass nur die Funktion Zugriff auf die Variable hat, die dies wirklich benötigt.
Das verhindert unter Anderem, dass Funktionen unabsichtlich die Variablen anderer Funktionen ändern und damit unvorhersehbare Ergebnisse produzieren.
Manchmal macht es auch Sinn, eine Variable direkt in einer for-Schleife zu initialisieren. Diese Variable ist dann nur innerhalb der for-Schleife gültig.
Beispielcode
Der Code beschreibt den Unterschied zwischen lokalen und globalen Variablen.
int gPWMval;  // Globale Variable, die jede Funktion "sehen" kann
void setup() {
  // ...
}
void loop() {


void setup() {
  // ...
}
void loop() {
  int i;    // "i" ist nur "sichtbar" innerhalb von "loop"
  float f;  // "f" ist nur "sichtbar" innerhalb von "loop"
  // ...
  for (int j = 0; j <100; j++) {
    // Variable j kann nur innerhalb der Schleife benutzt werden
  }
}
Siehe auch


Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
        Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.

    Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
    Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.

Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
            >  Language
            >  Variables
            >  Variable scope qualifiers
            > Static

static
          [Data Types]

Beschreibung


> Static

static
          [Data Types]

Beschreibung
Das static-Keywort ermöglicht es, dass Variablen nur für eine Funktion sichtbar sind. Anders als lokale Variablen, die bei jedem Funktionsaufruf neu belegt werden,
behalten statische Variablen deren Wert über das Funktionsende hinaus bei.
Statische Variablen werden nur einmal erstellt, wenn die Funktion das erste Mal aufgerufen wird.
Beispielcode
Der Code wandert zufällig zwischen 2 Endpunkten umher.
/* RandomWalk
* Paul Badger 2007
* RandomWalk wandert zufällig zwischen 2 Endpunkten umher.
* Die maximale Bewegug pro Schritt wird über "stepsize" festgelegt.
* Eine statische Variable wird dazu um einen zufälligen Wert hoch- bzw.


* Eine statische Variable wird dazu um einen zufälligen Wert hoch- bzw.
* heruntergezählt.
* Das ist auch bekannt als "pink noise" und "drunken walk".
*/
// Definiere die maximale und minimale Beschränkung der Funktion
#define randomWalkLowRange -20
#define randomWalkHighRange 20
// Variable für die Schrittweite pro Durchlauf
int stepsize;
// Variable zur Speicherung des aktuellen Ergebnisses der RandomWalk-Funktion
int thisTime;
int total;
void setup() {
  // Initialisiere die serielle Verbindung
  Serial.begin(9600);
}
void loop() {
  // Initialisiere die Schrittweite
  stepsize = 5;
  // Rufe die randomWalk-Funktion auf und speichere das Ergebnis


// Rufe die randomWalk-Funktion auf und speichere das Ergebnis
  // in der Variable "thisTime"
  thisTime = randomWalk(stepsize);
  // Gib den Wert der Variable "thisTime" aus
  Serial.println(thisTime);
  // Warte 10 ms
  delay(10);
}
int randomWalk(int moveSize) {
  // Variable, um den Wert in der randomWalk-Funktion zu speichern
  // Nur diese Funktion kann den Wert ändern, der Wert ist aber von
  // Aufruf zu Aufruf wieder verfügbar
  static int  place;
  // Zufällige Bewegung
  place = place + (random(-moveSize, moveSize + 1));
  // Check, ob die Limits verletzt wurden
  if (place < randomWalkLowRange) {


if (place < randomWalkLowRange) {
	// Korrigiere den aktuellen Schritt in die positive Richtung
    place = randomWalkLowRange + (randomWalkLowRange - place);
  }
  else if(place > randomWalkHighRange) {
	// Korrigiere den aktuellen Schritt in die negative Richtung
    place = randomWalkHighRange - (place - randomWalkHighRange);
  }
  // Gib die neue Position zurück
  return place;
}


Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
        Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.

    Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
    Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.

Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
            >  Language
            >  Variables
            >  Conversion
            > Bytecast

byte()
          [Conversion]

Beschreibung
Konvertiert einen Wert in den byte-Datentyp.
Syntax
byte(x)


Konvertiert einen Wert in den byte-Datentyp.
Syntax
byte(x)
(byte)x (Typ-Konvertierung wie in C)
Parameter
x: Ein Wert beliebigen Typs. Erlaubte Datentypen: Beliebiger Datentyp.
Rückgabewert
Datentyp: byte.
Siehe auch
SPRACHE byte


Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
        Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.

    Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
    Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.

Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
            >  Language
            >  Variables
            >  Conversion
            > Wordcast

word()
          [Conversion]

Beschreibung
Konvertiert einen Wert in den word-Datentyp.
Syntax


Beschreibung
Konvertiert einen Wert in den word-Datentyp.
Syntax
word(h, l)
(word)x (Typ-Konvertierung wie in C)
Parameter
x: Ein Wert beliebigen Typs. Erlaubte Datentypen: Beliebiger Datentyp.
h: Das high-order (linkeste) byte des Words.
l: Das low-order (rechteste) byte des Words.
Rückgabewert
Datentyp: word.
Siehe auch
SPRACHE word


Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
        Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.

    Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
    Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.

Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
            >  Language
            >  Variables
            >  Conversion
            > Intcast

int()
          [Conversion]

Beschreibung
Konvertiert einen Wert in den int-Datentyp.
Syntax
int(x)


Konvertiert einen Wert in den int-Datentyp.
Syntax
int(x)
(int)x (Typ-Konvertierung wie in C)
Parameter
x: Ein Wert beliebigen Typs. Erlaubte Datentypen: Beliebiger Datentyp.
Rückgabewert
Datentyp: int.
Siehe auch
SPRACHE int


Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
        Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.

    Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
    Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.

Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
            >  Language
            >  Variables
            >  Conversion
            > Charcast

char()
          [Conversion]

Beschreibung
Konvertiert einen Wert in den char-Datentyp.
Syntax
char(x)


Konvertiert einen Wert in den char-Datentyp.
Syntax
char(x)
(char)x (Typ-Konvertierung wie in C)
Parameter
x: Ein Wert beliebigen Typs. Erlaubte Datentypen: Beliebiger Datentyp.
Rückgabewert
Datentyp: char.
Siehe auch
SPRACHE char


Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
        Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.

    Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
    Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.

Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
            >  Language
            >  Variables
            >  Conversion
            > Unsignedlongcast

(unsigned long)
          [Conversion]

Beschreibung
Konvertiert einen Wert in den unsigned long-Datentyp.
Syntax


Konvertiert einen Wert in den unsigned long-Datentyp.
Syntax
(unsigned long)x
Parameter
x: Ein Wert beliebigen Typs. Erlaubte Datentypen: Beliebiger Datentyp.
Rückgabewert
Datentyp: unsigned long.
Siehe auch
LANGUAGE unsigned long


Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
        Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.

    Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
    Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.

Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
            >  Language
            >  Variables
            >  Conversion
            > Floatcast

float()
          [Conversion]

Beschreibung
Konvertiert einen Wert in den float-Datentyp.
Syntax
float(x)


Konvertiert einen Wert in den float-Datentyp.
Syntax
float(x)
(float)x (Typ-Konvertierung wie in C)
Parameter
x: Ein Wert beliebigen Typs. Erlaubte Datentypen: Beliebiger Datentyp.
Rückgabewert
Datentyp: float.
Anmerkungen und Warnungen
Siehe die Referenz des Datentyps float für Details über Präzision und Fließkommazahlen auf dem Arduino.
Siehe auch
SPRACHE float


Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
        Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.

    Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
    Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.

Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
            >  Language
            >  Variables
            >  Conversion
            > Longcast

long()
          [Conversion]

Beschreibung
Konvertiert einen Wert in den long-Datentyp.
Syntax
long(x)


Konvertiert einen Wert in den long-Datentyp.
Syntax
long(x)
(long)x (Typ-Konvertierung wie in C)
Parameter
x: Ein Wert beliebigen Typs. Erlaubte Datentypen: Beliebiger Datentyp.
Rückgabewert
Datentyp: long.
Siehe auch
SPRACHE long


Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
        Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.

    Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
    Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.

Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
            >  Language
            >  Variables
            >  Conversion
            > Unsignedintcast

(unsigned int)
          [Conversion]

Beschreibung
Konvertiert einen Wert in den unsigned int-Datentyp.
Syntax


Konvertiert einen Wert in den unsigned int-Datentyp.
Syntax
(unsigned int)x
Parameter
x: Ein Wert beliebigen Typs. Erlaubte Datentypen: Beliebiger Datentyp.
Rückgabewert
Datentyp: unsigned int.
Siehe auch
LANGUAGE unsigned int


Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
        Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.

    Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
    Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.

Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
            >  Language
            >  Variables
            >  Data types
            > String

string
          [Data Types]

Beschreibung


> String

string
          [Data Types]

Beschreibung
Textzeichenfolgen können auf zwei Arten dargestellt werden. Du kannst den String-Datentyp verwenden, der ab Version 0019 Teil des Kerns ist oder du kannst einen
String aus einem Array des Typs char erstellen und ihn mit einem Nullterminator abschließen.
Diese Seite beschreibt die letztere Methode. Für weitere Informationen zum String-Objekt, das mehr Funktionalität auf Kosten von mehr Arbeitsspeicher bietet, siehe die string object-Seite.
Syntax
Alle folgenden Angaben sind gültige Deklarationen für Strings.
char Str1[15];
char Str2[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o'};


char Str3[8] = {'a', 'r', 'd', 'u', 'i', 'n', 'o', '\0'};
char Str4[ ] = "arduino";
char Str5[8] = "arduino";
char Str6[15] = "arduino";
Möglichkeiten zur Deklaration von Strings
Deklariere ein Array von Zeichen, ohne es wie in Str1 zu initialisieren
Deklariere ein Array von chars (mit einem zusätzlichen char) und der Compiler fügt das erforderliche Nullzeichen wie in Str2 hinzu
Füge das Nullzeichen explizit hinzu, Str3


Füge das Nullzeichen explizit hinzu, Str3
Initialisiere mit einer String-Konstante in Anführungszeichen. Der Compiler passt die Größe des Arrays an die String-Konstante und fügt ein abschließendes Nullzeichen an, Str4
Initialisiere das Array mit einer expliziten Größen- und Zeichenfolgekonstante, Str5
Initialisiere das Array und lasse zusätzlichen Platz für eine größere Zeichenfolge, Str6
Null-Termination
Im Allgemeinen werden Zeichenfolgen mit einem Nullzeichen (ASCII-Code 0) abgeschlossen. Dadurch können Funktionen (wie Serial.print()) erkennen, wo das Ende eines Strings ist.
Andernfalls würden sie nachfolgende Speicherbytes lesen, die eigentlich nicht Teil der Zeichenfolge sind.


Das bedeutet, dass die Zeichenfolge Platz für ein Zeichen mehr als den gewünschten Text haben muss.
Aus diesem Grund müssen Str2 und Str5 acht Zeichen haben, obwohl "Arduino" nur sieben hat - die letzte Position wird automatisch mit einem Nullzeichen gefüllt.
Str4 wird automatisch in acht Zeichen umgewandelt, eines für die zusätzliche Null. In Str3 haben wir das Nullzeichen (geschrieben als '\0') selbst explizit eingefügt.
Beachte, dass es möglich ist, eine Zeichenfolge ohne ein abschließendes Nullzeichen zu verwenden (z. B. wenn du die Länge von Str2 mit sieben statt mit acht angegeben hättest).
Dadurch werden die meisten Funktionen, die Zeichenfolgen verwenden, nicht mehr richtig funktionieren.


Wenn du feststellst, dass sich etwas merkwürdig verhält (mit Zeichen, die sich nicht in der Zeichenfolge befinden), kann dies jedoch das Problem sein.
Einfache oder doppelte Anführungszeichen?
Strings werden immer in doppelten Anführungszeichen ("Abc") und chars in einfachen Anführungszeichen ('A') definiert.
Lange strings umbrechen
Du kannst lange Zeichenfolgen wie folgt umbrechen:
char myString[] = "This is the first line"
" this is the second line"
" etcetera";
Arrays von Strings
Wenn du mit großen Textmengen arbeitest, z. B. bei einem Projekt mit LCD-Display, ist es oft praktisch, ein String-Array zu erstellen.


Da Strings selbst Arrays sind, handelt es sich eigentlich um ein zweidimensionales Array.
In dem folgenden Code zeigt das Sternchen hinter dem Datentyp char “char*” an, dass dies ein Array von “Zeigern” ist.
Alle Array-Namen sind eigentlich Zeiger, daher ist dies zum Erstellen eines Arrays aus Arrays erforderlich. Zeiger sind eine der eher esoterischen Komponenten von C ++,
die für Anfänger schwer verständlich sind, aber es ist nicht notwendig,Zeiger im Detail zu verstehen, um sie hier effektiv zu verwenden.
Beispielcode
char* myStrings[]={ "This is string 1", "This is string 2", "This is string 3",
"This is string 4", "This is string 5","This is string 6"};
void setup() {
  Serial.begin(9600);
}


void setup() {
  Serial.begin(9600);
}
void loop() {
  for (int i = 0; i < 6; i++) {
    Serial.println(myStrings[i]);
    delay(500);
  }
}
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
            > Void

void
          [Data Types]

Beschreibung


> Void

void
          [Data Types]

Beschreibung
Das Schlüsselwort void wird nur in Funktionsdeklarationen verwendet. Es zeigt an, dass die Funktion voraussichtlich keine Informationen an die Funktion zurückgibt, von der sie aufgerufen wurde.
Beispielcode
Der Code zeigt, wie void verwendet wird.
// Aktionen werden in den Funktionen `setup()` und `loop()` ausgeführt.
// Es werden jedoch keine Informationen an das größere Programm gemeldet.
void setup() {
  // ...
}
void loop() {
  // ...
}
Siehe auch
SPRACHE Ganzzahlkonstanten


Sprache
Funktionen
Variablen
Struktur
Bibliotheken
IoT Cloud API
Glossar
        Der Arduino-Referenztext ist lizenziert unter der Creative Commons Attribution-Share Alike 3.0 Lizenz.

    Findest du etwas, das verbessert werden kann? Über GitHub kannst du Korrekturen und neue Dokumentation vorschlagen.
    Zweifel, wie man Github benutzt? Erfahre in diesem Tutorial alles, was du wissen musst.

Last Revision: Searching...
Last Build: 2023/06/30
Bearbeite diese Seite
Reference
            >  Language
            >  Variables
            >  Data types
            > Int

int
          [Data Types]

Beschreibung
Ganzzahlen sind der primäre Datentyp für die Nummernspeicherung.


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.


Programmierer gehen oft etwas in die Länge und konvertieren Gleitkomma-Berechnungen in Ganzzahl-Mathematik, um die Geschwindigkeit zu erhöhen.
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
            > 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


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


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


> 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


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,


ob sich die implizierte Genauigkeit von der tatsächlich bei ATMEGA-basierten Arduinos erreichten unterscheidet.
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
            > 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


x = x + 1; // x enthält jetzt 0
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
            > 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


> 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()


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


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


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


a 'ul' oder 'UL': Ändert den Datentyp der Konstante auf unsigned long. Beispiel: 32767ul
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
            > 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


2.34 * 10^5
234000
67e-12
67.0 * 10^-12
0.000000000067
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
            >  Functions
            >  Digital io
            > Digitalread

digitalRead()
          [Digital I/O]

Beschreibung


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


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


Siehe auch
BEISPIEL-Tutorial: (Beschreibung der digitalen Pins)


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.


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.


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


}
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)


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


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


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


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


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()


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


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


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


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);


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


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


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()


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
            > Bitset

bitSet()
          [Bits and Bytes]

Beschreibung


bitSet()
          [Bits and Bytes]

Beschreibung
Setzt (Schreibt eine 1) ein Bit einer Zahlenvariable.
Syntax
bitSet(x, n)
Parameter
x: Die Zahlenvariable, in der das Bit gesetzt werden soll.
n: Welches Bit gesetzt werden soll; Startet bei 0 für das least-significant (rechteste) Bit.
Rückgabewert
Nichts.
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
            >  Functions
            >  Bits and bytes
            > Bitclear

bitClear()
          [Bits and Bytes]

Beschreibung


bitClear()
          [Bits and Bytes]

Beschreibung
Löscht den Wert (Schreibt 0) eines Bits einer Zahlen-Variable.
Syntax
bitClear(x, n)
Parameter
x: Die Zahlenvariable, deren Wert gelöscht werden soll.
n: Welches Bit gelöscht werden soll; Startet bei 0 für das least-significant (rechteste) Bit.
Rückgabewert
x: Der Wert der numerischen Variablen nach dem Löschen des Bits an Position n.
Beispielcode


Beispielcode
Gibt das Ergebnis von bitClear (x, n) aus und verwendet zwei vorgegebenen ganzen Zahlen. Die binäre Darstellung von 6 ist 0110. Wenn also n=1 ist, wird das zweite Bit von rechts auf 0 gesetzt. Danach bleibt 0100 in binär, so dass 4 zurückgegeben wird.
void setup() {
  Serial.begin(9600);
  while (!Serial) {
    ; // Wartet, bis die serielle Schnittstelle hergestellt ist. Wird nur für den nativen USB-Anschluss benötigt.
  }
  int x = 6;
  int n = 1;
  Serial.print(bitClear(x, n)); // Drucke die Ausgabe von bitClear(x,n) auf den seriellen Monitor.
}
void loop() {
}


}
void loop() {
}
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
            >  Functions
            >  Bits and bytes
            > Bit

bit()
          [Bits and Bytes]

Beschreibung


bit()
          [Bits and Bytes]

Beschreibung
Berechnet die Wertigkeit des angegebenen Bits (Bit 0 ist 1, Bit 1 ist 2, Bit 2 ist 4, etc.).
Syntax
bit(n)
Parameter
n: Das Bit, von dem der Wert berechnet werden soll.
Rückgabewert
Der Wert des Bits.
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
            >  Functions
            >  Communication
            > Wire

Wire
          [Communication]

Description


> Wire

Wire
          [Communication]

Description
This library allows you to communicate with I2C/TWI devices. On the Arduino boards with the R3 layout (1.0 pinout), the SDA (data line) and SCL (clock line) are on the pin headers close to the AREF pin. The Arduino Due has two I2C/TWI interfaces SDA1 and SCL1 are near to the AREF pin and the additional one is on pins 20 and 21.
As a reference the table below shows where TWI pins are located on various Arduino boards.
Board
I2C/TWI pins
UNO, Ethernet
A4 (SDA), A5 (SCL)
Mega2560
20 (SDA), 21 (SCL)
Leonardo
20 (SDA), 21 (SCL), SDA1, SCL1