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.

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.
| Eigenschap | String | char-array |
|---|---|---|
| Gebruiksgemak | Heel makkelijk: +, ==, substring() | Lastiger: strcat(), strcmp(), strtok() |
| Waar het in het geheugen staat | Heap, dynamisch | Vast; globaal gebied of stack |
| Grootte | Groeit vanzelf | Vooraf ingesteld |
| Risico op overflow | Geen, maar als het geheugen op is, mislukt de bewerking zonder foutmelding | Ja; je controleert zelf de grenzen |
| Risico op fragmentatie | Ja (vooral op de Uno) | Nee |
| Het best voor | ESP32, Pico, korte en weinig gebruikte tekst | Projecten die altijd aan staan op de Uno en Nano |
Geheugen per platform en testaansluitingen
| Eigenschap | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| RAM | 2 KB SRAM | 520 KB SRAM | 264 KB SRAM |
| Programmageheugen | 32 KB flash | 4 MB externe flash (op de meeste boards) | 2 MB externe flash |
| Pin van de test-led | D9 (PWM) + 220 Ω | GPIO 4 + 220 Ω | GP15 + 220 Ω |
| Seriële snelheid (in de voorbeelden) | 9600 baud | 115200 baud | USB (Thonny-shell) |
| F()-macro | Bespaart RAM | Geen effect, bestaat voor compatibiliteit | Niet beschikbaar (MicroPython) |
| Teksttype | String en char[] | String en char[] | str (Python) |
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.
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}| Functie | Wat het doet | Voorbeeld (s = "LED,128") |
|---|---|---|
| s.length() | Geeft het aantal tekens terug | 7 |
| s.indexOf(',') | Positie van de eerste overeenkomst, -1 als er geen is | 3 |
| 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 is | 128 |
| s.startsWith("LED") | Begint het met deze tekst? | true |
| s.equalsIgnoreCase("led,128") | Vergelijkt zonder onderscheid tussen hoofd- en kleine letters | true |
| 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-array | strcmp(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 plekke | s is nu "LED;128" |
Seriële commando's stap voor stap ontleden
- 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.
- Bepaal het commandoformaat: COMMANDO,WAARDE. LED,1 zet de led bijvoorbeeld aan, LED,0 zet hem uit en PWM,128 geeft ongeveer halve helderheid.
- Lees een regel van de seriële poort tot het Enter-teken ('\n') en ruim onzichtbare tekens op met trim().
- Zoek de komma met indexOf(','); splits met substring() wat ervoor staat af als commando en wat erna komt als waarde.
- 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.
- Stuur na elk commando een kort antwoord naar de Serial Monitor, zodat je meteen ziet of het commando is begrepen.
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().
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.
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}| Functie | Wat het doet | Voorbeeld |
|---|---|---|
| strlen(s) | Geeft het aantal tekens terug, zonder '\0' | strlen("LED") → 3 |
| strncpy(dest, src, n) | Kopieert maximaal n tekens | strncpy(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 zijn | strcmp(cmd, "LED") == 0 |
| strchr(s, c) | Geeft het adres van het teken terug, NULL als het er niet is | strchr(s, ',') |
| strtok(s, ",") | Splitst de tekst bij een scheidingsteken (wijzigt het origineel) | strtok(NULL, ",") voor het volgende stuk |
| atoi / atol / atof | Zet tekst om in een int-, long- of double-getal | atoi("128") → 128 |
| snprintf(buf, size, ...) | Bouwt opgemaakte tekst, beveiligd tegen overflow | snprintf(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.
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.
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
| Symptoom | Oorzaak | Oplossing |
|---|---|---|
| Commando wordt nooit herkend | Regeleinde staat op No line ending, of '\r' staat nog aan het einde van de tekst | Kies Newline, gebruik trim() |
| 1 seconde vertraging bij elk commando | readStringUntil() wacht op de standaard-timeout van 1000 ms | Serial.setTimeout(50) of lees teken voor teken |
| "PWM,abc" zet de led uit | toInt() geeft 0 bij ongeldige tekst | Controleer het eerste teken met isDigit() |
| == is bij char-arrays altijd onwaar | == vergelijkt adressen, niet inhoud | Gebruik strcmp(a, b) == 0 |
| Betekenisloze tekens aan het einde van de tekst | '\0' ontbreekt in de char-array of de array is te klein | Maak de array tekstlengte + 1 groot en sluit af met '\0' |
| Loopt na uren vast of reset | Heapfragmentatie of RAM dat op is op de Uno | Gebruik reserve(), F() en char-arrays |
| snprintf print "?" in plaats van een float | Ondersteuning voor %f is uitgeschakeld op AVR | Zet om met dtostrf() |
| length() is te groot bij tekst met letters met accenten | Letters als ş, ğ, ı nemen 2 bytes in beslag in UTF-8 | Reken op basis van het aantal bytes of gebruik ASCII |
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.
Projecten om hierna te bouwen
Alle projecten bekijken
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.

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

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.

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.

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…

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…

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

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…
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

