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.

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.
| Eigenschaft | String | char-Array |
|---|---|---|
| Bedienkomfort | Sehr einfach: +, ==, substring() | Aufwendiger: strcat(), strcmp(), strtok() |
| Speicherort | Heap, dynamisch | Fest; globaler Bereich oder Stack |
| Größe | Wächst automatisch | Wird vorab festgelegt |
| Überlaufrisiko | Keins, aber wenn der Speicher voll ist, scheitert die Operation stillschweigend | Ja; du musst die Grenzen selbst prüfen |
| Fragmentierungsrisiko | Ja (besonders beim Uno) | Nein |
| Geeignet für | ESP32, Pico, kurze und seltene Texte | Dauerbetrieb auf Uno und Nano |
Speicher je Plattform und Testaufbau
| Eigenschaft | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| RAM | 2 KB SRAM | 520 KB SRAM | 264 KB SRAM |
| Programmspeicher | 32 KB Flash | 4 MB externer Flash (bei den meisten Boards) | 2 MB externer Flash |
| Test-LED-Pin | D9 (PWM) + 220 Ω | GPIO 4 + 220 Ω | GP15 + 220 Ω |
| Baudrate (in den Beispielen) | 9600 Baud | 115200 Baud | USB (Thonny-Shell) |
| F()-Makro | Spart RAM | Wirkungslos, nur aus Kompatibilitätsgründen da | Gibt es nicht (MicroPython) |
| Texttyp | String und char[] | String und char[] | str (Python) |
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.
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}| Funktion | Was sie macht | Beispiel (s = "LED,128") |
|---|---|---|
| s.length() | Liefert die Zeichenanzahl | 7 |
| s.indexOf(',') | Position des ersten Treffers, sonst -1 | 3 |
| 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 0 | 128 |
| s.startsWith("LED") | Beginnt der Text damit? | true |
| s.equalsIgnoreCase("led,128") | Vergleicht ohne Rücksicht auf Groß- und Kleinschreibung | true |
| 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 kannst | strcmp(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 String | s ist jetzt "LED;128" |
Befehle vom seriellen Port parsen, Schritt für Schritt
- 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.
- Lege das Befehlsformat fest: BEFEHL,WERT. LED,1 schaltet die LED ein, LED,0 aus, PWM,128 ergibt etwa halbe Helligkeit.
- Lies die Zeile vom seriellen Port bis zum Enter-Zeichen ('\n') und entferne mit trim() unsichtbare Zeichen.
- Finde mit indexOf(',') das Komma; trenne mit substring() den Teil davor als Befehl und den Teil danach als Wert ab.
- 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.
- Gib nach jedem Befehl eine kurze Antwort im Serial Monitor aus, damit du sofort siehst, ob der Befehl verstanden wurde.
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().
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.
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}| Funktion | Was sie macht | Beispiel |
|---|---|---|
| strlen(s) | Liefert die Zeichenanzahl ohne '\0' | strlen("LED") → 3 |
| strncpy(ziel, quelle, n) | Kopiert höchstens n Zeichen | strncpy(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 sind | strcmp(komando, "LED") == 0 |
| strchr(s, c) | Liefert die Adresse des Zeichens, sonst NULL | strchr(s, ',') |
| strtok(s, ",") | Zerlegt den Text am Trennzeichen (verändert das Original) | Für das nächste Teilstück strtok(NULL, ",") |
| atoi / atol / atof | Wandelt Text in int, long oder double um | atoi("128") → 128 |
| snprintf(buf, größe, ...) | Erzeugt formatierten Text, gegen Überlauf geschützt | snprintf(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.
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.
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
| Symptom | Ursache | Lösung |
|---|---|---|
| Befehl wird gar nicht erkannt | Zeilenende auf No line ending gestellt oder am Textende bleibt '\r' hängen | Newline wählen, trim() verwenden |
| Jeder Befehl dauert 1 Sekunde | readStringUntil() wartet auf den Standard-Timeout von 1000 ms | Serial.setTimeout(50) setzen oder Zeichen für Zeichen lesen |
| "PWM,abc" schaltet die LED aus | toInt() liefert bei ungültigem Text 0 | Erstes Zeichen mit isDigit() prüfen |
| == beim char-Array ist immer false | == vergleicht die Adresse, nicht den Inhalt | strcmp(a, b) == 0 verwenden |
| Sinnlose Zeichen am Textende | Im char-Array fehlt '\0' oder das Array ist zu klein | Array mit Textlänge + 1 anlegen und mit '\0' abschließen |
| Nach Stunden Absturz oder Reset | Heap-Fragmentierung oder volles RAM auf dem Uno | reserve(), F() und char-Array verwenden |
| snprintf zeigt "?" statt Float | %f-Unterstützung ist auf AVR deaktiviert | Mit dtostrf() umwandeln |
| length() ist bei Umlauten zu groß | Zeichen wie ä, ö, ü belegen in UTF-8 2 Byte | Nach Bytes rechnen oder ASCII verwenden |
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.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
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…

LED per Bluetooth mit dem Handy steuern
Eine kleine Probe dafür, das Licht in deinem Zimmer vom Handy aus ein- und auszuschalten.

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.

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.

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…

Verwendung des LCD-Bildschirms mit I2C
Gib deinem Arduino ein eigenes Display und lass es seine erste Nachricht schreiben.

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

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

