Basi · 11 min di lettura

Array Arduino: guida a dichiarazione, ciclo for ed esempi

Array in Arduino passo passo: dichiarazione, indice, ciclo for, array bidimensionali, pin dei LED, media dei sensori e melodie con il buzzer, anche su ESP32 e Pico.

Usare gli array in Arduino è una competenza di base che ti permette di raccogliere molti valori dello stesso tipo sotto un unico nome e di raggiungere ciascuno tramite il suo numero (l'indice). Invece di scrivere il pin di sei LED, le ultime dieci letture di un sensore o le note di una canzone in variabili separate come led1, led2, led3, li conservi in un solo array e li elabori tutti in poche righe con un ciclo for. Così il codice diventa più corto, sbagli meno e, per aggiungere un nuovo LED al circuito, basta aggiungere un numero all'elenco dell'array.

In questa guida vedrai come un array sta in memoria, come si dichiara, perché l'indice parte da zero e come calcolare il numero di elementi con sizeof. Poi faremo tre esempi concreti: l'effetto Knight Rider con i LED, la media mobile che leviga i dati rumorosi di un sensore e una melodia con il buzzer. Infine costruirai con gli array bidimensionali una tabella di stati per un semaforo, vedrai le differenze su ESP32 e Raspberry Pi Pico e scoprirai come individuare gli errori di overflow che rompono il programma in silenzio. Se sei completamente nuovo, dai prima un'occhiata a Fondamenti di programmazione Arduino.

LED usati nell'esempio di array con Arduino
Gestire sei LED con un unico array di pin invece che uno per uno è l'uso più classico degli array.

Che cos'è un array e come funziona?

Un array è un blocco di elementi affiancati in memoria, tutti dello stesso tipo di dato. Immaginalo come un armadio con cassetti numerati: l'armadio ha un solo nome e ogni cassetto ha un numero. Nel linguaggio di Arduino, basato su C e C++, la numerazione parte da 0: un array di 5 elementi ha indici 0, 1, 2, 3 e 4, cioè l'ultimo indice è sempre il numero di elementi meno uno. Il compilatore conosce l'indirizzo iniziale dell'array: quando scrivi array[3], aggiunge all'indirizzo iniziale 3 × la dimensione dell'elemento e va direttamente in quella cella. Per questo l'accesso è velocissimo, ma per lo stesso motivo il compilatore non controlla se esci dai limiti. La memoria occupata da un array è il numero di elementi per la dimensione di un singolo elemento:

Tipo di datoDimensione elemento (Uno)Dimensione elemento (ESP32 / Pico, C++)Array da 100 elementi (Uno)
byte / uint8_t1 byte1 byte100 byte
char1 byte1 byte100 byte
int2 byte4 byte200 byte
unsigned int2 byte4 byte200 byte
long4 byte4 byte400 byte
float4 byte4 byte400 byte

Considerando che Arduino Uno ha solo 2 KB (2048 byte) di RAM, un array di 1000 int da solo si mangerebbe quasi tutta la memoria. Per questo è buona abitudine usare byte per i valori tra 0 e 255 (numeri di pin, luminosità PWM, giorno o ora), int per i risultati di analogRead e long per le somme grandi. Scegliere il tipo giusto significa far stare nella stessa memoria il doppio dei dati.

Come si dichiara un array in Arduino?

Per dichiarare un array scrivi prima il tipo di dato, poi il nome e, tra parentesi quadre, il numero di elementi. I valori puoi assegnarli subito tra parentesi graffe, oppure lasciare vuota la dimensione e lasciar contare al compilatore. Il programma seguente mostra le forme più usate insieme e scrive i risultati sul Monitor seriale:

C++ (Arduino IDE)
1int notlar[5] = {90, 75, 60, 85, 100};   // boyut ve değerler / size and values
2int pinler[] = {2, 3, 4, 5, 6, 7};       // boyutu derleyici sayar / compiler counts the size
3float olcumler[10] = {1.5, 2.0};         // kalan 8 eleman 0.0 / remaining 8 are 0.0
4int bos[5];                              // global dizi: hepsi 0 / global array: all zeros
5char isim[] = "Arduino";                 // 7 harf + '\0' = 8 bayt / 7 letters + '\0' = 8 bytes
6
7void setup() {
8  Serial.begin(9600);
9  Serial.println(notlar[0]);             // ilk eleman: 90 / first element: 90
10  Serial.println(notlar[4]);             // son eleman: 100 / last element: 100
11  notlar[2] = 65;                        // üçüncü elemanı değiştir / change the third element
12  Serial.println(notlar[2]);             // 65
13  Serial.println(olcumler[5]);           // 0.00
14  Serial.println(bos[3]);                // 0
15  Serial.println(sizeof(isim));          // 8
16  Serial.println(sizeof(pinler) / sizeof(pinler[0]));  // eleman sayısı: 6 / element count: 6
17}
18
19void loop() {
20}
DichiarazioneSignificato
int a[5];Array di 5 elementi; se globale tutti valgono 0, se dentro una funzione i valori iniziali sono casuali
int a[5] = {1, 2, 3, 4, 5};Dimensione e valori indicati insieme
int a[] = {2, 3, 4};La dimensione la conta il compilatore (qui 3)
float a[10] = {1.5, 2.0};Gli elementi senza valore diventano 0
int a[5] = {0};Il modo breve per azzerare tutti gli elementi
char s[] = "Arduino";Array di testo; alla fine c'è un carattere invisibile '\0' (8 byte in totale)
const byte a[] = {2, 3, 4};Array costante, non modificabile nel programma
L'indice parte da 0. Nell'array int a[5] di 5 elementi non esiste un elemento a[5]; l'ultimo è a[4]. Il compilatore nella maggior parte dei casi non segnala questo errore: scrivendo in a[5] sovrascrivi un'altra variabile che sta subito dopo l'array in memoria. Il risultato non è un messaggio di errore, ma valori senza senso, un Arduino che si riavvia da solo o un guasto misterioso da cercare per ore.

Scorrere l'array con il ciclo for

La vera forza degli array emerge combinandoli con il ciclo for. La variabile i parte da 0 e arriva fino al numero di elementi meno uno; a ogni giro raggiungi l'elemento successivo con array[i]. Invece di scrivere a mano il numero di elementi, il modo più sicuro è calcolarlo con la formula sizeof(array) / sizeof(array[0]): sizeof(array) dà i byte totali, sizeof(array[0]) la dimensione di un singolo elemento. Ad esempio, su Uno un array di 7 int occupa 14 byte e 14 / 2 = 7. Quando aggiungi elementi, la formula aggiorna il numero da sola. Il codice seguente trova la media, il minimo e il massimo delle temperature di una settimana. La somma delle misure è 161, la media 23,0 gradi; il minimo è 19 e il massimo 27. Fai attenzione alla condizione i < ADET: se usi minore o uguale, il ciclo gira una volta di troppo e legge la memoria fuori dall'array.

C++ (Arduino IDE)
1int sicakliklar[] = {22, 24, 19, 27, 25, 21, 23};   // bir haftalık ölçüm / one week of readings
2const int ADET = sizeof(sicakliklar) / sizeof(sicakliklar[0]);   // 7
3
4void setup() {
5  Serial.begin(9600);
6  long toplam = 0;                       // taşmasın diye long / long to avoid overflow
7  int enKucuk = sicakliklar[0];
8  int enBuyuk = sicakliklar[0];
9
10  for (int i = 0; i < ADET; i++) {       // 0'dan 6'ya / from 0 to 6
11    toplam += sicakliklar[i];
12    if (sicakliklar[i] < enKucuk) enKucuk = sicakliklar[i];
13    if (sicakliklar[i] > enBuyuk) enBuyuk = sicakliklar[i];
14  }
15
16  Serial.print("Ortalama / Average: ");
17  Serial.println((float)toplam / ADET);  // 23.00
18  Serial.print("En dusuk / Min: ");
19  Serial.println(enKucuk);               // 19
20  Serial.print("En yuksek / Max: ");
21  Serial.println(enBuyuk);               // 27
22}
23
24void loop() {
25}

Esempio 1: gestire i pin dei LED con un array

L'uso più classico degli array in Arduino è gestire più LED. Senza array, per controllare sei LED devi scrivere sei pinMode separati e righe digitalWrite distinte per ogni passo; con l'array basta un solo ciclo. Collega la gamba lunga (anodo) di ogni LED a un pin digitale e la gamba corta a GND tramite una resistenza da 220 Ω. Se vuoi calcolare tu il valore della resistenza, usa lo strumento calcolatore della resistenza per LED.

LED (indice nell'array)Arduino UnoESP32Raspberry Pi Pico
LED 1 (ledPinleri[0])D2GPIO 13GP14
LED 2 (ledPinleri[1])D3GPIO 14GP13
LED 3 (ledPinleri[2])D4GPIO 27GP12
LED 4 (ledPinleri[3])D5GPIO 26GP11
LED 5 (ledPinleri[4])D6GPIO 25GP10
LED 6 (ledPinleri[5])D7GPIO 33GP9
Catodo (gamba corta)GND tramite 220 ΩGND tramite 220 ΩGND tramite 220 Ω
  1. Inserisci i LED in ordine sulla breadboard; collega le gambe corte (catodo) alla linea GND tramite resistenze da 220 Ω.
  2. Collega le gambe lunghe ai pin 2–7 di Arduino nell'ordine della tabella.
  3. Scrivi i numeri dei pin nell'array ledPinleri nell'ordine fisico dei LED; l'ordine nell'array determina la direzione di scorrimento della luce.
  4. In setup() imposta tutti i pin come OUTPUT con un solo ciclo for.
  5. In loop() crea l'effetto Knight Rider con due cicli, uno in avanti e uno all'indietro, e carica il codice.
C++ (Arduino IDE)
1const byte ledPinleri[] = {2, 3, 4, 5, 6, 7};   // LED'lerin fiziksel sırası / physical order of LEDs
2const byte LED_SAYISI = sizeof(ledPinleri) / sizeof(ledPinleri[0]);   // 6
3const int BEKLEME = 100;                         // adım süresi ms / step time in ms
4
5void setup() {
6  for (byte i = 0; i < LED_SAYISI; i++) {
7    pinMode(ledPinleri[i], OUTPUT);              // tüm pinler çıkış / all pins as output
8  }
9}
10
11void loop() {
12  // ileri: 0'dan 5'e / forward: 0 to 5
13  for (byte i = 0; i < LED_SAYISI; i++) {
14    digitalWrite(ledPinleri[i], HIGH);
15    delay(BEKLEME);
16    digitalWrite(ledPinleri[i], LOW);
17  }
18  // geri: 4'ten 1'e, uçlar tekrar yanmaz / backward: 4 to 1, ends are not repeated
19  for (int i = LED_SAYISI - 2; i > 0; i--) {
20    digitalWrite(ledPinleri[i], HIGH);
21    delay(BEKLEME);
22    digitalWrite(ledPinleri[i], LOW);
23  }
24}

Il ciclo in avanti accende e spegne ogni LED per 100 ms, da 0 a 5. Il ciclo all'indietro parte da 4 e si ferma a 1; non riaccendendo i LED alle estremità, la luce torna indietro in modo fluido senza pause agli estremi. Nel ciclo all'indietro abbiamo usato int come contatore perché byte è senza segno e non può scendere sotto 0; se usi byte in un ciclo che aspetta un contatore minore di 0, dopo lo 0 si va a 255 e il ciclo non finisce mai. Per cambiare la sequenza dell'effetto basta scambiare di posto i numeri nell'array senza toccare il resto del codice. Per altri effetti scritti con la stessa logica, guarda l'articolo Knight Rider e LED a scorrimento.

Esempio 2: media dei sensori con un array (media mobile)

I valori letti da sensori analogici come potenziometro, LDR o sensore di umidità del terreno oscillano continuamente di qualche unità. Il modo più semplice per ridurre questo rumore è fare la media delle ultime N letture. Tieni le ultime 10 letture in un array e, a ogni nuova misura, togli il valore più vecchio dalla somma e aggiungi quello nuovo. Poiché arrivati alla fine dell'array riporti l'indice a 0, questa struttura si chiama buffer circolare (ring buffer). Aggiornare la somma con il metodo toglie-aggiungi, invece di ricalcolarla ogni volta da capo, mantiene l'operazione veloce anche se la finestra arriva a 100 elementi. Nelle prime 10 letture l'array non è ancora pieno, quindi la media sale da zero e si assesta sul valore reale dopo circa mezzo secondo. Collega il pin di segnale del sensore ad A0 (per esempio il pin centrale del potenziometro) e osserva il risultato nel Serial Plotter come due linee:

C++ (Arduino IDE)
1const byte PENCERE = 10;            // ortalama alınacak okuma sayısı / number of readings to average
2int okumalar[PENCERE];              // global dizi sıfırla başlar / global array starts at zero
3byte indeks = 0;                    // sıradaki hücre / next slot
4long toplam = 0;                    // taşmasın diye long / long to avoid overflow
5
6void setup() {
7  Serial.begin(9600);
8}
9
10void loop() {
11  int yeni = analogRead(A0);
12  toplam -= okumalar[indeks];       // en eski okumayı çıkar / remove the oldest reading
13  okumalar[indeks] = yeni;          // yerine yenisini yaz / store the new one
14  toplam += yeni;                   // toplama ekle / add to the total
15  indeks++;
16  if (indeks >= PENCERE) {          // sona gelince başa dön / wrap around at the end
17    indeks = 0;
18  }
19  int ortalama = toplam / PENCERE;
20  Serial.print(yeni);               // ham değer / raw value
21  Serial.print(" ");
22  Serial.println(ortalama);         // yumuşatılmış değer / smoothed value
23  delay(50);
24}
Su Uno un int può contenere al massimo 32 767. La somma di 64 letture analogiche fino a 1023 è 65 472 e una variabile int andrebbe in overflow tornando a un numero negativo. Nei calcoli di somme e medie usa sempre long. Più la finestra è grande, più l'uscita è liscia ma più lentamente reagisce ai cambiamenti; 10 letture a intervalli di 50 ms, cioè una finestra di mezzo secondo, sono un buon punto di partenza per la maggior parte dei sensori. Per metodi più avanzati leggi l'articolo sul filtraggio dei dati dei sensori.

Esempio 3: salvare le note di una melodia in un array

Una melodia è in realtà fatta di due elenchi: quale nota suonare (la frequenza) e quanto deve durare. Queste due informazioni le conservi in due array paralleli della stessa lunghezza: melodi[i] e sureler[i] appartengono sempre alla stessa nota. Collega la gamba positiva del buzzer passivo al pin 8 e quella negativa a GND. Il codice seguente suona le prime due strofe di "Twinkle Twinkle Little Star" e separa i suoni lasciando tra le note una pausa pari a un terzo della durata. Per aggiungere un nuovo brano basta riempire i due array; il ciclo di riproduzione non cambia mai. Se i due array hanno un numero diverso di elementi, il ciclo esce dai limiti di quello più corto, quindi scrivere lo stesso numero di elementi su ogni riga evita l'errore. Se le melodie lunghe iniziano a riempire la RAM dell'Uno, puoi spostare gli array nella memoria flash con PROGMEM. Se non conosci la differenza tra buzzer attivo e passivo, leggi l'articolo che cos'è un buzzer.

C++ (Arduino IDE)
1#define NOTA_DO  262   // Hz
2#define NOTA_RE  294
3#define NOTA_MI  330
4#define NOTA_FA  349
5#define NOTA_SOL 392
6#define NOTA_LA  440
7
8const byte BUZZER_PIN = 8;   // pasif buzzer / passive buzzer
9
10// notalar ve süreler aynı sırada / notes and durations in the same order
11const int melodi[] = {NOTA_DO, NOTA_DO, NOTA_SOL, NOTA_SOL, NOTA_LA, NOTA_LA, NOTA_SOL,
12                      NOTA_FA, NOTA_FA, NOTA_MI, NOTA_MI, NOTA_RE, NOTA_RE, NOTA_DO};
13const int sureler[] = {400, 400, 400, 400, 400, 400, 800,
14                       400, 400, 400, 400, 400, 400, 800};
15const int NOTA_SAYISI = sizeof(melodi) / sizeof(melodi[0]);   // 14
16
17void setup() {
18  for (int i = 0; i < NOTA_SAYISI; i++) {
19    tone(BUZZER_PIN, melodi[i], sureler[i]);   // notayı çal / play the note
20    delay(sureler[i] + sureler[i] / 3);         // nota + kısa boşluk / note + short gap
21  }
22  noTone(BUZZER_PIN);
23}
24
25void loop() {
26}

Array multidimensionali: salvare dati come in una tabella

Un array bidimensionale è una tabella fatta di righe e colonne. int tablo[4][3] è un array di 12 elementi con 4 righe e 3 colonne; raggiungi l'elemento con tablo[riga][colonna] ed entrambi gli indici partono da 0. In memoria le righe sono una dopo l'altra, quindi su Uno questa tabella occupa 4 × 3 × 2 = 24 byte. I disegni delle matrici LED 8x8, le mappe dei tasti di un keypad e le tabelle di stato sono usi tipici degli array bidimensionali. Nell'esempio seguente abbiamo scritto ogni stato del semaforo su una riga: le prime tre colonne indicano se il LED rosso, giallo e verde deve accendersi, la quarta quanti millisecondi dura quello stato. Puoi collegare i LED ai primi tre pin della tabella dei pin (D2 rosso, D3 giallo, D4 verde). Il numero di righe lo abbiamo calcolato con sizeof(durumlar) / sizeof(durumlar[0]); qui sizeof(durumlar[0]) dà la dimensione di un'intera riga. Per aggiungere un nuovo stato al semaforo basta scrivere una riga nella tabella, mentre il codice in loop() resta uguale. Questo approccio, che separa la logica del programma dai dati, ti servirà anche quando costruirai una macchina a stati.

C++ (Arduino IDE)
1const byte trafikPinleri[3] = {2, 3, 4};   // kırmızı, sarı, yeşil / red, yellow, green
2
3// her satır bir durum: {kırmızı, sarı, yeşil, süre ms} / each row: {red, yellow, green, time ms}
4const unsigned int durumlar[4][4] = {
5  {1, 0, 0, 5000},   // kırmızı / red
6  {1, 1, 0, 1500},   // kırmızı + sarı / red + yellow
7  {0, 0, 1, 5000},   // yeşil / green
8  {0, 1, 0, 1500}    // sarı / yellow
9};
10const byte DURUM_SAYISI = sizeof(durumlar) / sizeof(durumlar[0]);   // 4 satır / 4 rows
11
12void setup() {
13  for (byte i = 0; i < 3; i++) {
14    pinMode(trafikPinleri[i], OUTPUT);
15  }
16}
17
18void loop() {
19  for (byte d = 0; d < DURUM_SAYISI; d++) {          // satırları gez / walk the rows
20    for (byte led = 0; led < 3; led++) {              // sütunları gez / walk the columns
21      digitalWrite(trafikPinleri[led], durumlar[d][led] ? HIGH : LOW);
22    }
23    delay(durumlar[d][3]);                            // durumun süresi / duration of the state
24  }
25}

Array su ESP32 e Raspberry Pi Pico

Su ESP32 gli array si scrivono con la stessa sintassi C++ dell'Arduino Uno e gli esempi qui sopra si compilano senza modifiche; devi solo adattare i numeri dei pin. Nell'esempio dei LED basta cambiare la riga dell'array in {13, 14, 27, 26, 25, 33}; non scrivere nell'array i pin 6–11, perché sono riservati alla memoria flash interna. Su ESP32 un int è di 4 byte e la RAM a disposizione dei programmi supera i 300 KB; un array di 10 000 misure, che sull'Uno non ci starebbe, qui trova posto senza problemi. Poiché le letture analogiche dell'ESP32 vanno da 0 a 4095, nell'esempio della media mobile i numeri risultano più grandi, ma la logica è la stessa. Se usi Raspberry Pi Pico con MicroPython, al posto degli array usi le liste: la dimensione non è fissa, puoi aggiungere elementi con append() e conoscere la lunghezza con len(). Nelle liste è valido anche l'indice negativo; ledler[-1] restituisce l'ultimo elemento. Mettere direttamente oggetti Pin dentro la lista semplifica molto il codice:

MicroPython
1from machine import Pin
2import time
3
4led_pinleri = [14, 13, 12, 11, 10, 9]            # GP14 -> GP9 sırası / order
5ledler = [Pin(p, Pin.OUT) for p in led_pinleri]  # Pin nesnelerinden liste / list of Pin objects
6print("LED sayisi / LED count:", len(ledler))
7
8while True:
9    for led in ledler:                           # ileri / forward
10        led.on()
11        time.sleep_ms(100)
12        led.off()
13    for i in range(len(ledler) - 2, 0, -1):      # geri, uçlar hariç / backward, ends skipped
14        ledler[i].on()
15        time.sleep_ms(100)
16        ledler[i].off()

Errori di overflow e errori comuni con gli array

ErroreSintomoSoluzione
Usare minore o uguale nella condizione del cicloAll'ultimo giro si legge o si scrive fuori dall'array; valori senza senso, riavviiUsa la condizione i < ADET
Far partire l'indice da 1Il primo elemento viene saltato e all'ultimo giro c'è overflowGli indici vanno da 0 a N-1
Scambiare sizeof(array) per il numero di elementiIn un array di int il ciclo gira il doppio su Uno e il quadruplo su ESP32Usa sizeof(array) / sizeof(array[0])
Usare sizeof dentro una funzioneL'array arriva alla funzione come indirizzo; sizeof restituisce 2 o 4Passa il numero di elementi come parametro separato
Tenere la somma in una variabile intSu Uno, superati 32 767 la media diventa negativaUsa long per la somma
Non inizializzare un array dentro una funzioneUn array locale ha valori iniziali casualiAzzera con int a[10] = {0};
Assegnare un array a un altro con =Errore di compilazione: invalid array assignmentCopia con un ciclo for o con memcpy
Dichiarare un array troppo grande su UnoAvviso di poca memoria, blocchi e riavviiUsa byte e sposta le tabelle costanti in PROGMEM
Le tabelle che non cambiano (note delle melodie, disegni di caratteri, valori di calibrazione) su Uno vengono copiate nella RAM all'avvio anche se le scrivi const. Sposta gli array costanti grandi nella memoria flash con la parola chiave PROGMEM e leggili con funzioni come pgm_read_word(); così sfrutti i 32 KB di flash e proteggi i 2 KB di RAM. Su ESP32 e Pico gli array const restano comunque in flash. Se sospetti che la memoria sia piena, leggi l'articolo Arduino memoria insufficiente.

Idee di progetti da fare con gli array

  • Pacchetto di effetti LED: tieni i pattern in un array bidimensionale e riproduci ogni riga come un fotogramma di animazione; gestisci gli effetti Knight Rider e LED a scorrimento con un solo ciclo.
  • Gioco di memoria Simon: salva in un array la sequenza di colori generata a caso e confrontala con i pulsanti premuti dal giocatore; per idee simili guarda progetti di giochi con Arduino.
  • Serratura a codice: tieni il codice giusto in un array di char, scrivi i tasti premuti sul keypad in un secondo array e confrontali elemento per elemento.
  • Animazioni su matrice LED: salva i disegni 8x8 in array di byte e mostrali su una matrice LED MAX7219.
  • Registratore di dati giornaliero: tieni le temperature orarie in un array di 24 elementi e calcola minimo, massimo e media della giornata; come sensore puoi usare un DHT11.
  • Carillon: conserva alcune canzoni in array separati e passa da una all'altra con un pulsante.

Gli array sono il mattone fondamentale che entra in gioco appena in Arduino hai a che fare con più di qualche variabile: elenchi di pin, storico delle misure, melodie e disegni si gestiscono tutti con gli array. Per scoprire la differenza tra array di char e classe String quando lavori con i testi, continua con l'articolo Uso di String in Arduino. Nell'app BlueGrays puoi esaminare passo passo i progetti con LED a scorrimento, Knight Rider, semaforo e Inno nazionale con buzzer, con codice pronto scritto con gli array e schemi dei circuiti.

Domande frequenti

Come si trova il numero di elementi di un array in Arduino?

In Arduino non esiste una funzione length() per gli array. Il numero di elementi si ricava con la formula sizeof(array) / sizeof(array[0]): la prima parte dà i byte totali dell'array, la seconda la dimensione di un singolo elemento. Questa formula funziona correttamente solo dove l'array è dichiarato; in un array passato a una funzione restituisce la dimensione del puntatore.

In Arduino l'indice di un array parte da 0 o da 1?

Nel linguaggio di Arduino, basato su C e C++, l'indice di un array parte sempre da 0. In un array di 10 elementi il primo è array[0] e l'ultimo array[9]. Accedere ad array[10] non dà errore di compilazione, ma corrompe la memoria fuori dall'array.

In Arduino si può cambiare la dimensione di un array in un secondo momento?

No, la dimensione di un normale array è stabilita in fase di compilazione e non può crescere mentre il programma gira. La soluzione pratica è dichiarare un array della dimensione massima che potrebbe servirti e tenere in una variabile contatore separata quanti elementi sono pieni. Allocare memoria dinamica con malloc o new è possibile, ma su Uno con 2 KB di RAM è sconsigliato perché causa frammentazione della memoria.

Come si dichiara un array di stringhe (testi) in Arduino?

Per salvare più testi si usa un array di puntatori nella forma const char* renkler[] = {"Rosso", "Giallo", "Verde"}; e con renkler[1] si raggiunge il testo "Giallo". Un singolo testo invece è un array di caratteri come char isim[] = "Arduino"; e alla fine contiene un carattere invisibile '\0'. Si possono scrivere anche array di oggetti String, ma su Uno consumano la RAM più in fretta.

Quanti elementi può contenere al massimo un array su Arduino Uno?

Il limite lo decide la RAM: Uno ha 2048 byte di RAM in tutto e una parte è usata da Serial e dalle altre variabili. In pratica un array da circa 1500 byte, cioè 1500 byte o 750 int, è vicino al limite. Se sposti le tabelle costanti nella flash con PROGMEM puoi salvare molti più dati; su ESP32 e Pico ci sono centinaia di KB di RAM.

Come si copia un array in un altro in Arduino?

In C++ non si può copiare un array scrivendo destinazione = sorgente; il compilatore dà errore. Puoi copiare gli elementi uno per uno con un ciclo for oppure usare il comando memcpy(destinazione, sorgente, sizeof(sorgente));. Assicurati che i due array abbiano lo stesso tipo e la stessa dimensione; se la destinazione è più piccola, anche memcpy causa overflow.

Vedi tutti i progetti
Semaforo
AR-3Principiante

Semaforo

Una copia in miniatura del semaforo che vedi ogni giorno per strada. Il rosso resta acceso due secondi, il giallo brilla per un attimo, il verde resta due secondi, poi si torna al rosso passando di…

4.8(137)
440
LED in sequenza
AR-5Intermedio

LED in sequenza

Luci che si accendono una dopo l'altra, come se corressero. L'Arduino accende sei LED uno alla volta; ognuno brilla per un istante e si spegne, così la luce percorre la fila dall'inizio alla fine e…

4.6(87)
218
Effetto Supercar con LED
AR-6Intermedio

Effetto Supercar con LED

La classica luce che va e viene: un punto luminoso scorre da un capo all'altro di sei LED e poi torna indietro.

4.8(107)
214
LED in sequenza a velocità regolabile
AR-7Intermedio

LED in sequenza a velocità regolabile

Sei LED si accendono uno dopo l'altro e la luce sembra correre da un'estremità all'altra.

4.6(72)
148
Effetto Supercar a velocità regolabile
AR-8Intermedio

Effetto Supercar a velocità regolabile

Una luce corre su sei LED da un'estremità all'altra, torna indietro e riparte. Girando la manopola del potenziometro cambi subito la velocità della corsa: con la manopola da un lato la luce quasi…

4.5(60)
124
Inno nazionale turco con cicalino
AR-15Intermedio

Inno nazionale turco con cicalino

Premi il pulsante e un piccolo buzzer comincia a suonare l'inno nazionale turco, nota dopo nota.

4.8(114)
235
LED Sequenziale ESP32 (Knight Rider)
ES-6Principiante

LED Sequenziale ESP32 (Knight Rider)

6 LED che si muovono sequenzialmente da sinistra a destra e da destra a sinistra (stile Knight Rider). Esempio di base di utilizzo del ciclo for e degli array. Insegna la logica del cambio di direzione.

4.5(19)
33
Raspberry Pi Pico LED Sequenziale (6 LED)
PI-7Principiante

Raspberry Pi Pico LED Sequenziale (6 LED)

La classica animazione delle "luci che camminano" con il Pico, in versione a 6 LED! Sei LED si accendono uno dopo l'altro da sinistra a destra, come se la luce camminasse lungo la fila. Impari le liste Python (LED_PINS = [14, 13, 12, 11, 10, 9]), la list comprehension, il controllo dei pin con un ciclo for ed enumerate(). Sei LED sui pin GP9-GP14, ognuno con una resistenza di limitazione da 220Ω.

5.0(1)
9