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.

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:
| Datentyp | Elementgröße (Uno) | Elementgröße (ESP32 / Pico, C++) | Array mit 100 Elementen (Uno) |
|---|---|---|---|
| byte / uint8_t | 1 Byte | 1 Byte | 100 Byte |
| char | 1 Byte | 1 Byte | 100 Byte |
| int | 2 Byte | 4 Byte | 200 Byte |
| unsigned int | 2 Byte | 4 Byte | 200 Byte |
| long | 4 Byte | 4 Byte | 400 Byte |
| float | 4 Byte | 4 Byte | 400 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:
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}| Definition | Bedeutung |
|---|---|
| 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 |
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.
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 Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| LED 1 (ledPinleri[0]) | D2 | GPIO 13 | GP14 |
| LED 2 (ledPinleri[1]) | D3 | GPIO 14 | GP13 |
| LED 3 (ledPinleri[2]) | D4 | GPIO 27 | GP12 |
| LED 4 (ledPinleri[3]) | D5 | GPIO 26 | GP11 |
| LED 5 (ledPinleri[4]) | D6 | GPIO 25 | GP10 |
| LED 6 (ledPinleri[5]) | D7 | GPIO 33 | GP9 |
| Kathode (kurzes Bein) | über 220 Ω an GND | über 220 Ω an GND | über 220 Ω an GND |
- Stecke die LEDs der Reihe nach aufs Breadboard und verbinde die kurzen Beine (Kathode) über 220-Ω-Widerstände mit der GND-Schiene.
- Verbinde die langen Beine in der Reihenfolge der Tabelle mit den Pins 2–7 des Arduino.
- Schreibe die Pin-Nummern in der physischen Reihenfolge der LEDs ins Array ledPinleri; die Reihenfolge im Array bestimmt die Laufrichtung des Lichts.
- Setze in setup() mit einer einzigen for-Schleife alle Pins auf OUTPUT.
- Erzeuge in loop() mit zwei Schleifen, erst vorwärts, dann rückwärts, den Knight-Rider-Effekt und lade den Code hoch.
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:
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}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.
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.
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:
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
| Fehler | Symptom | Lösung |
|---|---|---|
| Kleiner-gleich in der Schleifenbedingung verwenden | In der letzten Runde wird außerhalb des Arrays gelesen oder geschrieben; sinnlose Werte, Resets | Bedingung auf i < ADET setzen |
| Den Index bei 1 beginnen lassen | Das erste Element wird übersprungen, in der letzten Runde kommt es zum Überlauf | Indizes laufen von 0 bis N-1 |
| sizeof(array) für die Elementanzahl halten | Bei int-Arrays läuft die Schleife auf dem Uno doppelt, auf dem ESP32 viermal zu oft | sizeof(array) / sizeof(array[0]) verwenden |
| sizeof innerhalb einer Funktion verwenden | Das Array wird als Adresse übergeben; sizeof liefert 2 oder 4 | Die Elementanzahl als eigenen Parameter übergeben |
| Die Summe in einer int-Variable halten | Auf dem Uno negativer Mittelwert, sobald 32 767 überschritten werden | long für die Summe verwenden |
| Ein Array in einer Funktion nicht initialisieren | Lokale Arrays haben zufällige Startwerte | Mit int a[10] = {0}; auf null setzen |
| Ein Array mit = einem anderen zuweisen | Kompilierfehler: invalid array assignment | Mit einer for-Schleife oder memcpy kopieren |
| Auf dem Uno ein zu großes Array definieren | Warnung vor wenig Speicher, Einfrieren und Resets | byte verwenden, konstante Tabellen in PROGMEM auslagern |
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.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
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…

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…

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.

LED-Lauflicht mit einstellbarer Geschwindigkeit
Sechs LEDs leuchten nacheinander auf, sodass das Licht von einem Ende zum anderen zu laufen scheint.

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.

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

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.

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.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

