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.

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 dato | Dimensione elemento (Uno) | Dimensione elemento (ESP32 / Pico, C++) | Array da 100 elementi (Uno) |
|---|---|---|---|
| byte / uint8_t | 1 byte | 1 byte | 100 byte |
| char | 1 byte | 1 byte | 100 byte |
| int | 2 byte | 4 byte | 200 byte |
| unsigned int | 2 byte | 4 byte | 200 byte |
| long | 4 byte | 4 byte | 400 byte |
| float | 4 byte | 4 byte | 400 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:
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}| Dichiarazione | Significato |
|---|---|
| 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 |
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.
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 Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| LED 1 (ledPinleri[0]) | D2 | GPIO 13 | GP14 |
| LED 2 (ledPinleri[1]) | D3 | GPIO 14 | GP13 |
| LED 3 (ledPinleri[2]) | D4 | GPIO 27 | GP12 |
| LED 4 (ledPinleri[3]) | D5 | GPIO 26 | GP11 |
| LED 5 (ledPinleri[4]) | D6 | GPIO 25 | GP10 |
| LED 6 (ledPinleri[5]) | D7 | GPIO 33 | GP9 |
| Catodo (gamba corta) | GND tramite 220 Ω | GND tramite 220 Ω | GND tramite 220 Ω |
- Inserisci i LED in ordine sulla breadboard; collega le gambe corte (catodo) alla linea GND tramite resistenze da 220 Ω.
- Collega le gambe lunghe ai pin 2–7 di Arduino nell'ordine della tabella.
- Scrivi i numeri dei pin nell'array ledPinleri nell'ordine fisico dei LED; l'ordine nell'array determina la direzione di scorrimento della luce.
- In setup() imposta tutti i pin come OUTPUT con un solo ciclo for.
- In loop() crea l'effetto Knight Rider con due cicli, uno in avanti e uno all'indietro, e carica il codice.
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:
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}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.
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.
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:
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
| Errore | Sintomo | Soluzione |
|---|---|---|
| Usare minore o uguale nella condizione del ciclo | All'ultimo giro si legge o si scrive fuori dall'array; valori senza senso, riavvii | Usa la condizione i < ADET |
| Far partire l'indice da 1 | Il primo elemento viene saltato e all'ultimo giro c'è overflow | Gli indici vanno da 0 a N-1 |
| Scambiare sizeof(array) per il numero di elementi | In un array di int il ciclo gira il doppio su Uno e il quadruplo su ESP32 | Usa sizeof(array) / sizeof(array[0]) |
| Usare sizeof dentro una funzione | L'array arriva alla funzione come indirizzo; sizeof restituisce 2 o 4 | Passa il numero di elementi come parametro separato |
| Tenere la somma in una variabile int | Su Uno, superati 32 767 la media diventa negativa | Usa long per la somma |
| Non inizializzare un array dentro una funzione | Un array locale ha valori iniziali casuali | Azzera con int a[10] = {0}; |
| Assegnare un array a un altro con = | Errore di compilazione: invalid array assignment | Copia con un ciclo for o con memcpy |
| Dichiarare un array troppo grande su Uno | Avviso di poca memoria, blocchi e riavvii | Usa byte e sposta le tabelle costanti in PROGMEM |
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.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
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…

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…

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.

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

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…

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

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.

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Ω.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

