Grundlagen · 10 Min. Lesezeit

Arduino String verwenden: char-Array, substring und toInt

Arduino String richtig nutzen: verketten, indexOf, substring, toInt, Befehle vom seriellen Port parsen, char-Array, F()-Makro und Speicherfragmentierung.

Der Arduino String ist eine fertige Klasse, mit der du Text in einer einzigen Variablen speichern, verketten und zerlegen kannst. Wenn du einen Befehl wie "LED,1" vom seriellen Port aufteilen, einen Sensorwert als "Temperatur: 24 C" ausgeben oder eine Nachricht per Bluetooth erkennen willst, greifst du zuerst dazu. Es gibt zwei Wege, mit Text zu arbeiten: das bequeme String-Objekt und das low-level char-Array aus der Sprache C. Beide erledigen dieselbe Aufgabe, gehen aber völlig unterschiedlich mit dem Speicher um.

In diesem Beitrag siehst du zuerst die wichtigsten String-Operationen wie Verketten, indexOf, substring und toInt mit echten Ausgaben. Danach schreiben wir einen Parser, der Befehle vom seriellen Port annimmt, eine LED ein- und ausschaltet und die Helligkeit per PWM einstellt. Dann klären wir, warum String im 2-KB-RAM des Arduino Uno mit der Zeit Probleme machen kann, was Speicherfragmentierung ist und wie das F()-Makro hilft. Zum Schluss erfährst du, wie derselbe Parser mit einem char-Array, auf dem ESP32 und auf dem Raspberry Pi Pico mit MicroPython aussieht.

Arduino-Uno-Board
Arduino Uno: Der ATmega328P hat nur 2 KB RAM, und genau dieses Limit entscheidet beim Arbeiten mit Text.

Was ist ein String in Arduino und wie unterscheidet er sich vom char-Array?

String (mit großem S) ist eine Klasse, die im Arduino-Core definiert ist. Sie speichert den Text im Heap und vergrößert diesen Bereich selbst, wenn der Text länger wird. Dadurch kannst du mit + verketten, mit == vergleichen und mit einem einzigen Befehl in eine Zahl umwandeln. Ein char-Array dagegen ist ein Byte-Bereich fester Größe, den du von Anfang an festlegst. Das Textende wird immer durch ein unsichtbares '\0'-Zeichen (Null-Terminator) markiert; für das 5-Buchstaben-Wort "Hello" brauchst du deshalb mindestens 6 Byte: char name[6] = "Hello";. Beim char-Array nutzt du zum Verketten und Vergleichen C-Funktionen wie strcat und strcmp; der Operator == vergleicht dort nicht den Inhalt, sondern die Speicheradressen. Genau hier stolpern Einsteiger am häufigsten.

EigenschaftStringchar-Array
BedienkomfortSehr einfach: +, ==, substring()Aufwendiger: strcat(), strcmp(), strtok()
SpeicherortHeap, dynamischFest; globaler Bereich oder Stack
GrößeWächst automatischWird vorab festgelegt
ÜberlaufrisikoKeins, aber wenn der Speicher voll ist, scheitert die Operation stillschweigendJa; du musst die Grenzen selbst prüfen
FragmentierungsrisikoJa (besonders beim Uno)Nein
Geeignet fürESP32, Pico, kurze und seltene TexteDauerbetrieb auf Uno und Nano

Speicher je Plattform und Testaufbau

EigenschaftArduino UnoESP32Raspberry Pi Pico
RAM2 KB SRAM520 KB SRAM264 KB SRAM
Programmspeicher32 KB Flash4 MB externer Flash (bei den meisten Boards)2 MB externer Flash
Test-LED-PinD9 (PWM) + 220 ΩGPIO 4 + 220 ΩGP15 + 220 Ω
Baudrate (in den Beispielen)9600 Baud115200 BaudUSB (Thonny-Shell)
F()-MakroSpart RAMWirkungslos, nur aus Kompatibilitätsgründen daGibt es nicht (MicroPython)
TexttypString und char[]String und char[]str (Python)
Steht die Zeilenende-Einstellung unten rechts im Serial Monitor auf No line ending, wird beim Drücken von Enter kein '\n' gesendet; dein Parser, der auf das Zeilenende wartet, hängt dann bis zum Timeout oder löst gar nicht aus. Stelle sie für die Beispiele in diesem Beitrag auf Newline oder Both NL & CR. Bei der zweiten Option bleibt ein '\r' am Textende hängen; deshalb nutzen wir im Code trim() oder überspringen das '\r'-Zeichen.

Grundoperationen mit String: verketten, indexOf, substring, toInt

Um Text an einen String anzuhängen, nutzt du += oder concat(). indexOf() liefert die Position eines Zeichens oder Wortes; gezählt wird ab 0, und wird nichts gefunden, kommt -1 zurück. substring(von, bis) kopiert einen Textteil: Die Startposition ist enthalten, die Endposition nicht, substring(8, 12) liefert also die Zeichen an Position 8, 9, 10 und 11. toInt() wandelt die Ziffern am Textanfang in eine Zahl vom Typ long um. Wenn du den folgenden Code hochlädst und den Serial Monitor mit 9600 Baud öffnest, kannst du jede Ausgabezeile mit dem Wert im Kommentar vergleichen.

C++ (Arduino IDE)
1void setup() {
2  Serial.begin(9600);
3
4  String ad = "Blue";
5  ad += "Grays";                                  // birleştirme / concatenation
6  String mesaj = "Merhaba " + ad;                 // "Merhaba BlueGrays"
7  int sicaklik = 24;
8  String satir = String("Sicaklik: ") + sicaklik + " C";  // sayı eklemek / appending a number
9
10  Serial.println(mesaj);                          // Merhaba BlueGrays
11  Serial.println(satir);                          // Sicaklik: 24 C
12  Serial.println(mesaj.length());                 // 17
13  Serial.println(mesaj.indexOf(' '));             // 7
14  Serial.println(mesaj.indexOf("Grays"));         // 12
15  Serial.println(mesaj.substring(8));             // BlueGrays
16  Serial.println(mesaj.substring(8, 12));         // Blue
17  mesaj.toUpperCase();                            // yerinde değiştirir / modifies in place
18  Serial.println(mesaj);                          // MERHABA BLUEGRAYS
19
20  String sayiMetni = "1250";
21  long n = sayiMetni.toInt() + 1;                 // 1251
22  Serial.println(n);
23  float f = String("3.75").toFloat();             // 3.75
24  Serial.println(f, 2);
25  Serial.println(String(255, HEX));               // ff
26}
27
28void loop() {
29}
FunktionWas sie machtBeispiel (s = "LED,128")
s.length()Liefert die Zeichenanzahl7
s.indexOf(',')Position des ersten Treffers, sonst -13
s.substring(0, 3)Von 0 bis Position 3 (3 ausgenommen)"LED"
s.substring(4)Ab Position 4 bis zum Ende"128"
s.substring(4).toInt()Wandelt in eine Zahl (long) um; bei ungültigem Text 0128
s.startsWith("LED")Beginnt der Text damit?true
s.equalsIgnoreCase("led,128")Vergleicht ohne Rücksicht auf Groß- und Kleinschreibungtrue
s.charAt(0)Liefert ein einzelnes Zeichen'L'
s.trim()Entfernt Leerzeichen, \r und \n am Anfang und Ende (direkt im String)Bleibt gleich (keine Leerzeichen)
s.c_str()Liefert einen Zeiger, den du wie ein char-Array lesen kannststrcmp(s.c_str(), "LED,128") == 0
String(3.14159, 2)Wandelt eine Dezimalzahl mit der angegebenen Nachkommastellenzahl in Text um"3.14"
s.replace(",", ";")Ersetzt einen Teil direkt im Strings ist jetzt "LED;128"
Vorsicht beim Anhängen von Zahlen: Die Zeile String s = "Wert: " + 5; lässt sich kompilieren, funktioniert aber nicht wie erwartet. Hier gibt es gar kein String-Objekt; der Compiler addiert 5 zur Adresse des Textes "Wert: ", und in s landet ein sinnloses Stück wie ": ". Ganz links in der Kette muss ein String stehen: Schreibe String s = String("Wert: ") + 5; oder setze zuerst String s = "Wert: "; und hänge dann s += 5; an.

Befehle vom seriellen Port parsen, Schritt für Schritt

  1. Schließe das lange Bein (Anode) der LED über einen 220-Ω-Widerstand an Pin D9 des Uno an, das kurze Bein an GND. D9 unterstützt PWM, also lässt sich auch die Helligkeit regeln.
  2. Lege das Befehlsformat fest: BEFEHL,WERT. LED,1 schaltet die LED ein, LED,0 aus, PWM,128 ergibt etwa halbe Helligkeit.
  3. Lies die Zeile vom seriellen Port bis zum Enter-Zeichen ('\n') und entferne mit trim() unsichtbare Zeichen.
  4. Finde mit indexOf(',') das Komma; trenne mit substring() den Teil davor als Befehl und den Teil danach als Wert ab.
  5. Wandle den Wert mit toInt() in eine Zahl um, setze den Befehl mit toUpperCase() in Großbuchstaben, vergleiche ihn und führe die passende Aktion aus.
  6. Gib nach jedem Befehl eine kurze Antwort im Serial Monitor aus, damit du sofort siehst, ob der Befehl verstanden wurde.
C++ (Arduino IDE)
1const int LED_PIN = 9;          // PWM destekli pin / PWM capable pin
2
3void setup() {
4  Serial.begin(9600);
5  Serial.setTimeout(50);        // satır bekleme süresi (ms) / line wait timeout (ms)
6  pinMode(LED_PIN, OUTPUT);
7  Serial.println(F("Komutlar / Commands: LED,1  LED,0  PWM,0-255"));
8}
9
10void loop() {
11  if (Serial.available() > 0) {
12    String satir = Serial.readStringUntil('\n');  // Enter'a kadar oku / read until Enter
13    satir.trim();                                // CR ve boşlukları sil / remove CR and spaces
14    if (satir.length() == 0) return;
15
16    String komut = satir;
17    String deger = "";
18    int virgul = satir.indexOf(',');
19    if (virgul >= 0) {
20      komut = satir.substring(0, virgul);        // virgülden önce / before the comma
21      deger = satir.substring(virgul + 1);       // virgülden sonra / after the comma
22    }
23    komut.toUpperCase();
24    long sayi = deger.toInt();                   // geçersizse 0 / 0 if invalid
25
26    if (komut == "LED") {
27      digitalWrite(LED_PIN, sayi ? HIGH : LOW);
28      Serial.print(F("LED -> "));
29      Serial.println(sayi ? "ACIK / ON" : "KAPALI / OFF");
30    } else if (komut == "PWM") {
31      sayi = constrain(sayi, 0, 255);            // 0-255 arasında tut / keep in 0-255
32      analogWrite(LED_PIN, (int)sayi);
33      Serial.print(F("PWM -> "));
34      Serial.println(sayi);
35    } else {
36      Serial.print(F("Bilinmeyen komut / Unknown command: "));
37      Serial.println(komut);
38    }
39  }
40}

Die Zeile Serial.setTimeout(50) ist wichtig: readStringUntil() wartet standardmäßig 1000 ms auf das nächste Zeichen; kommt kein Zeilenende, hängt das Programm eine Sekunde lang. Bei 9600 Baud trifft ein Zeichen etwa nach 1 ms ein, 50 ms reichen also locker. Enthält der Befehl kein Komma, liefert indexOf() -1; dann behandeln wir die ganze Zeile als Befehl, und der Wert bleibt leer. Wendest du toInt() auf einen leeren String an, ist das Ergebnis 0. Hier lauert eine Falle: toInt() liefert auch für ungültigen Text 0, "PWM,abc" und "PWM,0" sind für den Code also dasselbe. In einem echten Projekt solltest du mit isDigit() prüfen, ob das erste Zeichen des Werts eine Ziffer ist. constrain() verhindert, dass der PWM-Wert den Bereich 0–255 verlässt.

Speicherfragmentierung: Warum String den Uno zum Absturz bringen kann

Wenn ein String wächst und der vorhandene Platz nicht reicht, fordert er im Heap einen größeren neuen Bereich an, verschiebt den Text dorthin und gibt den alten Bereich frei. Freigegebene Bereiche lassen sich nicht immer wiederverwenden; mit der Zeit gleicht der Heap einem Käse mit lauter kleinen Löchern. Selbst wenn insgesamt 300 Byte frei sind, kann ein String von 50 Byte nicht angelegt werden, wenn der größte zusammenhängende Block nur 40 Byte hat. Das nennt man Speicherfragmentierung (Heap Fragmentation). Im 2-KB-RAM des Arduino Uno wächst der Heap nach oben, der Stack der Funktionsaufrufe nach unten; stoßen beide zusammen, werden Variablen beschädigt, im Serial Monitor erscheinen seltsame Zeichen oder das Board startet von selbst neu. Tückischer ist, dass eine String-Operation ohne Fehlermeldung scheitert, wenn kein Platz gefunden wird: Nach dem Verketten ist der Text dann halb oder ganz leer. Weil diese Probleme meist erst nach Stunden Laufzeit auftreten, fallen sie bei kurzen Tests am Schreibtisch nicht auf.

  • Mit reserve() Platz reservieren: Wenn du die Länge eines Strings abschätzen kannst, schreibe in setup() zeile.reserve(64);; solange der Text innerhalb dieser Grenze bleibt, fordert er keinen neuen Platz an.
  • Global oder static verwenden: Strings, die in loop() bei jedem Durchlauf neu erzeugt werden, wirbeln den Heap ständig durcheinander; ein einziger globaler String, der immer wieder benutzt wird, ist sicherer.
  • Per Referenz übergeben: Definiere den Funktionsparameter als void ausgeben(const String &text); einen String per Wert zu übergeben erzeugt bei jedem Aufruf eine neue Kopie.
  • Lange Ketten aufteilen: Ausdrücke wie a + b + c + d erzeugen temporäre Objekte; schrittweises Anhängen mit += braucht weniger temporären Speicher.
  • Direkt ausgeben: Wenn du Text nur auf dem Bildschirm ausgeben willst, nutze mehrere Serial.print()-Aufrufe hintereinander statt zu verketten; dann entsteht gar kein String.
  • Nicht in Interrupts verwenden: Erzeuge in Funktionen, die über attachInterrupt() aufgerufen werden, keine Strings; Speicherreservierung ist innerhalb eines Interrupts nicht sicher.

Mit dem F()-Makro auf dem Uno RAM sparen

Auf Boards mit AVR-Prozessor (Uno, Nano, Mega) wird jeder konstante Text im Code beim Programmstart aus dem Flash ins RAM kopiert. Schon zehn Menütexte mit je 40 Zeichen belegen 400 Byte, also ein Fünftel des Uno-RAMs. Das Makro F("...") lässt den Text im Flash, und Serial.print() oder lcd.print() liest ihn von dort. Die Regel ist einfach: Verpacke jeden konstanten Text, den du im Serial Monitor oder auf einem Display ausgibst, in F(). F() funktioniert nur mit der print-Familie und Stellen, die es unterstützen, etwa dem Anhängen an einen String; C-Funktionen wie strcmp() kannst du es nicht direkt übergeben. Der folgende Code zeigt außerdem den klassischen Weg, den freien RAM auf AVR-Boards zu messen; vergleiche den Wert vor und nach dem Einsatz von F().

C++ (Arduino IDE)
1// Yalnız AVR kartlar (Uno, Nano, Mega) / AVR boards only (Uno, Nano, Mega)
2extern int __heap_start, *__brkval;
3
4int bosRam() {
5  int v;
6  return (int)&v - (__brkval == 0 ? (int)&__heap_start : (int)__brkval);
7}
8
9void setup() {
10  Serial.begin(9600);
11  Serial.println("Bu metin RAM'e kopyalanir / This text is copied to RAM");
12  Serial.println(F("Bu metin flash'ta kalir / This text stays in flash"));
13
14  String s;
15  s.reserve(40);                 // tek seferde 40 bayt / 40 bytes at once
16  s += F("Sicaklik: ");          // F() String'e de eklenebilir / F() works with String too
17  s += 24;
18  Serial.println(s);
19
20  Serial.print(F("Bos RAM / Free RAM: "));
21  Serial.println(bosRam());
22}
23
24void loop() {
25}

Sicheres Befehlsparsen mit einem char-Array

In Projekten, bei denen das Board tagelang ohne Unterbrechung laufen soll, besonders auf Uno und Nano, ist es am robustesten, Befehle in einem char-Array fester Größe zu sammeln. Der folgende Code schreibt die ankommenden Zeichen einzeln in einen 32-Byte-Puffer, schließt die Zeile bei '\n' mit '\0' ab und zerlegt sie mit strtok() am Komma. Ist der Puffer voll, werden überzählige Zeichen stillschweigend verworfen; so kann nichts überlaufen. Da der Code nirgends delay() oder einen Timeout abwartet, laufen auch andere Aufgaben in loop() wie Sensoren lesen oder Motoren ansteuern ungestört weiter. Der einzige Unterschied: Der Vergleich unterscheidet zwischen Groß- und Kleinschreibung, du musst die Befehle also in Großbuchstaben schreiben.

C++ (Arduino IDE)
1const int LED_PIN = 9;
2const byte MAX_UZUNLUK = 32;          // en fazla 31 karakter + '\0' / max 31 chars + '\0'
3char tampon[MAX_UZUNLUK];
4byte konum = 0;
5
6void komutIsle(char *satir) {
7  char *komut = strtok(satir, ",");   // ilk parça / first token
8  char *deger = strtok(NULL, ",");    // ikinci parça / second token
9  if (komut == NULL) return;
10  int sayi = (deger != NULL) ? atoi(deger) : 0;
11
12  if (strcmp(komut, "LED") == 0) {
13    digitalWrite(LED_PIN, sayi ? HIGH : LOW);
14  } else if (strcmp(komut, "PWM") == 0) {
15    sayi = constrain(sayi, 0, 255);
16    analogWrite(LED_PIN, sayi);
17  } else {
18    Serial.print(F("Bilinmeyen / Unknown: "));
19    Serial.println(komut);
20    return;
21  }
22  char cevap[40];
23  snprintf(cevap, sizeof(cevap), "OK %s=%d", komut, sayi);   // taşma korumalı / overflow safe
24  Serial.println(cevap);
25}
26
27void setup() {
28  Serial.begin(9600);
29  pinMode(LED_PIN, OUTPUT);
30}
31
32void loop() {
33  while (Serial.available() > 0) {
34    char c = Serial.read();
35    if (c == '\r') continue;              // CR karakterini atla / skip CR
36    if (c == '\n') {                      // satır bitti / line complete
37      tampon[konum] = '\0';
38      if (konum > 0) komutIsle(tampon);
39      konum = 0;
40    } else if (konum < MAX_UZUNLUK - 1) {
41      tampon[konum++] = c;                // yer varsa ekle / append if there is room
42    }
43  }
44}
FunktionWas sie machtBeispiel
strlen(s)Liefert die Zeichenanzahl ohne '\0'strlen("LED") → 3
strncpy(ziel, quelle, n)Kopiert höchstens n Zeichenstrncpy(buf, "PWM", sizeof(buf) - 1)
strcat(ziel, quelle)Hängt an das Ende an (im Ziel muss Platz sein)strcat(buf, ",128")
strcmp(a, b)Liefert 0, wenn die Texte gleich sindstrcmp(komando, "LED") == 0
strchr(s, c)Liefert die Adresse des Zeichens, sonst NULLstrchr(s, ',')
strtok(s, ",")Zerlegt den Text am Trennzeichen (verändert das Original)Für das nächste Teilstück strtok(NULL, ",")
atoi / atol / atofWandelt Text in int, long oder double umatoi("128") → 128
snprintf(buf, größe, ...)Erzeugt formatierten Text, gegen Überlauf geschütztsnprintf(buf, sizeof(buf), "%d", 42)
dtostrf(zahl, breite, stellen, buf)Wandelt Float in Text um (%f funktioniert auf AVR nicht)dtostrf(3.14159, 4, 2, buf) → "3.14"

String auf dem ESP32: Warum es bequemer ist und worauf du achten musst

Der ESP32 hat 520 KB SRAM, etwa das 260-Fache des Uno. Deshalb ist String bei textlastigen Aufgaben wie Webserver, JSON oder MQTT-Nachrichten viel entspannter, und der String-Parser oben läuft auf dem ESP32 unverändert, wenn du LED_PIN auf 4 und die Baudrate auf 115200 setzt. Der String im ESP32-Core speichert kurze Texte direkt im Objekt, ohne den Heap zu belegen; das verringert die Fragmentierung bei kleinen Texten. Konstante Texte werden ohnehin aus dem Flash gelesen, F() ändert hier also nichts und sorgt nur dafür, dass der Code mit AVR kompatibel bleibt. Trotzdem kann es bei einem Webserver, der monatelang läuft, zu Fragmentierung kommen, wenn er bei jeder Anfrage große Strings erzeugt. Zur Überwachung liefert ESP.getFreeHeap() den gesamten freien Speicher und ESP.getMaxAllocHeap() den größten zusammenhängenden Block, der vergeben werden kann; wächst der Unterschied zwischen beiden mit der Zeit, hat die Fragmentierung begonnen.

C++ (Arduino IDE)
1String satir;                     // global, tekrar kullanılır / global, reused
2
3void setup() {
4  Serial.begin(115200);
5  satir.reserve(96);              // önceden yer ayır / pre-allocate
6  Serial.printf("Bos heap: %u bayt\n", (unsigned int)ESP.getFreeHeap());
7}
8
9void loop() {
10  static unsigned long son = 0;
11  if (millis() - son >= 2000) {
12    son = millis();
13    int ham = analogRead(34);     // GPIO 34: yalnız giriş, ADC1 / input only, ADC1
14    satir = "t=";
15    satir += millis() / 1000;
16    satir += " s, adc=";
17    satir += ham;
18    satir += ", heap=";
19    satir += (unsigned long)ESP.getFreeHeap();       // toplam boş / total free
20    satir += ", blok=";
21    satir += (unsigned long)ESP.getMaxAllocHeap();   // en büyük blok / largest block
22    Serial.println(satir);
23  }
24}

Textverarbeitung auf dem Raspberry Pi Pico mit MicroPython

In MicroPython ist Text vom Typ str und wie in Python unveränderlich; jede Operation erzeugt einen neuen Text, nicht mehr benutzte räumt der Garbage Collector weg. Da der Pico 264 KB RAM hat, belastet Befehlsparsen das Board überhaupt nicht. Das Gegenstück zu indexOf bei String ist find(), zu substring das Slicing (zeile[0:3]), zu toInt int() und zu trim strip(). Am praktischsten ist split(","): Es zerlegt den Text in einer einzigen Zeile in Teile. Bei ungültigem Text liefert int() nicht 0, sondern löst einen ValueError aus; das ist sicherer als die Unklarheit bei toInt() in Arduino, aber du musst den Fehler mit try/except abfangen. Schließe die LED mit einem 220-Ω-Widerstand an GP15 an, starte den Code mit Thonny und tippe die Befehle ins Shell-Fenster. Programmierst du den Pico mit der Arduino IDE, funktionieren String und char-Array genauso; der einzige Unterschied ist das reichlich vorhandene RAM.

MicroPython
1import sys
2from machine import Pin, PWM
3
4led = PWM(Pin(15))                          # GP15 + 220 ohm direnç / resistor
5led.freq(1000)
6
7print("Komutlar / Commands: LED,1  LED,0  PWM,0-255")
8
9while True:
10    satir = sys.stdin.readline().strip()    # Enter'a kadar bekler / waits for Enter
11    if not satir:
12        continue
13    parcalar = satir.split(",")             # "PWM,128" -> ["PWM", "128"]
14    komut = parcalar[0].upper()
15    try:
16        deger = int(parcalar[1]) if len(parcalar) > 1 else 0
17    except ValueError:                      # sayı değil / not a number
18        print("Gecersiz sayi / Invalid number:", parcalar[1])
19        continue
20    if komut == "LED":
21        led.duty_u16(65535 if deger else 0)
22        print("LED ->", "ACIK / ON" if deger else "KAPALI / OFF")
23    elif komut == "PWM":
24        deger = max(0, min(255, deger))     # 0-255 arasında tut / keep in 0-255
25        led.duty_u16(deger * 257)           # 0-255 -> 0-65535
26        print("PWM ->", deger)
27    else:
28        print("Bilinmeyen komut / Unknown command:", komut)

Projektideen mit String und serieller Kommunikation

  • Steuerung per Bluetooth: Verarbeite mit dem HC-05-Bluetooth-Modul Befehle wie "LED,1" oder "SERVO,90" vom Handy mit demselben Parser.
  • Bedienfeld mit Python: Sende Befehle von einem Python-Skript auf dem Computer und empfange Messwerte vom Arduino; Details im Beitrag Arduino und Python: serielle Kommunikation.
  • Nachrichten zwischen zwei Arduinos: Per UART-Kommunikation sendet ein Board Messwerte, das andere zerlegt die Zeile "T,24" und zeigt sie auf dem Display an.
  • Laufschrift auf dem LCD: Verschiebe den über den seriellen Port eingegebenen Text mit substring() und gib ihn auf einem I2C-LCD aus.
  • Einstellungen dauerhaft speichern: Speichere einen per Befehl wie "ESIK,500" empfangenen Schwellwert im EEPROM, damit die Einstellung auch nach einem Neustart erhalten bleibt.
  • Daten in Excel erfassen: Sende Sensorwerte als kommagetrennte Zeilen und übertrage sie nach Excel.

Häufige Fehler und ihre Lösungen

SymptomUrsacheLösung
Befehl wird gar nicht erkanntZeilenende auf No line ending gestellt oder am Textende bleibt '\r' hängenNewline wählen, trim() verwenden
Jeder Befehl dauert 1 SekundereadStringUntil() wartet auf den Standard-Timeout von 1000 msSerial.setTimeout(50) setzen oder Zeichen für Zeichen lesen
"PWM,abc" schaltet die LED austoInt() liefert bei ungültigem Text 0Erstes Zeichen mit isDigit() prüfen
== beim char-Array ist immer false== vergleicht die Adresse, nicht den Inhaltstrcmp(a, b) == 0 verwenden
Sinnlose Zeichen am TextendeIm char-Array fehlt '\0' oder das Array ist zu kleinArray mit Textlänge + 1 anlegen und mit '\0' abschließen
Nach Stunden Absturz oder ResetHeap-Fragmentierung oder volles RAM auf dem Unoreserve(), F() und char-Array verwenden
snprintf zeigt "?" statt Float%f-Unterstützung ist auf AVR deaktiviertMit dtostrf() umwandeln
length() ist bei Umlauten zu großZeichen wie ä, ö, ü belegen in UTF-8 2 ByteNach Bytes rechnen oder ASCII verwenden
Wenn du dich nicht entscheiden kannst, welchen Weg du wählen sollst, gilt eine einfache Regel: Für Dauerbetrieb auf Uno und Nano nimmst du char-Array und F(), für Testcode sowie auf ESP32 und Pico String. Beachte auch die Zeile "Global variables use ... bytes", die die Arduino IDE nach dem Kompilieren ausgibt; übersteigt dieser Anteil beim Uno 75 Prozent, warnt die IDE vor wenig Speicher. Details zu Speicherproblemen findest du im Beitrag Arduino: zu wenig Speicher.

Sobald du den Unterschied zwischen String und char-Array verstanden hast, kannst du jeden Befehl vom seriellen Port, jede Bluetooth-Nachricht und jede Sensorzeile sicher verarbeiten. Den Serial Monitor lernst du im Beitrag Arduino Serial Monitor besser kennen, die allgemeine Logik von Arrays im Beitrag Arduino Array. In der BlueGrays-App kannst du Projekte wie LED per Handy über Bluetooth schalten, serielle Kommunikation zwischen zwei Arduinos und Nachrichten auf dem LCD mit Schaltplan und Code Schritt für Schritt ausprobieren und das Gelernte sofort anwenden.

Häufige Fragen

Soll ich in Arduino String oder char-Array verwenden?

Für kurze Testprogramme, auf dem ESP32 und dem Pico sind String schnell und gut lesbar. Auf Boards mit 2 KB RAM wie Arduino Uno oder Nano ist bei einem Projekt, das tagelang laufen soll, ein char-Array fester Größe sicherer, weil es Speicherfragmentierung komplett verhindert. Du kannst beides kombinieren: Mit der Funktion c_str() kannst du einen String wie ein char-Array lesen.

Wie wandle ich in Arduino einen String in int um?

Beim String-Objekt nutzt du text.toInt(); das Ergebnis ist vom Typ long, und gelesen werden die Ziffern am Textanfang. Enthält der Text keine Zahl, kommt 0 zurück; um eine echte 0 von einer fehlerhaften Eingabe zu unterscheiden, prüfe das erste Zeichen mit isDigit(). Beim char-Array übernehmen atoi(), atol() oder strtol() mit Fehlerprüfung diese Aufgabe.

Wie wandle ich in Arduino eine Zahl in einen String um?

Am einfachsten schreibst du String(zahl); String(255, HEX) erzeugt hexadezimalen Text, String(3.14159, 2) Dezimaltext mit zwei Nachkommastellen. An einen vorhandenen String kannst du auch direkt mit s += zahl anhängen. Für ein char-Array nutzt du snprintf() oder itoa(); auf AVR-Boards brauchst du für Float-Zahlen dtostrf().

Wofür ist das F()-Makro in Arduino da?

F() verhindert, dass konstante Texte, die du Befehlen wie Serial.print() übergibst, ins RAM kopiert werden, und lässt sie aus dem Flash lesen. Da der Arduino Uno nur 2 KB RAM hat, sparst du bei langen Menü- und Warntexten Hunderte Byte. Auf ESP32 und Pico bleiben konstante Texte ohnehin im Flash, F() macht dort keinen Unterschied und ist nur aus Kompatibilitätsgründen vorhanden.

Wie liest Arduino Text vom seriellen Port?

Am kürzesten geht es mit Serial.readStringUntil('\n') bis zum Enter-Zeichen; danach solltest du mit trim() '\r' und Leerzeichen entfernen. Weil diese Funktion standardmäßig 1 Sekunde wartet, ist es sinnvoll, die Zeit mit Serial.setTimeout() zu verkürzen. Soll das Programm gar nicht warten, lies die Zeichen einzeln mit Serial.read(), sammle sie in einem char-Array und verarbeite sie, sobald '\n' kommt.

Wie vergleicht man in Arduino zwei Strings?

Bei String-Objekten vergleichen der Operator == oder equals() den Inhalt; willst du Groß- und Kleinschreibung ignorieren, nimm equalsIgnoreCase(). Bei char-Arrays vergleicht == nur die Speicheradressen und liefert ein falsches Ergebnis; schreibe stattdessen strcmp(a, b) == 0. Vergiss nicht, vor dem Vergleich das '\r' am Textende mit trim() zu entfernen.

Alle Projekte ansehen
HC-SR04 Abstandsmessung (serielle Anzeige)
AR-27Anfänger

HC-SR04 Abstandsmessung (serielle Anzeige)

Der Sensor HC-SR04 funktioniert wie eine Fledermaus, die im Dunkeln ihren Weg findet: Er sendet einen Ton, den du nicht hörst, lauscht auf das Echo und misst, wie weit der Gegenstand vor ihm entfernt…

4.6(50)
82
LED per Bluetooth mit dem Handy steuern
AR-34Anfänger
Premium

LED per Bluetooth mit dem Handy steuern

Eine kleine Probe dafür, das Licht in deinem Zimmer vom Handy aus ein- und auszuschalten.

4.8(69)
91
Einweg-Kommunikation zwischen 2 Arduinos
AR-57Mittel
Premium

Einweg-Kommunikation zwischen 2 Arduinos

Du bringst zwei Arduinos über ein einziges Kabel zum Reden: Drückst du den Knopf am einen, geht die LED am anderen an, drückst du noch einmal, geht sie aus.

4.4(37)
50
Bidirektionale Kommunikation zwischen 2 Arduinos
AR-58Mittel
Premium

Bidirektionale Kommunikation zwischen 2 Arduinos

Zwei Arduinos werden per Kabel verbunden und unterhalten sich: Drückst du den Knopf am einen, geht am anderen das Licht an, drückst du noch einmal, geht es aus.

4.5(20)
26
Text auf 2x16-LCD-Bildschirm anzeigen
AR-29Fortgeschritten
Premium

Text auf 2x16-LCD-Bildschirm anzeigen

Dein erster Schritt, um Text auf ein Display zu bringen. Das zweizeilige LCD-Display zeigt zuerst eine Wartemeldung, schreibt dann einen Gruß in die obere Zeile und tippt in der unteren Zeile ein…

4.6(37)
51
Verwendung des LCD-Bildschirms mit I2C
AR-32Anfänger
Premium

Verwendung des LCD-Bildschirms mit I2C

Gib deinem Arduino ein eigenes Display und lass es seine erste Nachricht schreiben.

4.8(53)
70
Python-Entwickler-Tastatur
AR-66Mittel
Premium

Python-Entwickler-Tastatur

Wenn du es leid bist, beim Programmieren immer wieder dieselben Muster zu tippen, ist diese kleine Tastatur genau das Richtige.

4.6(35)
45
Bluetooth-gesteuertes Auto mit L298N
AR-80Fortgeschritten
Premium

Bluetooth-gesteuertes Auto mit L298N

Mach dein Handy zur Fernbedienung und steuere dein eigenes Roboterauto. Der Arduino empfängt über ein Bluetooth-Modul die Befehle einer Fernsteuer-App auf dem Handy und treibt die Räder über einen…

5.0(39)
66