Basi · 11 min di lettura

Arduino String: Uso, char array, substring e toInt

Come usare String in Arduino? Concatenazione, indexOf, substring, toInt, parsing di comandi dalla seriale, array di char, macro F() e frammentazione della RAM.

La String di Arduino è una classe pronta all'uso che ti permette di tenere un testo in una sola variabile, unirlo e spezzarlo. È il primo strumento a cui ricorri quando vuoi separare un comando come "LED,1" arrivato dalla seriale, scrivere un valore del sensore sullo schermo nel formato "Temperatura: 24 C" o riconoscere un messaggio ricevuto via Bluetooth. In Arduino ci sono due modi di lavorare con il testo: l'oggetto String, facile da usare, e l'array di char, più a basso livello e ereditato dal linguaggio C. Fanno lo stesso lavoro, ma usano la memoria in modo molto diverso.

In questo articolo vedrai prima le operazioni più usate con String, come concatenazione, indexOf, substring e toInt, con gli output reali. Poi scriveremo un parser che riceve comandi dalla seriale, accende e spegne un LED e ne regola la luminosità con il PWM. Quindi vedremo perché nei 2 KB di RAM dell'Arduino Uno la String può dare problemi col tempo, parlando di frammentazione della memoria e della macro F(). Nelle ultime sezioni scoprirai come scrivere lo stesso parser con un array di char, su ESP32 e su Raspberry Pi Pico con MicroPython.

Scheda Arduino Uno
Arduino Uno: il processore ATmega328P ha solo 2 KB di RAM; quando lavori con il testo questo limite è decisivo.

Cos'è String in Arduino e che differenza c'è con un array di char?

String (con la S maiuscola) è una classe definita nel core di Arduino. Conserva il testo in una zona di memoria chiamata heap e, man mano che il testo si allunga, ingrandisce da sola quello spazio. Così diventano possibili la concatenazione con +, il confronto con == e la conversione in numero con un solo comando. Un array di char, invece, è un'area di byte di dimensione fissa che decidi tu in anticipo. La fine del testo è sempre segnata da un carattere invisibile '\0' (null): per questo per la parola "Hello" di 5 lettere servono almeno 6 byte: char nome[6] = "Hello";. Con gli array di char per concatenare e confrontare usi funzioni C come strcat e strcmp; l'operatore == non confronta il contenuto di due array, ma i loro indirizzi in memoria. Questa distinzione è uno dei punti in cui i principianti inciampano più spesso.

CaratteristicaStringArray di char
Facilità d'usoMolto facile: +, ==, substring()Più difficile: strcat(), strcmp(), strtok()
Posizione in memoriaHeap, dinamicaFissa; area globale o stack
DimensioneCresce da solaStabilita in anticipo
Rischio di overflowNo, ma se la memoria finisce l'operazione fallisce in silenzioSì; i controlli sui limiti li fai tu
Rischio di frammentazioneSì (soprattutto sulla Uno)No
Dove usarlaESP32, Pico, testi brevi e saltuariProgetti sempre attivi su Uno e Nano

Memoria e collegamenti di test per piattaforma

CaratteristicaArduino UnoESP32Raspberry Pi Pico
RAM2 KB SRAM520 KB SRAM264 KB SRAM
Memoria programma32 KB flash4 MB flash esterna (su quasi tutte le schede)2 MB flash esterna
Pin LED di testD9 (PWM) + 220 ΩGPIO 4 + 220 ΩGP15 + 220 Ω
Velocità seriale (negli esempi)9600 baud115200 baudUSB (shell di Thonny)
Macro F()Fa risparmiare RAMNessun effetto, esiste per compatibilitàNon esiste (MicroPython)
Tipo di testoString e char[]String e char[]str (Python)
Se l'impostazione di fine riga in basso a destra nel Monitor seriale resta su No line ending, quando premi Invio non viene inviato il carattere '\n': il tuo parser, che aspetta la fine della riga, attenderà fino al timeout oppure non scatterà mai. Per gli esempi di questo articolo imposta Newline oppure Both NL & CR. Con la seconda opzione il carattere '\r' si attacca alla fine del testo: per questo nel codice usiamo trim() o saltiamo il carattere '\r'.

Operazioni di base con String: concatenazione, indexOf, substring, toInt

Per aggiungere testo a una String si usa += oppure concat(). indexOf() ti dice in quale posizione si trova il carattere o la parola cercata; il conteggio parte da 0 e, se non trova nulla, restituisce -1. substring(inizio, fine) copia una parte del testo: la posizione iniziale è inclusa, quella finale esclusa, quindi substring(8, 12) prende i caratteri nelle posizioni 8, 9, 10 e 11. toInt() converte le cifre all'inizio del testo in un numero di tipo long. Se carichi il codice qui sotto e apri il Monitor seriale a 9600 baud, puoi confrontare l'output di ogni riga con il valore indicato nel commento.

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}
FunzioneCosa faEsempio (s = "LED,128")
s.length()Restituisce il numero di caratteri7
s.indexOf(',')Posizione della prima corrispondenza, -1 se manca3
s.substring(0, 3)Dalla posizione 0 alla 3 (3 esclusa)"LED"
s.substring(4)Dalla posizione 4 fino alla fine"128"
s.substring(4).toInt()Converte in numero (long); 0 se non valido128
s.startsWith("LED")Inizia con questo testo?true
s.equalsIgnoreCase("led,128")Confronta ignorando maiuscole e minuscoletrue
s.charAt(0)Restituisce un singolo carattere'L'
s.trim()Elimina spazi, \r e \n all'inizio e alla fine (sul posto)Invariata (nessuno spazio)
s.c_str()Restituisce un puntatore leggibile come array di charstrcmp(s.c_str(), "LED,128") == 0
String(3.14159, 2)Converte un decimale in testo con il numero di cifre indicato"3.14"
s.replace(",", ";")Sostituisce una parte sul postos ora è "LED;128"
Attenzione quando aggiungi un numero al testo: la riga String s = "Valore: " + 5; compila ma non funziona come ti aspetti. Qui non esiste nessun oggetto String: il compilatore somma 5 all'indirizzo del testo "Valore: " e in s finisce un frammento senza senso. All'estrema sinistra della catena deve esserci per forza una String: scrivi String s = String("Valore: ") + 5; oppure prima String s = "Valore: "; e poi s += 5;.

Parsing di comandi dalla seriale passo dopo passo

  1. Collega la gamba lunga del LED (anodo) al pin D9 della Uno tramite una resistenza da 220 Ω e la gamba corta a GND. Poiché D9 supporta il PWM, potrai regolare anche la luminosità.
  2. Stabilisci il formato del comando: COMANDO,VALORE. Per esempio LED,1 accende il LED, LED,0 lo spegne, PWM,128 dà circa metà luminosità.
  3. Leggi dalla seriale la riga fino al carattere Invio ('\n') e ripulisci i caratteri invisibili con trim().
  4. Trova la posizione della virgola con indexOf(',') e separa con substring() ciò che sta prima (comando) e ciò che sta dopo (valore).
  5. Converti il valore in numero con toInt(), porta il comando in maiuscolo con toUpperCase() per confrontarlo ed esegui l'azione corrispondente.
  6. Dopo ogni comando stampa una breve risposta sul Monitor seriale, così vedi subito se il comando è stato capito.
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}

La riga Serial.setTimeout(50) è importante: readStringUntil() per impostazione predefinita aspetta il carattere successivo per 1000 ms; se la fine riga non arriva, il programma si blocca per un secondo. A 9600 baud un carattere arriva in circa 1 ms, quindi 50 ms bastano e avanzano. Se il comando non contiene la virgola, indexOf() restituisce -1: in questo caso consideriamo l'intera riga come comando e il valore resta vuoto. Applicando toInt() a una String vuota il risultato è 0. Qui c'è una trappola: toInt() restituisce 0 anche per un testo non valido, quindi per il tuo codice "PWM,abc" e "PWM,0" sono uguali. In un progetto vero è una buona abitudine controllare con isDigit() che il primo carattere del valore sia una cifra. constrain(), invece, impedisce che il valore PWM esca dall'intervallo 0–255.

Frammentazione della memoria: perché String può bloccare la Uno?

Ogni volta che una String cresce e lo spazio disponibile non basta, chiede nell'heap una nuova area più grande, ci sposta il testo e libera quella vecchia. Le aree liberate non sempre si possono riutilizzare; col tempo l'heap diventa una fetta di formaggio piena di piccoli buchi. Anche se in totale restano 300 byte liberi, se il blocco continuo più grande è di 40 byte non si può creare una String da 50 byte. Questo si chiama frammentazione della memoria (heap fragmentation). Nei 2 KB di RAM dell'Arduino Uno l'heap cresce verso l'alto e lo stack usato dalle chiamate di funzione verso il basso; quando si scontrano le variabili si corrompono, sul Monitor seriale compaiono caratteri strani o la scheda si resetta da sola. Più subdolo ancora: quando non trova spazio, l'operazione su String fallisce senza dare errori e dopo la concatenazione il testo resta incompleto o vuoto. Siccome questi problemi compaiono di solito dopo ore di funzionamento, nei brevi test alla scrivania non si notano.

  • Riserva spazio con reserve(): per una String di cui puoi stimare la lunghezza scrivi in setup() riga.reserve(64);; finché il testo resta entro questo limite non chiederà altro spazio.
  • Usa variabili globali o static: le String ricreate a ogni giro di loop() rimescolano di continuo l'heap; riutilizzare una sola String globale è più sicuro.
  • Passa per riferimento: definisci il parametro della funzione come void scrivi(const String &testo); passare la String per valore crea una nuova copia a ogni chiamata.
  • Spezza le catene lunghe: espressioni come a + b + c + d producono oggetti temporanei; aggiungere passo passo con += usa meno memoria temporanea.
  • Stampa direttamente: se il testo serve solo da mostrare, invece di concatenarlo usa più Serial.print() di seguito; così non viene creata nessuna String.
  • Non usarla nelle interrupt: nelle funzioni chiamate con attachInterrupt() non creare String; l'allocazione di memoria dentro un'interrupt non è sicura.

La macro F() per risparmiare RAM sulla Uno

Sulle schede con processore AVR (Uno, Nano, Mega) ogni testo costante scritto nel codice viene copiato dalla memoria flash alla RAM all'avvio del programma. Anche solo dieci testi di menu da 40 caratteri consumano 400 byte, cioè un quinto della RAM della Uno. La macro F("...") lascia il testo nella flash e Serial.print() o lcd.print() lo leggono da lì. La regola è semplice: metti dentro F() ogni testo costante che stampi sul Monitor seriale o sul display. F() funziona solo con la famiglia print e con le funzioni che la supportano, come l'aggiunta a una String; non si può passare direttamente a funzioni C come strcmp(). Il codice qui sotto mostra anche il metodo classico per misurare la RAM libera sulle schede AVR; puoi confrontare questo valore prima e dopo l'uso di 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}

Parsing sicuro dei comandi con un array di char

Nei progetti in cui la scheda deve funzionare per giorni senza interruzioni, soprattutto su Uno e Nano, raccogliere i comandi in un array di char di dimensione fissa è la via più solida. Il codice qui sotto scrive i caratteri in arrivo uno per uno in un buffer da 32 byte, chiude la riga con '\0' quando arriva '\n' e la divide alla virgola con strtok(). Quando il buffer è pieno i caratteri in più vengono scartati in silenzio, quindi non c'è overflow. Poiché il codice non usa mai delay() né aspetta un timeout, dentro loop() possono proseguire senza intoppi anche altre attività, come leggere un sensore o pilotare un motore. L'unica differenza è che il confronto distingue maiuscole e minuscole: devi scrivere i comandi in maiuscolo.

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}
FunzioneCosa faEsempio
strlen(s)Restituisce il numero di caratteri escluso '\0'strlen("LED") → 3
strncpy(dest, src, n)Copia al massimo n caratteristrncpy(buf, "PWM", sizeof(buf) - 1)
strcat(dest, src)Aggiunge in coda (la destinazione deve avere spazio)strcat(buf, ",128")
strcmp(a, b)Restituisce 0 se i testi sono ugualistrcmp(comando, "LED") == 0
strchr(s, c)Restituisce l'indirizzo del carattere, NULL se mancastrchr(s, ',')
strtok(s, ",")Divide il testo al separatore (modifica l'originale)Per il pezzo successivo strtok(NULL, ",")
atoi / atol / atofConverte il testo in numero int, long o doubleatoi("128") → 128
snprintf(buf, dim, ...)Produce testo formattato, protetto dall'overflowsnprintf(buf, sizeof(buf), "%d", 42)
dtostrf(num, larghezza, cifre, buf)Converte un float in testo (su AVR %f non funziona)dtostrf(3.14159, 4, 2, buf) → "3.14"

String su ESP32: perché è più comoda e dove fare attenzione?

L'ESP32 ha 520 KB di SRAM, circa 260 volte quella della Uno. Per questo usare String è molto più comodo nei lavori ricchi di testo come server web, JSON o messaggi MQTT, e il parser con String visto sopra funziona così com'è sull'ESP32 se imposti LED_PIN a 4 e la velocità a 115200 baud. La String del core ESP32 conserva i testi brevi direttamente dentro l'oggetto, senza passare dall'heap; questo riduce la frammentazione con le piccole etichette. I testi costanti sono già letti dalla flash, quindi F() qui non cambia nulla e serve solo a mantenere il codice compatibile con AVR. Tuttavia, in un server web acceso per mesi, creare grandi String a ogni richiesta può portare a frammentazione. Per tenerla sotto controllo, ESP.getFreeHeap() restituisce la memoria libera totale, mentre ESP.getMaxAllocHeap() dà il blocco continuo più grande allocabile; se la differenza tra i due cresce col tempo, la frammentazione è iniziata.

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}

Elaborazione del testo su Raspberry Pi Pico e MicroPython

In MicroPython il testo è di tipo str e, come in Python, non è modificabile: ogni operazione produce un nuovo testo e il garbage collector ripulisce quelli inutilizzati. Poiché il Pico ha 264 KB di RAM, lavori come il parsing dei comandi non mettono mai sotto sforzo la scheda. L'equivalente di indexOf di String è find(), quello di substring è lo slicing (riga[0:3]), quello di toInt è int() e quello di trim è strip(). La più comoda è split(","): divide il testo in parti in una sola riga. Invece di restituire 0 con un testo non valido, int() solleva un errore ValueError; è più sicuro dell'ambiguità di toInt() in Arduino, ma devi gestire l'errore con try/except. Collega il LED a GP15 con una resistenza da 220 Ω, esegui il codice con Thonny e scrivi i comandi nella finestra Shell. Se programmi il Pico con l'Arduino IDE, String e array di char funzionano allo stesso modo; l'unica differenza è l'abbondanza di 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)

Idee di progetto con String e comunicazione seriale

  • Controllo via Bluetooth: con un modulo Bluetooth HC-05 elabora con lo stesso parser i comandi "LED,1" o "SERVO,90" che arrivano dal telefono.
  • Pannello di controllo in Python: invia comandi da uno script Python sul computer e ricevi le misure da Arduino; i dettagli sono nell'articolo comunicazione seriale Arduino Python.
  • Messaggi tra due Arduino: con la comunicazione seriale UART una scheda invia una misura e l'altra interpreta la riga "T,24" e la scrive sul display.
  • Messaggio scorrevole su LCD: fai scorrere con substring() il testo scritto dalla seriale su un display LCD I2C.
  • Impostazioni permanenti: salva nella EEPROM la soglia ricevuta con un comando come "SOGLIA,500"; l'impostazione non si perde nemmeno se la scheda si riavvia.
  • Registrazione dati in Excel: invia i valori dei sensori come righe separate da virgole e trasferiscili in Excel.

Errori comuni e come risolverli

SintomoCausaSoluzione
Il comando non viene mai riconosciutoFine riga su No line ending o '\r' rimasto in coda al testoScegli Newline, usa trim()
Ritardo di 1 secondo a ogni comandoreadStringUntil() aspetta il timeout predefinito di 1000 msSerial.setTimeout(50) oppure lettura carattere per carattere
"PWM,abc" spegne il LEDtoInt() restituisce 0 con un testo non validoControlla il primo carattere con isDigit()
Con gli array di char == è sempre false== confronta gli indirizzi, non il contenutoUsa strcmp(a, b) == 0
Caratteri senza senso in fondo al testoManca '\0' nell'array o l'array è troppo piccoloDimensiona l'array come lunghezza del testo + 1 e chiudilo con '\0'
Blocco o reset dopo oreFrammentazione dell'heap sulla Uno, RAM esauritaUsa reserve(), F() e array di char
Con snprintf al posto del float esce "?"Su AVR il supporto a %f è disattivatoConverti con dtostrf()
length() è troppo grande con lettere accentateLettere come è, à, ù occupano 2 byte in UTF-8Calcola in base ai byte oppure usa l'ASCII
Se non sai quale strada scegliere, applica una regola semplice: su Uno e Nano, nel codice che gira di continuo, array di char e F(); nel codice di prova e su ESP32 e Pico, String. Tieni d'occhio anche la riga "Global variables use ... bytes" che l'Arduino IDE scrive a fine compilazione: sulla Uno, se questa percentuale supera il 75%, l'IDE segnala poca memoria. Per i dettagli sui problemi di memoria dai un'occhiata all'articolo Arduino memoria insufficiente.

Quando hai capito la differenza tra String e array di char, puoi elaborare con sicurezza qualsiasi comando seriale, messaggio Bluetooth o riga di un sensore. Per conoscere meglio il Monitor seriale leggi l'articolo Arduino Serial Monitor, e per la logica generale degli array l'articolo array in Arduino. Nell'app BlueGrays puoi mettere subito in pratica quello che hai imparato qui provando, passo dopo passo con schemi e codice, i progetti per accendere un LED dal telefono via Bluetooth, la comunicazione seriale tra due Arduino e la scrittura di messaggi su LCD.

Domande frequenti

In Arduino devo usare String o un array di char?

Nei codici di prova brevi, su ESP32 e su Pico, usare String è rapido e leggibile. Su schede con 2 KB di RAM come Arduino Uno o Nano, in un progetto che deve funzionare per giorni, un array di char a dimensione fissa è più sicuro perché evita del tutto la frammentazione della memoria. Si possono anche usare insieme: la funzione c_str() di String ti permette di leggerla come un array di char.

Come si converte una String in int in Arduino?

Su un oggetto String si usa testo.toInt(); il risultato è di tipo long e vengono lette le cifre all'inizio del testo. Se il testo non contiene numeri restituisce 0, quindi per distinguere uno 0 vero da un input errato controlla il primo carattere con isDigit(). Con un array di char lo stesso lavoro lo fanno atoi(), atol() o strtol(), che offre il controllo degli errori.

Come si converte un numero in String in Arduino?

Il modo più semplice è scrivere String(numero); String(255, HEX) produce un testo esadecimale, String(3.14159, 2) un decimale con due cifre. Puoi anche aggiungerlo direttamente a una String esistente con s += numero. Per un array di char si usano snprintf() o itoa(); sulle schede AVR per i numeri float serve dtostrf().

A cosa serve la macro F() di Arduino?

F() impedisce che i testi costanti passati a comandi come Serial.print() vengano copiati nella RAM e li fa leggere dalla memoria flash. Poiché l'Arduino Uno ha solo 2 KB di RAM, nei lunghi testi di menu e avvisi fa risparmiare centinaia di byte. Su ESP32 e Pico i testi costanti restano già nella flash, quindi F() non fa differenza e serve solo per compatibilità.

Come legge Arduino il testo in arrivo dalla porta seriale?

Il modo più breve è Serial.readStringUntil('\n'), che legge fino al carattere Invio; poi devi ripulire '\r' e gli spazi con trim(). Poiché per impostazione predefinita questa funzione aspetta 1 secondo, conviene ridurre il tempo con Serial.setTimeout(). Se il programma non deve mai aspettare, leggi i caratteri uno a uno con Serial.read(), accumulali in un array di char ed elaborali quando arriva '\n'.

Come si confrontano due String in Arduino?

Sugli oggetti String l'operatore == o equals() confronta il contenuto; se non vuoi distinguere maiuscole e minuscole usa equalsIgnoreCase(). Con gli array di char == confronta solo gli indirizzi di memoria e dà un risultato sbagliato; devi scrivere invece strcmp(a, b) == 0. Prima del confronto ricordati di eliminare con trim() il carattere '\r' in fondo al testo.

Vedi tutti i progetti
HC-SR04 Misura della distanza (display seriale)
AR-27Principiante

HC-SR04 Misura della distanza (display seriale)

Il sensore HC-SR04 funziona come un pipistrello che trova la strada al buio: manda un suono che non puoi sentire, ne ascolta l'eco e misura quanto è lontano l'oggetto davanti a sé.

4.6(50)
82
Controllare un LED dal telefono tramite Bluetooth
AR-34Principiante
Premium

Controllare un LED dal telefono tramite Bluetooth

Una piccola prova per accendere e spegnere le luci della tua stanza dal telefono.

4.8(69)
91
Comunicazione unidirezionale tra 2 Arduino
AR-57Intermedio
Premium

Comunicazione unidirezionale tra 2 Arduino

Fai parlare due Arduino con un solo filo: premi il pulsante sull'uno e il LED dell'altro si accende, premi di nuovo e si spegne.

4.4(37)
50
Comunicazione bidirezionale tra 2 Arduino
AR-58Intermedio
Premium

Comunicazione bidirezionale tra 2 Arduino

Due Arduino collegati con dei fili parlano tra loro: premi il pulsante di uno e si accende la luce dell'altro, premilo di nuovo e si spegne.

4.5(20)
26
Visualizzare un messaggio su display LCD 2x16
AR-29Avanzato
Premium

Visualizzare un messaggio su display LCD 2x16

Il tuo primo passo per scrivere testo su uno schermo. Il display LCD a due righe mostra prima un messaggio di attesa, poi scrive un saluto sulla riga in alto e batte una parola lettera per lettera su…

4.6(37)
51
Utilizzo dello schermo LCD con I2C
AR-32Principiante
Premium

Utilizzo dello schermo LCD con I2C

Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

4.8(53)
70
Tastiera per sviluppatori Python
AR-66Intermedio
Premium

Tastiera per sviluppatori Python

Se sei stanco di scrivere sempre gli stessi schemi mentre programmi, questa piccola tastiera fa per te.

4.6(35)
45
Auto controllata via Bluetooth con L298N
AR-80Avanzato
Premium

Auto controllata via Bluetooth con L298N

Trasforma il telefono in un telecomando e guida la tua auto robot. L'Arduino riceve tramite un modulo Bluetooth i comandi di un'app di controllo remoto sul telefono e fa girare le ruote con un driver…

5.0(39)
66