Grundlagen · 10 Min. Lesezeit

Arduino Arrays: Array definieren, for-Schleife und Beispiele

Arduino Arrays einfach erklärt: Array deklarieren, Index, for-Schleife, 2D-Arrays, LED-Pins, Sensor-Mittelwert und Melodie mit Beispielcode für Uno.

Arrays in Arduino sind eine grundlegende Programmiertechnik: Du fasst viele Werte desselben Typs unter einem Namen zusammen und greifst über ihre Nummer (den Index) auf jeden einzelnen zu. Die Pin-Nummern von sechs LEDs, die letzten zehn Sensormessungen oder die Noten eines Liedes schreibst du nicht einzeln als led1, led2, led3 in separate Variablen, sondern speicherst sie in einem Array und bearbeitest alles mit einer for-Schleife in wenigen Zeilen. So wird dein Code kürzer, du machst weniger Fehler, und für eine neue LED in der Schaltung reicht eine weitere Zahl in der Liste.

In dieser Anleitung lernst du, wie ein Array im Speicher liegt, wie du es definierst, warum der Index bei null beginnt und wie du die Elementanzahl mit sizeof berechnest. Danach bauen wir drei echte Beispiele: einen Knight-Rider-LED-Effekt, einen gleitenden Mittelwert, der verrauschte Sensordaten glättet, und eine Melodie mit Buzzer. Zum Schluss baust du mit zweidimensionalen Arrays eine Ampel-Zustandstabelle, siehst die Unterschiede bei ESP32 und Raspberry Pi Pico und erfährst, wie du Überlauffehler findest, die dein Programm still kaputtmachen. Wenn du ganz neu bist, wirf zuerst einen Blick auf Arduino-Programmiergrundlagen.

LEDs für ein Arduino-Array-Beispiel
Sechs LEDs über ein einziges Pin-Array statt einzeln anzusteuern ist der klassische Anwendungsfall für Arrays.

Was ist ein Array und wie funktioniert es?

Ein Array ist ein Block aus Elementen, die nebeneinander im Speicher liegen und alle denselben Datentyp haben. Stell es dir wie einen Schrank mit nummerierten Schubladen vor: Der Schrank hat einen Namen, jede Schublade eine Nummer. In der C/C++-basierten Arduino-Sprache beginnt diese Nummerierung bei 0; ein Array mit 5 Elementen hat die Indizes 0, 1, 2, 3 und 4, der letzte Index ist also immer die Elementanzahl minus eins. Der Compiler kennt die Startadresse des Arrays; schreibst du array[3], addiert er 3 × Elementgröße zur Startadresse und springt direkt zu dieser Zelle. Der Zugriff ist deshalb sehr schnell, aber aus demselben Grund prüft der Compiler nicht, ob du die Grenzen verlässt. Der Speicherbedarf eines Arrays ist Elementanzahl mal Größe eines Elements:

DatentypElementgröße (Uno)Elementgröße (ESP32 / Pico, C++)Array mit 100 Elementen (Uno)
byte / uint8_t1 Byte1 Byte100 Byte
char1 Byte1 Byte100 Byte
int2 Byte4 Byte200 Byte
unsigned int2 Byte4 Byte200 Byte
long4 Byte4 Byte400 Byte
float4 Byte4 Byte400 Byte

Der Arduino Uno hat nur 2 KB (2048 Byte) RAM; ein int-Array mit 1000 Elementen würde also fast den gesamten Speicher allein auffressen. Deshalb ist es eine gute Gewohnheit, für Werte zwischen 0 und 255 (Pin-Nummern, PWM-Helligkeit, Tag oder Stunde) byte, für analogRead-Ergebnisse int und für große Summen long zu verwenden. Der richtige Typ bedeutet, dass doppelt so viele Daten in denselben Speicher passen.

Wie definiert man ein Array in Arduino?

Beim Definieren schreibst du zuerst den Datentyp, dann den Namen des Arrays und in eckigen Klammern die Elementanzahl. Die Werte kannst du sofort in geschweiften Klammern angeben oder die Größe weglassen und den Compiler zählen lassen. Das folgende Programm zeigt die häufigsten Schreibweisen und gibt die Ergebnisse im Seriellen Monitor aus:

C++ (Arduino IDE)
1int notlar[5] = {90, 75, 60, 85, 100};   // boyut ve değerler / size and values
2int pinler[] = {2, 3, 4, 5, 6, 7};       // boyutu derleyici sayar / compiler counts the size
3float olcumler[10] = {1.5, 2.0};         // kalan 8 eleman 0.0 / remaining 8 are 0.0
4int bos[5];                              // global dizi: hepsi 0 / global array: all zeros
5char isim[] = "Arduino";                 // 7 harf + '\0' = 8 bayt / 7 letters + '\0' = 8 bytes
6
7void setup() {
8  Serial.begin(9600);
9  Serial.println(notlar[0]);             // ilk eleman: 90 / first element: 90
10  Serial.println(notlar[4]);             // son eleman: 100 / last element: 100
11  notlar[2] = 65;                        // üçüncü elemanı değiştir / change the third element
12  Serial.println(notlar[2]);             // 65
13  Serial.println(olcumler[5]);           // 0.00
14  Serial.println(bos[3]);                // 0
15  Serial.println(sizeof(isim));          // 8
16  Serial.println(sizeof(pinler) / sizeof(pinler[0]));  // eleman sayısı: 6 / element count: 6
17}
18
19void loop() {
20}
DefinitionBedeutung
int a[5];Array mit 5 Elementen; global alle 0, innerhalb einer Funktion zufällige Startwerte
int a[5] = {1, 2, 3, 4, 5};Größe und alle Werte werden zusammen angegeben
int a[] = {2, 3, 4};Der Compiler zählt die Größe (hier 3)
float a[10] = {1.5, 2.0};Elemente ohne Wert werden 0
int a[5] = {0};Kurzer Weg, alle Elemente auf null zu setzen
char s[] = "Arduino";Textarray; am Ende steht das unsichtbare Zeichen '\0' (insgesamt 8 Byte)
const byte a[] = {2, 3, 4};Konstantes Array, das im Programm nicht verändert werden kann
Der Index beginnt bei 0. Im Array int a[5] mit 5 Elementen gibt es kein a[5]; das letzte Element ist a[4]. Der Compiler erkennt diesen Fehler meistens nicht: Schreibst du in a[5], überschreibst du eine andere Variable, die direkt hinter dem Array im Speicher liegt. Das Ergebnis ist keine Fehlermeldung, sondern sinnlose Werte, ein Arduino, der sich von selbst neu startet, oder ein rätselhafter Fehler, den du stundenlang suchst.

Ein Array mit der for-Schleife durchlaufen

Die wahre Stärke von Arrays zeigt sich in Kombination mit der for-Schleife. Die Schleifenvariable i läuft von 0 bis zur Elementanzahl minus eins, und in jeder Runde greifst du mit array[i] auf das nächste Element zu. Statt die Elementanzahl von Hand zu schreiben, berechnest du sie am sichersten mit der Formel sizeof(array) / sizeof(array[0]): sizeof(array) liefert die Gesamtzahl der Bytes, sizeof(array[0]) die Größe eines Elements. Auf dem Uno ist ein int-Array mit 7 Elementen zum Beispiel 14 Byte groß, und 14 / 2 = 7. Fügst du Elemente hinzu, aktualisiert sich diese Zahl automatisch. Der folgende Code bestimmt Mittelwert, Minimum und Maximum der Temperaturen einer Woche. Die Summe der Messwerte ist 161, der Mittelwert 23,0 Grad; der kleinste Wert ist 19, der größte 27. Achte auf die Schleifenbedingung i < ADET: Mit kleiner-gleich läuft die Schleife eine Runde zu viel und liest Speicher außerhalb des Arrays.

C++ (Arduino IDE)
1int sicakliklar[] = {22, 24, 19, 27, 25, 21, 23};   // bir haftalık ölçüm / one week of readings
2const int ADET = sizeof(sicakliklar) / sizeof(sicakliklar[0]);   // 7
3
4void setup() {
5  Serial.begin(9600);
6  long toplam = 0;                       // taşmasın diye long / long to avoid overflow
7  int enKucuk = sicakliklar[0];
8  int enBuyuk = sicakliklar[0];
9
10  for (int i = 0; i < ADET; i++) {       // 0'dan 6'ya / from 0 to 6
11    toplam += sicakliklar[i];
12    if (sicakliklar[i] < enKucuk) enKucuk = sicakliklar[i];
13    if (sicakliklar[i] > enBuyuk) enBuyuk = sicakliklar[i];
14  }
15
16  Serial.print("Ortalama / Average: ");
17  Serial.println((float)toplam / ADET);  // 23.00
18  Serial.print("En dusuk / Min: ");
19  Serial.println(enKucuk);               // 19
20  Serial.print("En yuksek / Max: ");
21  Serial.println(enBuyuk);               // 27
22}
23
24void loop() {
25}

Beispiel 1: LED-Pins mit einem Array verwalten

Der klassische Einsatz von Arrays in Arduino ist die Steuerung mehrerer LEDs. Ohne Array brauchst du für sechs LEDs sechs einzelne pinMode-Zeilen und für jeden Schritt eigene digitalWrite-Zeilen; mit Array genügt eine einzige Schleife. Verbinde das lange Bein (Anode) jeder LED mit einem digitalen Pin und das kurze Bein über einen 220-Ω-Widerstand mit GND. Wenn du den Widerstandswert selbst berechnen möchtest, nutze den LED-Widerstandsrechner.

LED (Array-Index)Arduino UnoESP32Raspberry Pi Pico
LED 1 (ledPinleri[0])D2GPIO 13GP14
LED 2 (ledPinleri[1])D3GPIO 14GP13
LED 3 (ledPinleri[2])D4GPIO 27GP12
LED 4 (ledPinleri[3])D5GPIO 26GP11
LED 5 (ledPinleri[4])D6GPIO 25GP10
LED 6 (ledPinleri[5])D7GPIO 33GP9
Kathode (kurzes Bein)über 220 Ω an GNDüber 220 Ω an GNDüber 220 Ω an GND
  1. Stecke die LEDs der Reihe nach aufs Breadboard und verbinde die kurzen Beine (Kathode) über 220-Ω-Widerstände mit der GND-Schiene.
  2. Verbinde die langen Beine in der Reihenfolge der Tabelle mit den Pins 2–7 des Arduino.
  3. Schreibe die Pin-Nummern in der physischen Reihenfolge der LEDs ins Array ledPinleri; die Reihenfolge im Array bestimmt die Laufrichtung des Lichts.
  4. Setze in setup() mit einer einzigen for-Schleife alle Pins auf OUTPUT.
  5. Erzeuge in loop() mit zwei Schleifen, erst vorwärts, dann rückwärts, den Knight-Rider-Effekt und lade den Code hoch.
C++ (Arduino IDE)
1const byte ledPinleri[] = {2, 3, 4, 5, 6, 7};   // LED'lerin fiziksel sırası / physical order of LEDs
2const byte LED_SAYISI = sizeof(ledPinleri) / sizeof(ledPinleri[0]);   // 6
3const int BEKLEME = 100;                         // adım süresi ms / step time in ms
4
5void setup() {
6  for (byte i = 0; i < LED_SAYISI; i++) {
7    pinMode(ledPinleri[i], OUTPUT);              // tüm pinler çıkış / all pins as output
8  }
9}
10
11void loop() {
12  // ileri: 0'dan 5'e / forward: 0 to 5
13  for (byte i = 0; i < LED_SAYISI; i++) {
14    digitalWrite(ledPinleri[i], HIGH);
15    delay(BEKLEME);
16    digitalWrite(ledPinleri[i], LOW);
17  }
18  // geri: 4'ten 1'e, uçlar tekrar yanmaz / backward: 4 to 1, ends are not repeated
19  for (int i = LED_SAYISI - 2; i > 0; i--) {
20    digitalWrite(ledPinleri[i], HIGH);
21    delay(BEKLEME);
22    digitalWrite(ledPinleri[i], LOW);
23  }
24}

Die Vorwärtsschleife lässt jede LED von 0 bis 5 je 100 ms leuchten und löscht sie wieder. Die Rückwärtsschleife startet bei 4 und endet bei 1; da sie die äußeren LEDs nicht ein zweites Mal einschaltet, läuft das Licht an den Enden flüssig und ohne Stocken zurück. Als Zähler in der Rückwärtsschleife haben wir int verwendet, denn byte ist vorzeichenlos und kann nicht unter 0 fallen; verwendest du byte in einer Schleife, die auf einen Zähler kleiner als 0 wartet, springt er nach 0 auf 255 und die Schleife endet nie. Um die Reihenfolge des Effekts zu ändern, musst du nur die Zahlen im Array umstellen und am restlichen Code nichts anfassen. Andere Effekte nach demselben Prinzip findest du im Beitrag Knight Rider und Lauflicht.

Beispiel 2: Sensor-Mittelwert mit einem Array (gleitender Mittelwert)

Werte von analogen Sensoren wie Potentiometer, LDR oder Bodenfeuchtesensor schwanken ständig um einige Einheiten. Das Rauschen reduzierst du am einfachsten, indem du den Mittelwert der letzten N Messungen bildest. Du speicherst die letzten 10 Messwerte in einem Array und ziehst bei jeder neuen Messung den ältesten Wert von der Summe ab und addierst den neuen. Weil wir den Index am Ende des Arrays wieder auf 0 zurücksetzen, nennt man diese Struktur Ringpuffer (Ring Buffer). Die Summe per Subtrahieren und Addieren zu aktualisieren, statt sie jedes Mal neu zu berechnen, hält die Rechnung schnell, auch wenn das Fenster auf 100 Elemente wächst. Bei den ersten 10 Messungen ist das Array noch nicht voll, der Mittelwert steigt daher von null an und pendelt sich nach etwa einer halben Sekunde auf den echten Wert ein. Verbinde den Signalpin des Sensors mit A0 (zum Beispiel den Mittelpin des Potentiometers) und verfolge das Ergebnis als zwei Linien im Seriellen Plotter:

C++ (Arduino IDE)
1const byte PENCERE = 10;            // ortalama alınacak okuma sayısı / number of readings to average
2int okumalar[PENCERE];              // global dizi sıfırla başlar / global array starts at zero
3byte indeks = 0;                    // sıradaki hücre / next slot
4long toplam = 0;                    // taşmasın diye long / long to avoid overflow
5
6void setup() {
7  Serial.begin(9600);
8}
9
10void loop() {
11  int yeni = analogRead(A0);
12  toplam -= okumalar[indeks];       // en eski okumayı çıkar / remove the oldest reading
13  okumalar[indeks] = yeni;          // yerine yenisini yaz / store the new one
14  toplam += yeni;                   // toplama ekle / add to the total
15  indeks++;
16  if (indeks >= PENCERE) {          // sona gelince başa dön / wrap around at the end
17    indeks = 0;
18  }
19  int ortalama = toplam / PENCERE;
20  Serial.print(yeni);               // ham değer / raw value
21  Serial.print(" ");
22  Serial.println(ortalama);         // yumuşatılmış değer / smoothed value
23  delay(50);
24}
Auf dem Uno kann ein int höchstens 32 767 speichern. Die Summe von 64 analogen Messungen mit Werten bis 1023 beträgt 65 472, und eine int-Variable läuft über und wird negativ. Verwende für Summen und Mittelwerte immer long. Je größer das Fenster, desto glatter die Ausgabe, aber desto später reagiert sie auf Änderungen; 10 Messungen im Abstand von 50 ms, also ein halbsekündiges Fenster, sind für die meisten Sensoren ein guter Start. Fortgeschrittene Methoden findest du im Beitrag Sensordaten filtern.

Beispiel 3: Melodie-Noten in einem Array speichern

Eine Melodie besteht eigentlich aus zwei Listen: welche Note gespielt wird (Frequenz) und wie lange sie dauert. Diese beiden Informationen speicherst du in zwei gleich langen parallelen Arrays: melodi[i] und sureler[i] gehören immer zur selben Note. Verbinde das Pluszeichen eines passiven Buzzers mit Pin 8 und das Minuszeichen mit GND. Der folgende Code spielt die ersten beiden Zeilen von „Twinkle Twinkle Little Star“ und lässt zwischen den Noten eine Pause von einem Drittel der Notenlänge, damit die Töne getrennt klingen. Für ein neues Lied füllst du nur die beiden Arrays; die Abspielschleife bleibt unverändert. Haben die beiden Arrays unterschiedlich viele Elemente, läuft die Schleife über das kürzere Array hinaus, deshalb verhindert eine gleiche Anzahl an Elementen in jeder Zeile den Fehler. Wenn lange Melodien den RAM des Uno füllen, kannst du die Arrays mit PROGMEM in den Flash-Speicher verlagern. Wenn du den Unterschied zwischen aktivem und passivem Buzzer nicht kennst, lies Was ist ein Buzzer.

C++ (Arduino IDE)
1#define NOTA_DO  262   // Hz
2#define NOTA_RE  294
3#define NOTA_MI  330
4#define NOTA_FA  349
5#define NOTA_SOL 392
6#define NOTA_LA  440
7
8const byte BUZZER_PIN = 8;   // pasif buzzer / passive buzzer
9
10// notalar ve süreler aynı sırada / notes and durations in the same order
11const int melodi[] = {NOTA_DO, NOTA_DO, NOTA_SOL, NOTA_SOL, NOTA_LA, NOTA_LA, NOTA_SOL,
12                      NOTA_FA, NOTA_FA, NOTA_MI, NOTA_MI, NOTA_RE, NOTA_RE, NOTA_DO};
13const int sureler[] = {400, 400, 400, 400, 400, 400, 800,
14                       400, 400, 400, 400, 400, 400, 800};
15const int NOTA_SAYISI = sizeof(melodi) / sizeof(melodi[0]);   // 14
16
17void setup() {
18  for (int i = 0; i < NOTA_SAYISI; i++) {
19    tone(BUZZER_PIN, melodi[i], sureler[i]);   // notayı çal / play the note
20    delay(sureler[i] + sureler[i] / 3);         // nota + kısa boşluk / note + short gap
21  }
22  noTone(BUZZER_PIN);
23}
24
25void loop() {
26}

Mehrdimensionale Arrays: Daten wie in einer Tabelle speichern

Ein zweidimensionales Array ist eine Tabelle aus Zeilen und Spalten. int tablo[4][3] ist ein Array mit 4 Zeilen und 3 Spalten, also 12 Elementen; du greifst mit tablo[zeile][spalte] zu, und beide Indizes beginnen bei 0. Im Speicher liegen die Zeilen hintereinander, diese Tabelle belegt auf dem Uno also 4 × 3 × 2 = 24 Byte. Typische Einsatzgebiete zweidimensionaler Arrays sind Muster für 8x8-LED-Matrizen, Tastenbelegungen von Keypads und Zustandstabellen. Im folgenden Beispiel steht jeder Zustand der Ampel in einer Zeile: Die ersten drei Spalten bestimmen, ob die rote, gelbe und grüne LED leuchtet, die vierte Spalte hält die Dauer des Zustands in Millisekunden. Die LEDs kannst du an die ersten drei Pins der Pin-Tabelle anschließen (D2 rot, D3 gelb, D4 grün). Die Zeilenzahl haben wir mit sizeof(durumlar) / sizeof(durumlar[0]) berechnet; sizeof(durumlar[0]) liefert hier die Größe einer ganzen Zeile. Für einen neuen Ampelzustand schreibst du einfach eine Zeile in die Tabelle, der Code in loop() bleibt gleich. Diese Trennung von Programmlogik und Daten hilft dir auch später beim Bau eines Zustandsautomaten.

C++ (Arduino IDE)
1const byte trafikPinleri[3] = {2, 3, 4};   // kırmızı, sarı, yeşil / red, yellow, green
2
3// her satır bir durum: {kırmızı, sarı, yeşil, süre ms} / each row: {red, yellow, green, time ms}
4const unsigned int durumlar[4][4] = {
5  {1, 0, 0, 5000},   // kırmızı / red
6  {1, 1, 0, 1500},   // kırmızı + sarı / red + yellow
7  {0, 0, 1, 5000},   // yeşil / green
8  {0, 1, 0, 1500}    // sarı / yellow
9};
10const byte DURUM_SAYISI = sizeof(durumlar) / sizeof(durumlar[0]);   // 4 satır / 4 rows
11
12void setup() {
13  for (byte i = 0; i < 3; i++) {
14    pinMode(trafikPinleri[i], OUTPUT);
15  }
16}
17
18void loop() {
19  for (byte d = 0; d < DURUM_SAYISI; d++) {          // satırları gez / walk the rows
20    for (byte led = 0; led < 3; led++) {              // sütunları gez / walk the columns
21      digitalWrite(trafikPinleri[led], durumlar[d][led] ? HIGH : LOW);
22    }
23    delay(durumlar[d][3]);                            // durumun süresi / duration of the state
24  }
25}

Arrays beim ESP32 und Raspberry Pi Pico

Beim ESP32 schreibst du Arrays mit derselben C++-Syntax wie beim Arduino Uno, und die obigen Beispiele lassen sich unverändert kompilieren; du musst nur die Pin-Nummern anpassen. Im LED-Beispiel setzt du die Array-Zeile einfach auf {13, 14, 27, 26, 25, 33}; die Pins 6–11 sind für den internen Flash-Speicher reserviert, trage sie daher nicht ins Array ein. Beim ESP32 ist ein int 4 Byte groß, und deinen Programmen stehen über 300 KB RAM zur Verfügung; ein Messwert-Array mit 10 000 Elementen, das auf den Uno nicht passt, hat hier problemlos Platz. Da die analogen Messwerte des ESP32 im Bereich 0–4095 liegen, sind die Zahlen im Beispiel zum gleitenden Mittelwert größer, die Logik bleibt aber gleich. Nutzt du den Raspberry Pi Pico mit MicroPython, verwendest du statt Arrays Listen: Die Größe ist nicht fest, mit append() fügst du Elemente hinzu und mit len() fragst du die Länge ab. In Listen sind auch negative Indizes gültig; ledler[-1] liefert das letzte Element. Pin-Objekte direkt in die Liste zu legen vereinfacht den Code stark:

MicroPython
1from machine import Pin
2import time
3
4led_pinleri = [14, 13, 12, 11, 10, 9]            # GP14 -> GP9 sırası / order
5ledler = [Pin(p, Pin.OUT) for p in led_pinleri]  # Pin nesnelerinden liste / list of Pin objects
6print("LED sayisi / LED count:", len(ledler))
7
8while True:
9    for led in ledler:                           # ileri / forward
10        led.on()
11        time.sleep_ms(100)
12        led.off()
13    for i in range(len(ledler) - 2, 0, -1):      # geri, uçlar hariç / backward, ends skipped
14        ledler[i].on()
15        time.sleep_ms(100)
16        ledler[i].off()

Überlauffehler und häufige Array-Fehler

FehlerSymptomLösung
Kleiner-gleich in der Schleifenbedingung verwendenIn der letzten Runde wird außerhalb des Arrays gelesen oder geschrieben; sinnlose Werte, ResetsBedingung auf i < ADET setzen
Den Index bei 1 beginnen lassenDas erste Element wird übersprungen, in der letzten Runde kommt es zum ÜberlaufIndizes laufen von 0 bis N-1
sizeof(array) für die Elementanzahl haltenBei int-Arrays läuft die Schleife auf dem Uno doppelt, auf dem ESP32 viermal zu oftsizeof(array) / sizeof(array[0]) verwenden
sizeof innerhalb einer Funktion verwendenDas Array wird als Adresse übergeben; sizeof liefert 2 oder 4Die Elementanzahl als eigenen Parameter übergeben
Die Summe in einer int-Variable haltenAuf dem Uno negativer Mittelwert, sobald 32 767 überschritten werdenlong für die Summe verwenden
Ein Array in einer Funktion nicht initialisierenLokale Arrays haben zufällige StartwerteMit int a[10] = {0}; auf null setzen
Ein Array mit = einem anderen zuweisenKompilierfehler: invalid array assignmentMit einer for-Schleife oder memcpy kopieren
Auf dem Uno ein zu großes Array definierenWarnung vor wenig Speicher, Einfrieren und Resetsbyte verwenden, konstante Tabellen in PROGMEM auslagern
Unveränderliche Tabellen (Melodie-Noten, Zeichenmuster, Kalibrierwerte) werden auf dem Uno auch mit const beim Start in den RAM kopiert. Lagere große konstante Arrays mit dem Schlüsselwort PROGMEM in den Flash-Speicher aus und lies sie mit Funktionen wie pgm_read_word(); so nutzt du die 32 KB Flash und schonst die 2 KB RAM. Beim ESP32 und Pico bleiben const-Arrays ohnehin im Flash. Wenn du vermutest, dass der Speicher voll ist, lies Arduino: Speicher reicht nicht.

Projektideen mit Arrays

  • LED-Effektpaket: Halte Muster in einem zweidimensionalen Array und spiele jede Zeile wie ein Animationsbild ab; steuere die Effekte aus Knight Rider und Lauflicht mit einer einzigen Schleife.
  • Simon-Gedächtnisspiel: Speichere die zufällig erzeugte Farbfolge in einem Array und vergleiche sie mit den Tasten, die der Spieler drückt; ähnliche Ideen findest du bei Arduino-Spieleprojekte.
  • Codeschloss: Halte den richtigen Code in einem char-Array, schreibe die über das Keypad eingegebenen Tasten in ein zweites Array und vergleiche sie Element für Element.
  • LED-Matrix-Animationen: Speichere 8x8-Muster in Byte-Arrays und zeige sie auf der MAX7219-LED-Matrix an.
  • Tagesdatenlogger: Halte die stündlichen Temperaturen in einem Array mit 24 Elementen und berechne Minimum, Maximum und Mittelwert des Tages; als Sensor kannst du den DHT11 verwenden.
  • Spieluhr: Speichere mehrere Lieder in getrennten Arrays und wechsle mit einem Taster zwischen den Liedern.

Arrays sind der Baustein, den du in der Arduino-Programmierung brauchst, sobald du mit mehr als ein paar Variablen arbeitest: Pin-Listen, Messverläufe, Melodien und Muster werden alle mit Arrays verwaltet. Um beim Arbeiten mit Text den Unterschied zwischen char-Arrays und der String-Klasse zu lernen, geht es mit Arduino String verwenden weiter. In der BlueGrays-App findest du Lauflicht-, Knight-Rider-, Ampel- und Buzzer-Projekte (etwa die türkische Nationalhymne) mit fertigem Code auf Array-Basis und Schaltplänen Schritt für Schritt.

Häufige Fragen

Wie finde ich bei Arduino die Anzahl der Elemente eines Arrays?

In Arduino gibt es für Arrays keine fertige length()-Funktion. Die Elementanzahl bestimmst du mit der Formel sizeof(array) / sizeof(array[0]): Der erste Teil liefert die Gesamtzahl der Bytes, der zweite die Größe eines Elements. Die Formel funktioniert nur dort richtig, wo das Array definiert ist; bei einem an eine Funktion übergebenen Array liefert sie die Größe des Zeigers.

Beginnt der Array-Index bei Arduino bei 0 oder bei 1?

In der C/C++-basierten Arduino-Sprache beginnt der Array-Index immer bei 0. Das erste Element eines Arrays mit 10 Elementen ist array[0], das letzte array[9]. Ein Zugriff auf array[10] erzeugt keinen Kompilierfehler, beschädigt aber Speicher außerhalb des Arrays.

Kann man die Größe eines Arrays bei Arduino nachträglich ändern?

Nein, die Größe eines normalen Arrays wird beim Kompilieren festgelegt und kann zur Laufzeit nicht vergrößert werden. Praktisch definierst du ein Array in der größten benötigten Größe und merkst dir in einer eigenen Zählvariable, wie viele Elemente belegt sind. Dynamische Speicherreservierung mit malloc oder new ist möglich, wird beim Uno mit 2 KB RAM aber wegen Speicherfragmentierung nicht empfohlen.

Wie definiert man bei Arduino ein Array aus Texten (Strings)?

Um mehrere Texte zu speichern, verwendest du ein Zeiger-Array wie const char* renkler[] = {"Rot", "Gelb", "Gruen"}; und erreichst mit renkler[1] den Text "Gelb". Ein einzelner Text ist ein Zeichen-Array wie char isim[] = "Arduino"; und trägt am Ende ein unsichtbares '\0'-Zeichen. Arrays aus String-Objekten sind ebenfalls möglich, verbrauchen auf dem Uno aber schneller RAM.

Wie viele Elemente passen beim Arduino Uno höchstens in ein Array?

Die Grenze setzt der RAM: Der Uno hat insgesamt 2048 Byte RAM, ein Teil davon wird von Serial und anderen Variablen genutzt. In der Praxis liegt die Grenze bei etwa 1500 Byte, also 1500 byte-Elementen oder 750 int-Elementen. Lagerst du konstante Tabellen mit PROGMEM in den Flash-Speicher aus, kannst du deutlich mehr Daten speichern; ESP32 und Pico haben Hunderte KB RAM.

Wie kopiert man bei Arduino ein Array in ein anderes?

In C++ lässt sich ein Array nicht mit ziel = quelle; kopieren, der Compiler meldet einen Fehler. Du kannst die Elemente mit einer for-Schleife einzeln kopieren oder den Befehl memcpy(ziel, quelle, sizeof(quelle)); verwenden. Achte darauf, dass beide Arrays denselben Typ und dieselbe Größe haben; ist das Ziel kleiner, führt auch memcpy zu einem Überlauf.

Alle Projekte ansehen
Ampel
AR-3Anfänger

Ampel

Eine winzige Nachbildung der Ampel, die du jeden Tag auf der Straße siehst. Rot leuchtet zwei Sekunden, Gelb blitzt kurz auf, Grün leuchtet zwei Sekunden, dann geht es über Gelb wieder zurück zu Rot…

4.8(137)
440
LED-Lauflicht
AR-5Mittel

LED-Lauflicht

Lichter, die nacheinander aufleuchten, als würden sie laufen. Der Arduino schaltet sechs LEDs einzeln ein; jede leuchtet kurz auf und geht wieder aus, sodass das Licht von vorn nach hinten wandert…

4.6(87)
218
Knight-Rider-Lauflicht
AR-6Mittel

Knight-Rider-Lauflicht

Das klassische Lauflicht, das hin und her wandert: Ein Lichtpunkt gleitet über sechs LEDs von einem Ende zum anderen und kommt wieder zurück.

4.8(107)
214
LED-Lauflicht mit einstellbarer Geschwindigkeit
AR-7Mittel

LED-Lauflicht mit einstellbarer Geschwindigkeit

Sechs LEDs leuchten nacheinander auf, sodass das Licht von einem Ende zum anderen zu laufen scheint.

4.6(72)
148
Knight-Rider-Lauflicht mit einstellbarer Geschwindigkeit
AR-8Mittel

Knight-Rider-Lauflicht mit einstellbarer Geschwindigkeit

Ein Lichtpunkt läuft über sechs LEDs von einem Ende zum anderen, kehrt um und läuft wieder zurück.

4.5(60)
124
Türkische Nationalhymne mit Summer
AR-15Mittel

Türkische Nationalhymne mit Summer

Drückst du den Knopf, spielt ein kleiner Summer die türkische Nationalhymne, Note für Note.

4.8(114)
235
ESP32 Lauflicht LED
ES-6Anfänger

ESP32 Lauflicht LED

6 LEDs, die sich nacheinander von links nach rechts und von rechts nach links bewegen (Knight Rider Stil). Grundlegendes Beispiel für die Verwendung von for-Schleifen und Arrays. Lehrt die Logik des Richtungswechsels.

4.5(19)
33
Raspberry Pi Pico Lauflicht (6 LEDs)
PI-7Anfänger

Raspberry Pi Pico Lauflicht (6 LEDs)

Die klassische Lauflicht-Animation mit dem Pico, als Version mit 6 LEDs! Sechs LEDs leuchten nacheinander von links nach rechts auf, als würde das Licht die Reihe entlanglaufen. Du lernst Python-Listen (LED_PINS = [14, 13, 12, 11, 10, 9]), List Comprehensions, die Pinsteuerung mit einer for-Schleife und enumerate(). Sechs LEDs hängen an GP9-GP14, jede mit einem 220Ω-Vorwiderstand.

5.0(1)
9