Basis · 11 min leestijd

Arduino String-tutorial: char-array, substring en toInt

Hoe gebruik je Arduino String? Samenvoegen, indexOf, substring, toInt, seriële commando's verwerken, char-arrays, de F()-macro en heapfragmentatie op de Uno.

Arduino String is een kant-en-klare klasse waarmee je tekst in één variabele bewaart, samenvoegt en weer opsplitst. Wil je een commando als "LED,1" van de seriële poort opsplitsen, een sensorwaarde afdrukken als "Temperatuur: 24 C" of een bericht herkennen dat via Bluetooth binnenkomt? Dan is het het eerste gereedschap waar je naar grijpt. Er zijn twee manieren om met tekst te werken in Arduino: het gebruiksvriendelijke String-object en de laagniveau-char-array uit C. Beide doen hetzelfde werk, maar ze gebruiken het geheugen heel verschillend.

In dit artikel zie je eerst de meest voorkomende String-bewerkingen, zoals samenvoegen, indexOf, substring en toInt, met echte uitvoer. Daarna schrijven we een parser die commando's van de seriële poort leest, een led aan- en uitzet en de helderheid instelt met PWM. Vervolgens kijken we waarom String na verloop van tijd problemen kan geven in de 2 KB RAM van de Arduino Uno, met heapfragmentatie en de F()-macro. In de laatste delen leer je hoe dezelfde parser wordt geschreven met een char-array, op de ESP32 en in MicroPython op de Raspberry Pi Pico.

Arduino Uno board
Arduino Uno: de ATmega328P heeft maar 2 KB RAM, en die grens is bepalend als je met tekst werkt.

Wat is String in Arduino en wat is het verschil met een char-array?

String (met een hoofdletter S) is een klasse die in de Arduino-core is gedefinieerd. Een String bewaart zijn tekst in een geheugengebied dat de heap heet en laat die ruimte zelf groeien naarmate de tekst langer wordt. Daardoor kun je met + samenvoegen, met == vergelijken en met één aanroep omzetten naar een getal. Een char-array is daarentegen een vast blok bytes waarvan jij vooraf de grootte bepaalt. Het einde van de tekst wordt altijd gemarkeerd met een onzichtbaar '\0'-teken (null), dus het woord "Hello" van 5 letters heeft een array van minimaal 6 bytes nodig: char name[6] = "Hello";. Bij een char-array gebruik je C-functies zoals strcat en strcmp om samen te voegen en te vergelijken; de operator == vergelijkt de geheugenadressen van twee arrays, niet hun inhoud. Dit verschil is een van de punten waar beginners het vaakst op vastlopen.

EigenschapStringchar-array
GebruiksgemakHeel makkelijk: +, ==, substring()Lastiger: strcat(), strcmp(), strtok()
Waar het in het geheugen staatHeap, dynamischVast; globaal gebied of stack
GrootteGroeit vanzelfVooraf ingesteld
Risico op overflowGeen, maar als het geheugen op is, mislukt de bewerking zonder foutmeldingJa; je controleert zelf de grenzen
Risico op fragmentatieJa (vooral op de Uno)Nee
Het best voorESP32, Pico, korte en weinig gebruikte tekstProjecten die altijd aan staan op de Uno en Nano

Geheugen per platform en testaansluitingen

EigenschapArduino UnoESP32Raspberry Pi Pico
RAM2 KB SRAM520 KB SRAM264 KB SRAM
Programmageheugen32 KB flash4 MB externe flash (op de meeste boards)2 MB externe flash
Pin van de test-ledD9 (PWM) + 220 ΩGPIO 4 + 220 ΩGP15 + 220 Ω
Seriële snelheid (in de voorbeelden)9600 baud115200 baudUSB (Thonny-shell)
F()-macroBespaart RAMGeen effect, bestaat voor compatibiliteitNiet beschikbaar (MicroPython)
TeksttypeString en char[]String en char[]str (Python)
Als de instelling voor het regeleinde rechtsonder in de Serial Monitor op No line ending blijft staan, wordt er geen '\n'-teken verstuurd als je op Enter drukt; je parser, die op het einde van de regel wacht, wacht dan tot de timeout of wordt helemaal nooit geactiveerd. Zet de instelling voor de voorbeelden in dit artikel op Newline of Both NL & CR. Bij de tweede optie blijft het '\r'-teken aan het einde van de tekst plakken, daarom gebruikt de code trim() of slaat ze '\r' over.

Basisbewerkingen met String: samenvoegen, indexOf, substring, toInt

Om tekst aan een String toe te voegen gebruik je += of concat(). indexOf() geeft aan op welke positie het teken of woord staat dat je zoekt; het tellen begint bij 0 en je krijgt -1 terug als er niets wordt gevonden. substring(start, end) kopieert een stuk van de tekst: de beginpositie is inbegrepen en de eindpositie niet, dus substring(8, 12) pakt de tekens op positie 8, 9, 10 en 11. toInt() zet de cijfers aan het begin van de tekst om in een long-getal. Als je de onderstaande code uploadt en de Serial Monitor opent op 9600 baud, kun je de uitvoer van elke regel vergelijken met de waarde in het commentaar.

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}
FunctieWat het doetVoorbeeld (s = "LED,128")
s.length()Geeft het aantal tekens terug7
s.indexOf(',')Positie van de eerste overeenkomst, -1 als er geen is3
s.substring(0, 3)Van 0 tot positie 3 (3 niet inbegrepen)"LED"
s.substring(4)Van positie 4 tot het einde"128"
s.substring(4).toInt()Zet om naar een getal (long); 0 als het ongeldig is128
s.startsWith("LED")Begint het met deze tekst?true
s.equalsIgnoreCase("led,128")Vergelijkt zonder onderscheid tussen hoofd- en kleine letterstrue
s.charAt(0)Geeft één teken terug'L'
s.trim()Verwijdert spaties, \r en \n aan het begin en einde (ter plekke)Ongewijzigd (geen witruimte)
s.c_str()Geeft een pointer terug die je kunt lezen als een char-arraystrcmp(s.c_str(), "LED,128") == 0
String(3.14159, 2)Zet een decimaal getal om in tekst met het opgegeven aantal cijfers"3.14"
s.replace(",", ";")Vervangt een stuk ter plekkes is nu "LED;128"
Pas op als je een getal aan tekst toevoegt: de regel String s = "Value: " + 5; compileert, maar werkt niet zoals je verwacht. Er is hier helemaal geen String-object; de compiler telt 5 op bij het adres van de tekst "Value: " en s krijgt een betekenisloos fragment zoals ": ". Het uiterst linkse deel van de keten moet een String zijn: schrijf String s = String("Value: ") + 5;, of schrijf eerst String s = "Value: "; en voeg daarna s += 5; toe.

Seriële commando's stap voor stap ontleden

  1. Sluit het lange pootje (anode) van de led via een weerstand van 220 Ω aan op pin D9 van de Uno en het korte pootje op GND. D9 ondersteunt PWM, dus de helderheid kan ook worden geregeld.
  2. Bepaal het commandoformaat: COMMANDO,WAARDE. LED,1 zet de led bijvoorbeeld aan, LED,0 zet hem uit en PWM,128 geeft ongeveer halve helderheid.
  3. Lees een regel van de seriële poort tot het Enter-teken ('\n') en ruim onzichtbare tekens op met trim().
  4. Zoek de komma met indexOf(','); splits met substring() wat ervoor staat af als commando en wat erna komt als waarde.
  5. Zet de waarde om in een getal met toInt(), zet het commando met toUpperCase() om naar hoofdletters, vergelijk het en voer dan de bijbehorende actie uit.
  6. Stuur na elk commando een kort antwoord naar de Serial Monitor, zodat je meteen ziet of het commando is begrepen.
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}

De regel Serial.setTimeout(50) is belangrijk: readStringUntil() wacht standaard 1000 ms op het volgende teken, dus als er geen regeleinde binnenkomt, blijft het programma een seconde hangen. Bij 9600 baud komt er ongeveer elke milliseconde een teken binnen, dus 50 ms is ruim voldoende. Als het commando geen komma bevat, geeft indexOf() -1 terug; dan behandelen we de hele regel als commando en blijft de waarde leeg. toInt() op een lege String geeft 0. Hier zit een valkuil: toInt() geeft ook 0 voor ongeldige tekst, dus "PWM,abc" en "PWM,0" zien er voor de code hetzelfde uit. In een echt project is het een goede gewoonte om met isDigit() te controleren of het eerste teken van de waarde een cijfer is. constrain() zorgt ervoor dat de PWM-waarde niet buiten het bereik 0–255 komt.

Geheugenfragmentatie: waarom kan String een Uno laten vastlopen?

Elke keer dat een String groeit en de huidige ruimte niet genoeg is, vraagt hij de heap om een groter nieuw blok, verplaatst de tekst daarheen en geeft het oude blok vrij. Vrijgegeven blokken kunnen niet altijd opnieuw worden gebruikt; na verloop van tijd verandert de heap in een plak gatenkaas met kleine gaatjes. Ook als er in totaal 300 bytes vrij zijn, kan er geen String van 50 bytes worden gemaakt als het grootste aaneengesloten stuk 40 bytes is. Dit heet heapfragmentatie. In de 2 KB RAM van de Arduino Uno groeit de heap omhoog terwijl de stack voor functieaanroepen omlaag groeit; als die twee botsen, raken variabelen beschadigd, verschijnen er vreemde tekens in de Serial Monitor of reset het board zichzelf. Het gemene is dat de String-bewerking zonder foutmelding mislukt als er geen ruimte te vinden is: na een samenvoeging blijft de tekst half af of leeg. Omdat deze problemen meestal pas verschijnen nadat het programma uren draait, merk je ze niet bij korte tests aan je bureau.

  • Reserveer ruimte met reserve(): Schrijf voor een String waarvan je de lengte kunt inschatten line.reserve(64); in setup(); zolang de tekst binnen die limiet blijft, wordt er geen nieuwe ruimte gevraagd.
  • Gebruik globaal of static: Strings die bij elke ronde van loop() opnieuw worden gemaakt, blijven de heap omwoelen; het hergebruiken van één globale String is veiliger.
  • Geef door als referentie: Definieer functieparameters als void print(const String &text); een String doorgeven als waarde maakt bij elke aanroep een nieuwe kopie.
  • Breek lange ketens op: Uitdrukkingen als a + b + c + d maken tijdelijke objecten; stap voor stap toevoegen met += gebruikt minder tijdelijk geheugen.
  • Print direct: Als je de tekst alleen wilt tonen, gebruik dan opeenvolgende Serial.print()-aanroepen in plaats van samenvoegen; dan wordt er helemaal geen String gemaakt.
  • Gebruik het niet in interrupts: Maak geen Strings in functies die via attachInterrupt() worden aangeroepen; geheugenreservering is niet veilig binnen een interrupt.

RAM besparen op de Uno met de F()-macro

Op AVR-boards (Uno, Nano, Mega) wordt elke constante tekst in je code bij het starten van het programma van flash naar RAM gekopieerd. Tien menuteksten van 40 tekens gebruiken al 400 bytes, een vijfde van het RAM van de Uno. De macro F("...") laat de tekst in flash staan en Serial.print() of lcd.print() leest hem van daaruit. De regel is simpel: zet elke constante tekst die je naar de Serial Monitor of een display print in F(). F() werkt alleen met de print-familie en met plaatsen die het ondersteunen, zoals toevoegen aan een String; je kunt het niet direct doorgeven aan C-functies zoals strcmp(). De onderstaande code toont ook de klassieke manier om het vrije RAM op AVR-boards te meten; je kunt deze waarde vergelijken voor en na het gebruik van 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}

Veilig commando's ontleden met een char-array

In projecten waarbij het board dagenlang ononderbroken draait, vooral op de Uno en Nano, is het verzamelen van commando's in een char-array van vaste grootte de robuustste manier. De onderstaande code schrijft binnenkomende tekens één voor één in een buffer van 32 bytes, sluit de regel af met '\0' zodra '\n' binnenkomt en splitst hem bij de komma met strtok(). Als de buffer vol is, worden extra tekens stilzwijgend weggegooid, dus er is geen overflow. Omdat de code nooit wacht met delay() of een timeout, blijven andere taken in loop(), zoals sensoren uitlezen of motoren aansturen, ononderbroken doorlopen. Het enige verschil is dat de vergelijking hoofdlettergevoelig is: je moet commando's in hoofdletters typen.

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}
FunctieWat het doetVoorbeeld
strlen(s)Geeft het aantal tekens terug, zonder '\0'strlen("LED") → 3
strncpy(dest, src, n)Kopieert maximaal n tekensstrncpy(buf, "PWM", sizeof(buf) - 1)
strcat(dest, src)Voegt toe aan het einde (dest moet ruimte hebben)strcat(buf, ",128")
strcmp(a, b)Geeft 0 terug als de teksten gelijk zijnstrcmp(cmd, "LED") == 0
strchr(s, c)Geeft het adres van het teken terug, NULL als het er niet isstrchr(s, ',')
strtok(s, ",")Splitst de tekst bij een scheidingsteken (wijzigt het origineel)strtok(NULL, ",") voor het volgende stuk
atoi / atol / atofZet tekst om in een int-, long- of double-getalatoi("128") → 128
snprintf(buf, size, ...)Bouwt opgemaakte tekst, beveiligd tegen overflowsnprintf(buf, sizeof(buf), "%d", 42)
dtostrf(number, width, digits, buf)Zet een float om in tekst (%f werkt niet op AVR)dtostrf(3.14159, 4, 2, buf) → "3.14"

String op de ESP32: waarom is het makkelijker en waar let je op?

De ESP32 heeft 520 KB SRAM, ongeveer 260 keer zoveel als de Uno. Daardoor is String veel makkelijker te gebruiken bij tekstzware taken zoals webservers, JSON- of MQTT-berichten, en de String-parser hierboven draait ongewijzigd op de ESP32 als je LED_PIN op 4 zet en de baudrate op 115200. De String in de ESP32-core slaat korte teksten direct in het object zelf op zonder naar de heap te gaan, wat de fragmentatie bij kleine labels vermindert. Constante tekst wordt al uit flash gelezen, dus F() verandert hier niets en houdt de code alleen compatibel met AVR. Toch kan het bij een webserver die maandenlang aan staat tot fragmentatie leiden als je bij elk verzoek grote Strings opbouwt. Om dit te bewaken geeft ESP.getFreeHeap() het totale vrije geheugen en ESP.getMaxAllocHeap() het grootste aaneengesloten blok dat kan worden gereserveerd; als het verschil tussen die twee na verloop van tijd groeit, is de fragmentatie 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}

Tekst verwerken op de Raspberry Pi Pico met MicroPython

In MicroPython is tekst het type str en, net als in Python, onveranderlijk; elke bewerking maakt een nieuwe string en de garbage collector ruimt de ongebruikte op. Omdat de Pico 264 KB RAM heeft, belasten taken zoals commando's ontleden het board helemaal niet. Het equivalent van indexOf van String is find(), van substring is slicing (line[0:3]), van toInt is int() en van trim is strip(). De handigste is split(","), die de tekst in één regel in stukken breekt. Bij ongeldige tekst geeft int() een ValueError in plaats van 0; dat is veiliger dan de dubbelzinnigheid van toInt() in Arduino, maar je moet de fout opvangen met try/except. Sluit de led via een weerstand van 220 Ω aan op GP15, voer de code uit in Thonny en typ de commando's in het Shell-venster. Als je de Pico programmeert met de Arduino IDE, werken String en char-arrays op dezelfde manier; het enige verschil is dat er ruim voldoende RAM is.

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)

Projectideeën met String en seriële communicatie

  • Besturen via Bluetooth: Verwerk commando's als "LED,1" of "SERVO,90" die van een telefoon komen via een HC-05 Bluetooth-module met dezelfde parser.
  • Python-bedieningspaneel: Stuur commando's vanuit een Python-script op je computer en lees metingen terug van de Arduino; details in seriële communicatie tussen Arduino en Python.
  • Berichten tussen twee Arduino's: Met seriële UART-communicatie stuurt het ene board een meting en ontleedt het andere de regel "T,24" en toont die op een display.
  • Scrollend bericht op een LCD: Laat tekst die je in de seriële poort typt scrollen met substring() en toon hem op een I2C-LCD-display.
  • Instellingen permanent maken: Sla een drempelwaarde die je met een commando als "THRESH,500" ontvangt op in EEPROM, zodat de instelling niet verloren gaat als het board opnieuw opstart.
  • Data loggen naar Excel: Stuur sensorwaarden als regels met komma's en exporteer ze naar Excel.

Veelgemaakte fouten en hoe je ze oplost

SymptoomOorzaakOplossing
Commando wordt nooit herkendRegeleinde staat op No line ending, of '\r' staat nog aan het einde van de tekstKies Newline, gebruik trim()
1 seconde vertraging bij elk commandoreadStringUntil() wacht op de standaard-timeout van 1000 msSerial.setTimeout(50) of lees teken voor teken
"PWM,abc" zet de led uittoInt() geeft 0 bij ongeldige tekstControleer het eerste teken met isDigit()
== is bij char-arrays altijd onwaar== vergelijkt adressen, niet inhoudGebruik strcmp(a, b) == 0
Betekenisloze tekens aan het einde van de tekst'\0' ontbreekt in de char-array of de array is te kleinMaak de array tekstlengte + 1 groot en sluit af met '\0'
Loopt na uren vast of resetHeapfragmentatie of RAM dat op is op de UnoGebruik reserve(), F() en char-arrays
snprintf print "?" in plaats van een floatOndersteuning voor %f is uitgeschakeld op AVRZet om met dtostrf()
length() is te groot bij tekst met letters met accentenLetters als ş, ğ, ı nemen 2 bytes in beslag in UTF-8Reken op basis van het aantal bytes of gebruik ASCII
Als je niet kunt kiezen, pas dan een simpele regel toe: char-arrays en F() in code die altijd draait op de Uno en Nano, en String in testcode en op de ESP32 en Pico. Houd ook de regel "Global variables use ... bytes" in de gaten die de Arduino IDE aan het einde van het compileren toont; als die op de Uno boven de 75 procent komt, geeft de IDE een waarschuwing voor weinig geheugen. Meer over geheugenproblemen vind je in Arduino heeft te weinig geheugen.

Zodra je het verschil tussen String en een char-array begrijpt, kun je elk commando van de seriële poort, elk Bluetooth-bericht en elke sensorregel veilig verwerken. Om de Serial Monitor beter te leren kennen, zie je Arduino Serial Monitor, en voor de algemene logica van arrays Arduino-arrays. In de BlueGrays-app kun je het geleerde meteen toepassen met projecten als een led aansteken vanaf je telefoon via Bluetooth, seriële communicatie tussen twee Arduino's en berichten afdrukken op een LCD, met stap-voor-stap schakelschema's en code.

Veelgestelde vragen

Moet ik in Arduino String of een char-array gebruiken?

In korte testsketches, op de ESP32 en op de Pico is String snel en leesbaar. In een project dat dagenlang moet draaien op een board met 2 KB RAM, zoals de Arduino Uno of Nano, is een char-array van vaste grootte veiliger, omdat die heapfragmentatie volledig vermijdt. Je kunt ook allebei combineren: met de functie c_str() van String kun je hem lezen als een char-array.

Hoe zet ik in Arduino een String om in een int?

Bij een String-object gebruik je text.toInt(); het resultaat is een long en de cijfers aan het begin van de tekst worden gelezen. Als de tekst geen getal bevat, krijg je 0 terug; controleer daarom het eerste teken met isDigit() om een echte 0 van foute invoer te onderscheiden. Bij een char-array doen atoi(), atol() of strtol(), dat foutcontrole biedt, hetzelfde werk.

Hoe zet ik in Arduino een getal om in een String?

De makkelijkste manier is String(number) te schrijven; String(255, HEX) levert hexadecimale tekst op en String(3.14159, 2) levert tekst met twee decimalen op. Je kunt ook direct aan een bestaande String toevoegen met s += number. Voor een char-array gebruik je snprintf() of itoa(); op AVR-boards heb je dtostrf() nodig voor float-getallen.

Wat doet de Arduino F()-macro?

F() zorgt ervoor dat de constante tekst die je aan commando's als Serial.print() doorgeeft niet naar RAM wordt gekopieerd, maar uit flash wordt gelezen. Omdat de Arduino Uno maar 2 KB RAM heeft, bespaart het honderden bytes bij lange menu- en waarschuwingsteksten. Op de ESP32 en Pico blijft constante tekst al in flash, dus F() maakt geen verschil en bestaat alleen voor compatibiliteit.

Hoe leest Arduino tekst van de seriële poort?

De kortste manier is lezen tot het Enter-teken met Serial.readStringUntil('\n'); daarna ruim je '\r' en spaties op met trim(). Omdat deze functie standaard 1 seconde wacht, is het verstandig de tijd te verkorten met Serial.setTimeout(). Als het programma nooit mag wachten, lees je tekens één voor één met Serial.read(), verzamel je ze in een char-array en verwerk je de regel zodra '\n' binnenkomt.

Hoe vergelijk ik twee Strings in Arduino?

Bij String-objecten vergelijkt de operator == of equals() de inhoud; als hoofdletters er niet toe doen, gebruik je equalsIgnoreCase(). Bij char-arrays vergelijkt == alleen geheugenadressen en geeft het foute resultaten, dus je moet in plaats daarvan strcmp(a, b) == 0 schrijven. Vergeet niet om voor het vergelijken de '\r' aan het einde van de tekst met trim() te verwijderen.

Alle projecten bekijken
Afstand meten met HC-SR04 (Serial-weergave)
AR-27Beginner

Afstand meten met HC-SR04 (Serial-weergave)

De HC-SR04-sensor werkt net als een vleermuis die in het donker zijn weg vindt: hij stuurt een geluid uit dat je niet kunt horen, luistert naar de echo en meet hoe ver het object voor hem staat.

4.6(50)
82
LED bedienen met je telefoon via Bluetooth
AR-34Beginner
Premium

LED bedienen met je telefoon via Bluetooth

Een kleine oefening voor het aan- en uitzetten van de lampen in je kamer met je telefoon.

4.8(69)
91
Eenrichtingscommunicatie tussen 2 Arduino's
AR-57Gemiddeld
Premium

Eenrichtingscommunicatie tussen 2 Arduino's

Je laat twee Arduino's met elkaar praten via één draad: druk op de knop van de ene en de led van de andere gaat aan, druk nog een keer en hij gaat uit.

4.4(37)
50
Tweerichtingscommunicatie tussen 2 Arduino's
AR-58Gemiddeld
Premium

Tweerichtingscommunicatie tussen 2 Arduino's

Twee Arduino's zijn met draden aan elkaar gekoppeld en praten met elkaar: druk op de knop van de ene en het lampje van de andere gaat aan, druk nog eens en het gaat uit.

4.5(20)
26
Een bericht tonen op een 2x16-lcd-scherm
AR-29Gevorderd
Premium

Een bericht tonen op een 2x16-lcd-scherm

Je eerste stap naar tekst op een scherm. Het lcd-scherm met twee regels toont eerst een wachtbericht, schrijft dan een groet op de bovenste regel en typt op de onderste regel een woord letter voor…

4.6(37)
51
Een lcd-scherm gebruiken met I2C
AR-32Beginner
Premium

Een lcd-scherm gebruiken met I2C

Geef je Arduino een eigen scherm en laat hem zijn eerste bericht schrijven. Het lcd-scherm met twee regels sluit je aan met maar een paar draden; op de bovenste regel verschijnt een groet, daarna een…

4.8(53)
70
Python-ontwikkelaarstoetsenbord
AR-66Gemiddeld
Premium

Python-ontwikkelaarstoetsenbord

Als je het zat bent om tijdens het programmeren steeds dezelfde patronen te typen, is dit kleine toetsenbord iets voor jou.

4.6(35)
45
Auto met Bluetooth-besturing en L298N
AR-80Gevorderd
Premium

Auto met Bluetooth-besturing en L298N

Verander je telefoon in een afstandsbediening en bestuur je eigen robotauto. De Arduino ontvangt via een Bluetooth-module commando's van een afstandsbedieningsapp op je telefoon en laat de wielen…

5.0(39)
66