Progetti Arduino Vacanze Invernali: Piano di 14 Giorni
Progetti Arduino per le vacanze invernali: un piano di 14 giorni con un progetto al giorno, tre percorsi (Uno, ESP32, Pico), materiali e progetto finale.
Il modo migliore per affrontare i progetti Arduino delle vacanze invernali non è fare prove a caso, ma dedicare le due settimane a piccoli progetti, ognuno costruito su quello del giorno prima. In questa guida trovi un piano pronto: con uno starter kit e 1–2 ore al giorno, in 14 giorni passi dall'accendere un LED al leggere sensori, dallo scrivere su uno schermo al comandare un motore. Per ogni giorno trovi il progetto, i materiali e il link all'articolo che approfondisce l'argomento; alla fine avrai un progetto finale che unisce tutto quello che hai imparato.
Il piano si adatta a tre percorsi: Arduino Uno se parti da zero, ESP32 se hai già le basi e vuoi collegare il progetto a internet, Raspberry Pi Pico se vuoi imparare Python. Gli argomenti dei giorni sono gli stessi nei tre percorsi; cambiano solo la scheda, i numeri dei pin e il linguaggio. Se non hai ancora una scheda, puoi fare i primi giorni nel simulatore Wokwi o Tinkercad e passare al circuito reale quando arriva il materiale.
Prima di iniziare: quali materiali ti servono?
Quasi tutto l'elenco qui sotto è presente nei normali starter kit in commercio. Se al tuo kit manca qualcosa, basta cambiare l'ordine dei giorni: per esempio, se non hai il servo, puoi sostituire il giorno 13 con un progetto di melodie con il buzzer. Se non sai quale kit scegliere, l'articolo sullo starter kit Arduino confronta nel dettaglio i contenuti.
| Materiale | Quantità | Giorni in cui serve |
|---|---|---|
| Arduino Uno, ESP32 o Raspberry Pi Pico + cavo USB | 1 | Ogni giorno |
| Breadboard e cavi jumper maschio-maschio | 1 + 30 | Ogni giorno |
| LED (rosso, giallo, verde) | 6–8 | 1, 2, 3, 6, 7, 9, 11 |
| Resistenza da 220 Ω | 8 | 1, 2, 3, 6, 7, 11 |
| Resistenza da 10 kΩ | 2 | 7 |
| Resistenza da 1 kΩ (partitore di tensione per ESP32 e Pico) | 3 | 10, 11 |
| Pulsante | 2 | 4, 7, 9 |
| Potenziometro da 10 kΩ | 1 | 5, 13 |
| LED RGB | 1 | 6 |
| LDR (fotoresistenza) | 1 | 7 |
| Buzzer passivo | 1 | 8, 11 |
| Sensore di distanza HC-SR04 | 1 | 10, 11 |
| Sensore di temperatura e umidità DHT11 | 1 | 12 |
| Display LCD 16x2 I2C | 1 | 12, 14 |
| Servomotore SG90 | 1 | 13, 14 |
Quale percorso scegliere: Uno, ESP32 o Pico?
Tutte e tre le schede possono completare l'intero piano, ma ognuna offre un'esperienza diversa. L'Uno lavora a 5 V, quindi si collega direttamente a tutti i moduli del kit, e la maggior parte degli esempi online è scritta per lui: se fai i primi passi con l'elettronica, è il percorso più semplice da debuggare. L'ESP32 si programma con lo stesso linguaggio Arduino, ma con il processore dual-core a 240 MHz, il Wi-Fi e il Bluetooth puoi controllare il progetto finale dal telefono; in cambio, ricorda che i suoi pin sono a 3,3 V. Il Pico ti permette di scrivere codice in MicroPython e vederlo girare appena lo salvi: se a scuola fai Python, porti subito le tue conoscenze sull'hardware. Se sei indeciso, dai un'occhiata al confronto Arduino o ESP32.
| Percorso | Per chi è | Linguaggio ed editor | Punto di forza | A cosa fare attenzione |
|---|---|---|---|---|
| Arduino Uno | Chi inizia con l'elettronica | Arduino C++, Arduino IDE | Pin a 5 V, compatibile con tutti i moduli del kit, il maggior numero di esempi | Niente Wi-Fi, solo 2 KB di RAM |
| ESP32 | Chi conosce le basi e vuole collegarsi a internet | Arduino C++, Arduino IDE (pacchetto schede ESP32) | Wi-Fi e Bluetooth, dual-core a 240 MHz, ADC a 12 bit | Pin a 3,3 V: con sensori a 5 V serve un partitore di tensione |
| Raspberry Pi Pico | Chi vuole imparare Python | MicroPython, Thonny | Esecuzione immediata senza compilare, dual-core a 133 MHz, prezzo basso | Pin a 3,3 V, il Pico classico non ha connessione wireless (il Pico W sì) |
Organizzazione quotidiana: la regola di 1–2 ore
- Primi 15 minuti di lettura: leggi l'articolo del giorno e disegna su carta lo schema del circuito e la tabella dei pin.
- 30–45 minuti di montaggio e codice: costruisci il circuito con il cavo USB scollegato, ricontrolla i collegamenti e solo dopo carica il codice.
- 20 minuti di modifiche: quando il codice funziona, cambia almeno una cosa da solo: il tempo, il pin, la soglia o il numero di LED. È qui che si impara davvero.
- 10 minuti di appunti: scrivi su un quaderno cosa hai fatto, dove ti sei bloccato e come hai risolto; nel progetto finale questi appunti ti faranno risparmiare molto tempo.
- Giorni flessibili: se ti ammali o un progetto si allunga, puoi usare i giorni 7 e 14 anche come giorni di recupero.
Prima settimana: le basi (giorni 1–7)
L'obiettivo della prima settimana è imparare con le mani quattro concetti fondamentali: uscita digitale, ingresso digitale, lettura analogica e PWM. Ogni giorno si aggiungono in media un comando e un componente nuovi; alla fine del giorno 7 userai senza problemi pinMode, digitalWrite, digitalRead, analogRead, analogWrite e Serial.println.
- Giorno 1 – Accendere un LED: fai funzionare Blink con il LED integrato, poi collega un LED esterno al D13 sulla breadboard con una resistenza da 220 Ω e cambia il tempo di lampeggio. Materiale: scheda, breadboard, 1 LED, 1 resistenza da 220 Ω. Leggi: Come usare la breadboard, Calcolo della resistenza per LED.
- Giorno 2 – Semaforo: collega LED rosso, giallo e verde ai pin D10, D9 e D8 e imita con delay la sequenza luminosa di un vero incrocio. Materiale: 3 LED, 3 resistenze da 220 Ω. Leggi: Semaforo con Arduino.
- Giorno 3 – LED sequenziali e Knight Rider: impara a usare un ciclo for e un array di pin per accendere 6 LED in sequenza. Materiale: 6 LED, 6 resistenze da 220 Ω. Leggi: Knight Rider e LED sequenziali, Array in Arduino.
- Giorno 4 – LED con pulsante: prima un LED che resta acceso finché tieni premuto, poi uno che cambia stato a ogni pressione (toggle); qui imparerai INPUT_PULLUP e il debounce. Materiale: 1 pulsante, 1 LED, 1 resistenza da 220 Ω. Leggi: Come collegare un pulsante ad Arduino, Resistenze pull-up e pull-down.
- Giorno 5 – Potenziometro e Monitor seriale: leggi con analogRead un valore da 0 a 1023, osservalo nel Monitor seriale e con map trasformalo nella velocità di lampeggio del LED. Materiale: potenziometro da 10 kΩ, 1 LED. Leggi: Cos'è un potenziometro, Usare il Monitor seriale, La funzione map.
- Giorno 6 – PWM e LED RGB: con analogWrite fai accendere e spegnere lentamente un LED (effetto respiro), poi mescola i tre canali del LED RGB per creare il tuo colore. Materiale: 1 LED RGB, 3 resistenze da 220 Ω. Leggi: Cos'è il PWM, Usare il LED RGB.
- Giorno 7 – Luce notturna con LDR e ripasso della settimana: collega l'LDR con una resistenza da 10 kΩ come partitore di tensione e accendi il LED quando l'ambiente diventa buio. Nella seconda metà della giornata costruisci il semaforo con pulsante pedonale qui sotto. Materiale: LDR, resistenza da 10 kΩ, 3 LED, pulsante. Leggi: Sensore di luce LDR, Partitore di tensione.
Il progetto di chiusura della prima settimana unisce in un solo circuito quello che hai imparato nei giorni 2, 4 e 5: un semaforo per i veicoli che resta sempre verde; quando un pedone preme il pulsante passa al giallo, poi al rosso, e dopo cinque secondi torna al verde. Il pulsante va collegato tra D2 e GND: grazie alla resistenza pull-up interna non serve nessuna resistenza esterna e, quando lo premi, il pin legge LOW.
1// Yaya butonlu trafik lambası / Pedestrian button traffic light
2const int RED_PIN = 10; // kırmızı LED / red LED
3const int YELLOW_PIN = 9; // sarı LED / yellow LED
4const int GREEN_PIN = 8; // yeşil LED / green LED
5const int BUTTON_PIN = 2; // buton, diğer ucu GND / button, other leg to GND
6
7void setup() {
8 pinMode(RED_PIN, OUTPUT);
9 pinMode(YELLOW_PIN, OUTPUT);
10 pinMode(GREEN_PIN, OUTPUT);
11 pinMode(BUTTON_PIN, INPUT_PULLUP); // basılınca LOW okunur / reads LOW when pressed
12 digitalWrite(GREEN_PIN, HIGH); // araçlara yeşil / green for cars
13 Serial.begin(9600);
14}
15
16void loop() {
17 if (digitalRead(BUTTON_PIN) == LOW) {
18 Serial.println("Yaya istegi / Pedestrian request");
19 delay(1000);
20 digitalWrite(GREEN_PIN, LOW);
21 digitalWrite(YELLOW_PIN, HIGH); // sarı: yavaşla / yellow: slow down
22 delay(2000);
23 digitalWrite(YELLOW_PIN, LOW);
24 digitalWrite(RED_PIN, HIGH); // araçlar durur, yaya geçer / cars stop, pedestrians cross
25 delay(5000);
26 digitalWrite(YELLOW_PIN, HIGH); // kırmızı + sarı: hazırlan / red + yellow: get ready
27 delay(1500);
28 digitalWrite(RED_PIN, LOW);
29 digitalWrite(YELLOW_PIN, LOW);
30 digitalWrite(GREEN_PIN, HIGH);
31 delay(3000); // art arda basmayı engelle / ignore repeated presses
32 }
33}Il delay(3000) finale nel codice impedisce che il semaforo torni subito al rosso se un pedone preme il pulsante più volte di seguito; anche i semafori veri usano un tempo di attesa simile. Come modifica personale, prova a rendere regolabile con un potenziometro la durata del rosso, oppure a far emettere brevi bip al buzzer mentre il rosso è acceso. Il punto debole di questo codice è che, mentre delay è in corso, la scheda non può fare nient'altro: al giorno 9 risolverai il problema con millis.
Seconda settimana: suono, tempi, sensori e display (giorni 8–14)
Nella seconda settimana la scheda inizia a misurare il mondo esterno e a mostrare i risultati. In questi giorni installerai per la prima volta una libreria, misurerai il tempo con precisione al microsecondo e scriverai su uno schermo. Poiché i progetti sono un po' più lunghi, se serve non esitare a dividere un giorno in due: il piano non è una gara, ma un modo per prendere un'abitudine.
- Giorno 8 – Buzzer e melodia: suona le note con il comando tone(pin, frequenza, durata); 262 Hz è il do, 294 Hz il re, 330 Hz il mi. Il buzzer attivo emette un solo suono fisso, per le melodie serve un buzzer passivo. Materiale: buzzer passivo. Leggi: Cos'è un buzzer.
- Giorno 9 – millis al posto di delay: riesci a leggere il pulsante mentre un LED lampeggia una volta al secondo. È la base del progetto finale: ogni progetto che fa più cose insieme usa millis o una macchina a stati. Materiale: 2 LED, pulsante. Leggi: Differenza tra millis e delay, Macchina a stati con Arduino.
- Giorno 10 – Misurare la distanza con l'HC-SR04: misura il tempo di andata e ritorno dell'onda sonora; poiché il suono viaggia nell'aria a circa 343 m/s, dividere il tempo in microsecondi per 58 dà la distanza in centimetri. Materiale: HC-SR04. Leggi: Sensore di distanza HC-SR04.
- Giorno 11 – Sensore di parcheggio: unisci i giorni 8 e 10: più l'ostacolo si avvicina, più si accorcia l'intervallo tra i bip del buzzer e il LED lampeggia a ogni bip. Materiale: HC-SR04, buzzer passivo, LED, resistenza da 220 Ω. Leggi: Sistema di parcheggio con Arduino.
- Giorno 12 – DHT11 e LCD I2C: installa la tua prima libreria e scrivi temperatura e umidità su un LCD 16x2. Grazie all'I2C lo schermo si collega con soli 4 fili; l'indirizzo della maggior parte dei moduli è 0x27 o 0x3F. Materiale: DHT11, LCD 16x2 I2C. Leggi: Aggiungere una libreria in Arduino, Sensore DHT11, Display LCD I2C.
- Giorno 13 – Servomotore e piano del progetto finale: con la libreria Servo fai ruotare l'SG90 da 0 a 180 gradi e controlla l'angolo con il potenziometro. Nella seconda metà della giornata scegli il progetto finale e metti il piano su carta seguendo i passi qui sotto. Materiale: servo SG90, potenziometro. Leggi: Cos'è un servomotore, Il servo trema.
- Giorno 14 – Progetto finale e presentazione: unisci i codici dei giorni precedenti, metti il circuito in una scatola o in un modellino di cartone, gira un breve video e presenta il progetto a famiglia o compagni di classe. Materiale: l'elenco componenti del progetto finale. Leggi: Presentare un progetto a una fiera della scienza.
Il codice qui sotto è il sensore di parcheggio del giorno 11 e riutilizza in una funzione il metodo di misura della distanza imparato al giorno 10. Il timeout di 30 000 microsecondi in pulseIn corrisponde a circa 5 metri; se il sensore non riceve l'eco, il codice restituisce -1 invece di aspettare all'infinito. La funzione map converte l'intervallo 0–50 cm in un'attesa di 50–500 ms, così i bip diventano più frequenti man mano che l'ostacolo si avvicina.
1// Park sensörü: HC-SR04 + buzzer + LED / Parking sensor: HC-SR04 + buzzer + LED
2const int TRIG_PIN = 7;
3const int ECHO_PIN = 6;
4const int BUZZER_PIN = 5; // pasif buzzer / passive buzzer
5const int LED_PIN = 4; // 220 ohm dirençle / with a 220 ohm resistor
6
7long readDistanceCm() {
8 digitalWrite(TRIG_PIN, LOW);
9 delayMicroseconds(2);
10 digitalWrite(TRIG_PIN, HIGH); // 10 mikrosaniye tetik darbesi / 10 microsecond trigger pulse
11 delayMicroseconds(10);
12 digitalWrite(TRIG_PIN, LOW);
13 unsigned long duration = pulseIn(ECHO_PIN, HIGH, 30000UL); // 30 ms zaman aşımı / 30 ms timeout
14 if (duration == 0) return -1; // yankı yok / no echo
15 return duration / 58; // mikrosaniye -> cm / microseconds -> cm
16}
17
18void setup() {
19 pinMode(TRIG_PIN, OUTPUT);
20 pinMode(ECHO_PIN, INPUT);
21 pinMode(BUZZER_PIN, OUTPUT);
22 pinMode(LED_PIN, OUTPUT);
23 Serial.begin(9600);
24}
25
26void loop() {
27 long cm = readDistanceCm();
28 Serial.print("Mesafe / Distance: ");
29 Serial.print(cm);
30 Serial.println(" cm");
31
32 if (cm > 0 && cm < 50) {
33 int pause = map(cm, 0, 50, 50, 500); // yaklaştıkça kısalır / shorter when closer
34 tone(BUZZER_PIN, 2000, 50); // 2 kHz, 50 ms bip / 2 kHz, 50 ms beep
35 digitalWrite(LED_PIN, HIGH);
36 delay(50);
37 digitalWrite(LED_PIN, LOW);
38 delay(pause);
39 } else {
40 noTone(BUZZER_PIN);
41 digitalWrite(LED_PIN, LOW);
42 delay(200);
43 }
44}| Collegamento | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| HC-SR04 VCC | 5V | VIN / 5V | VBUS (5 V) |
| HC-SR04 GND | GND | GND | GND |
| HC-SR04 TRIG | D7 | GPIO 5 | GP14 |
| HC-SR04 ECHO | D6 | GPIO 18 (con partitore di tensione) | GP15 (con partitore di tensione) |
| Buzzer (+) | D5 | GPIO 19 | GP13 |
| LED (con 220 Ω) | D4 | GPIO 23 | GP12 |
Percorso ESP32: lo stesso piano, con il Wi-Fi in più
Se procedi con l'ESP32, i giorni 1–13 si fanno quasi con gli stessi codici; cambi solo i numeri dei pin. Ci sono due differenze da tenere a mente: analogRead sull'ESP32 restituisce valori da 0 a 4095 (12 bit) e per la lettura analogica conviene usare i pin ADC1 (GPIO 32–39), perché i pin ADC2 non sono utilizzabili quando il Wi-Fi è attivo. Inoltre, dopo il giorno 9 dedica una sera al Wi-Fi: il codice qui sotto mostra la distanza misurata dal sensore di parcheggio su una pagina web della rete locale; la pagina si aggiorna ogni secondo e il LED si accende quando la distanza scende sotto i 30 cm. Se lasci il buzzer collegato al GPIO 19 come nella tabella, sarà facile aggiungere un avviso sonoro nel progetto finale. Per la configurazione della scheda puoi leggere Cos'è l'ESP32.
1#include <WiFi.h>
2#include <WebServer.h>
3
4const char* WIFI_SSID = "AgAdi"; // kendi ağ adın / your network name
5const char* WIFI_PASS = "Sifre123"; // kendi şifren / your password
6
7const int TRIG_PIN = 5;
8const int ECHO_PIN = 18; // gerilim bölücüyle / through a voltage divider
9const int LED_PIN = 23;
10
11WebServer server(80);
12
13long readDistanceCm() {
14 digitalWrite(TRIG_PIN, LOW);
15 delayMicroseconds(2);
16 digitalWrite(TRIG_PIN, HIGH);
17 delayMicroseconds(10);
18 digitalWrite(TRIG_PIN, LOW);
19 unsigned long duration = pulseIn(ECHO_PIN, HIGH, 30000UL); // 30 ms zaman aşımı / 30 ms timeout
20 if (duration == 0) return -1;
21 return duration / 58;
22}
23
24void handleRoot() {
25 long cm = readDistanceCm();
26 digitalWrite(LED_PIN, (cm > 0 && cm < 30) ? HIGH : LOW); // 30 cm altında uyarı / warn below 30 cm
27 String html = "<html><head><meta charset='utf-8'><meta http-equiv='refresh' content='1'></head><body>";
28 html += "<h1>Mesafe: " + String(cm) + " cm</h1></body></html>";
29 server.send(200, "text/html", html);
30}
31
32void setup() {
33 Serial.begin(115200);
34 pinMode(TRIG_PIN, OUTPUT);
35 pinMode(ECHO_PIN, INPUT);
36 pinMode(LED_PIN, OUTPUT);
37 WiFi.mode(WIFI_STA);
38 WiFi.begin(WIFI_SSID, WIFI_PASS);
39 while (WiFi.status() != WL_CONNECTED) { // bağlanana kadar bekle / wait until connected
40 delay(500);
41 Serial.print(".");
42 }
43 Serial.println();
44 Serial.print("IP: ");
45 Serial.println(WiFi.localIP()); // bu adresi tarayıcıya yaz / type this address in a browser
46 server.on("/", handleRoot);
47 server.begin();
48}
49
50void loop() {
51 server.handleClient();
52}Dopo aver caricato il codice, apri il Monitor seriale a 115200 baud; quando la connessione è stabilita, digita nel browser del telefono l'indirizzo IP che viene stampato. Telefono ed ESP32 devono essere sulla stessa rete Wi-Fi. L'ESP32 si collega solo a reti a 2,4 GHz; se non si connette, segui la checklist in ESP32 non si connette al Wi-Fi. Nel progetto finale, aggiungere a questa pagina i dati del DHT11 e un link per accendere e spegnere un LED è un ottimo obiettivo per il passo successivo.
Percorso Raspberry Pi Pico: gli stessi giorni con MicroPython
Nel percorso Pico usi l'editor Thonny al posto dell'Arduino IDE; dopo aver caricato una volta il firmware MicroPython sul Pico, il codice va sulla scheda nel momento in cui lo salvi ed esegui. Il LED integrato sul Pico classico è su GP25 (sul Pico W si accede con Pin("LED")), per il PWM si usa machine.PWM, per la lettura analogica machine.ADC, e read_u16 restituisce valori nell'intervallo 0–65535. Se la sintassi di Python ti è nuova, prima del giorno 1 dai un'occhiata a Le basi di MicroPython; per conoscere la scheda c'è la guida Cos'è il Raspberry Pi Pico. Il codice qui sotto è l'equivalente in MicroPython del sensore di parcheggio del giorno 11 e usa la colonna Pico della tabella dei pin.
1from machine import Pin, PWM, time_pulse_us
2import time
3
4trig = Pin(14, Pin.OUT)
5echo = Pin(15, Pin.IN) # gerilim bölücüyle / through a voltage divider
6buzzer = PWM(Pin(13)) # pasif buzzer / passive buzzer
7led = Pin(12, Pin.OUT)
8
9def mesafe_cm():
10 trig.value(0)
11 time.sleep_us(2)
12 trig.value(1)
13 time.sleep_us(10) # 10 mikrosaniye tetik / 10 microsecond trigger
14 trig.value(0)
15 sure = time_pulse_us(echo, 1, 30000) # 30 ms zaman aşımı / 30 ms timeout
16 if sure < 0:
17 return -1 # yankı yok / no echo
18 return sure / 58
19
20while True:
21 cm = mesafe_cm()
22 print("Mesafe / Distance:", cm, "cm")
23 if 0 < cm < 50:
24 bekle = int(50 + cm * 9) # yaklaştıkça kısalır / shorter when closer
25 buzzer.freq(2000)
26 buzzer.duty_u16(32768) # yüzde 50 doluluk / 50 percent duty
27 led.value(1)
28 time.sleep_ms(50)
29 buzzer.duty_u16(0)
30 led.value(0)
31 time.sleep_ms(bekle)
32 else:
33 buzzer.duty_u16(0)
34 led.value(0)
35 time.sleep_ms(200)Progetto finale: cosa porterai a termine alla fine della vacanza?
Il progetto finale riunisce in un unico dispositivo utile le parti imparate in due settimane. Un buon progetto finale ha almeno un ingresso (sensore o pulsante), un'elaborazione (il codice che decide) e un'uscita (LED, suono, display o motore). Nessuna delle opzioni qui sotto richiede componenti costosi oltre al kit; scegli quella adatta al tuo livello e lavoraci dal giorno 13. Per altre idee puoi guardare l'elenco di idee per progetti Arduino.
| Livello / percorso | Progetto finale | Giorni che unisce | Materiale extra |
|---|---|---|---|
| Uno – principiante | Assistente di parcheggio intelligente: bip che accelera con la distanza, centimetri sull'LCD, barriera con servo che si abbassa a 10 cm | 4, 9, 10, 11, 12, 13 | Nessuno, il kit basta |
| Uno – alternativa | Mini stazione meteo: dati del DHT11 sull'LCD, il pulsante cambia pagina, la retroilluminazione si spegne al buio | 4, 7, 9, 12 | Nessuno, il kit basta |
| ESP32 | Stazione della stanza controllabile dal telefono: temperatura, umidità e distanza su una pagina web, LED acceso e spento dal browser | 6, 9, 10, 12 + Wi-Fi | Nessuno, la scheda ESP32 basta |
| Pico | Gioco di reazione: vince chi preme più velocemente quando il LED si accende a un istante casuale, il tempo appare nella console di Thonny e il vincitore viene festeggiato con una melodia del buzzer | 4, 8, 9 | Un secondo pulsante |
- Definiscilo in una frase: scrivi in modo chiaro cosa farà il dispositivo, per esempio "Più l'auto si avvicina al garage, più i bip accelerano; a 10 cm la barriera si abbassa".
- Disegna lo schema ingresso-elaborazione-uscita: con dei riquadri su carta, indica quale sensore fornisce i dati, su cosa deciderà il codice e quale componente reagirà.
- Fai il piano dei pin: scrivi in una tabella a quale pin va ogni componente. Assegna le uscite che richiedono PWM, come la luminosità dei LED, ai pin contrassegnati con ~; ricorda che su Uno la libreria Servo disattiva il PWM su D9 e D10. Per la mappa dei pin della tua scheda ti aiuta lo strumento diagramma dei pin.
- Testa pezzo per pezzo: fai prima funzionare ogni modulo da solo con il suo piccolo codice; non passare all'unione finché tutti non funzionano separatamente.
- Unisci e togli i delay: riunisci i codici in un solo file e sostituisci i delay lunghi con la struttura millis del giorno 9, in modo che lettura del sensore, suono e display non si aspettino a vicenda.
- Metti in scatola e presenta: sistema il circuito in una scatola di cartone o di plastica, fissa i cavi con il nastro e gira un video di presentazione di 30–60 secondi. Se vuoi rendere il circuito permanente, il passo successivo può essere saldare su una basetta forata.
Dove ti blocchi più spesso e come risolvere
| Problema | Causa probabile | Soluzione |
|---|---|---|
| Il codice non si carica, la porta non compare | Scheda o porta sbagliata, driver CH340 mancante o un cavo che serve solo per la ricarica | Seleziona scheda e porta dal menu Strumenti, usa un cavo USB per dati, installa il driver |
| Il LED non si accende mai | LED montato al contrario o gambe non sulla stessa fila della breadboard | La gamba lunga (anodo) va verso il pin, quella corta (catodo) verso GND; prova a spostare il collegamento di una fila |
| Il pulsante si attiva anche senza premerlo | Pin lasciato flottante (floating), manca la resistenza pull-up | Usa pinMode(pin, INPUT_PULLUP) e collega l'altro capo del pulsante a GND |
| L'HC-SR04 mostra sempre 0 o -1 | TRIG ed ECHO scambiati o il sensore non riceve 5 V | Controlla la tabella dei pin, collega VCC a 5 V, punta il sensore verso una superficie piana ad almeno 2 cm |
| La retroilluminazione dell'LCD è accesa ma non c'è testo | Contrasto o indirizzo I2C sbagliato | Gira il trimmer blu dietro il modulo, prova gli indirizzi 0x27 e 0x3F |
| La scheda si resetta quando il servo si muove | Il servo assorbe più corrente di quanta ne possa dare l'USB | Alimenta il servo con una fonte esterna da 5 V e collega il GND della fonte al GND della scheda |
| Errore "Failed to connect" durante il caricamento sull'ESP32 | La scheda non entra in modalità download | Tieni premuto il tasto BOOT all'inizio del caricamento e rilascialo quando compare "Connecting..." |
Alla fine delle due settimane non avrai solo un progetto finale funzionante, ma anche un metodo per imparare da solo qualsiasi nuovo sensore o modulo: leggi, disegna, monta, testa, modifica. Se a scuola continui con questa abitudine, un progetto a settimana, entro l'estate sarai pronto per un lavoro da concorso scientifico o da fiera della scienza; per la fase delle idee, l'articolo Idee di progetti Arduino per concorsi scientifici è un buon punto di partenza. Gli schemi e i codici dei progetti del piano (LED, semaforo, pulsante, luce notturna con LDR, misura della distanza e DHT11) li trovi passo per passo nell'app BlueGrays per Uno, ESP32 e Pico, così puoi seguire ogni giorno direttamente dall'app.
Domande frequenti
Si può imparare Arduino durante le vacanze invernali?
Sì, con 1–2 ore di lavoro regolare al giorno, in due settimane puoi imparare ingressi e uscite digitali e analogici, lettura di sensori, display e controllo dei motori. L'importante è completare ogni giorno un piccolo progetto e modificare il codice da solo. Alla fine della vacanza sarai in grado di realizzare un progetto che unisce più moduli.
Quale kit conviene comprare per iniziare con Arduino?
Uno starter kit con Arduino Uno, breadboard, cavi jumper, LED, resistenze, pulsante, potenziometro, LDR, buzzer, HC-SR04, DHT11, servo e LCD I2C basta per tutto questo piano. Anche i cloni dell'Uno eseguono lo stesso codice della scheda originale; potresti solo dover installare il driver CH340.
Meglio iniziare con Arduino, ESP32 o Raspberry Pi Pico?
Se non hai esperienza, Arduino Uno è l'inizio più facile: lavora a 5 V e la maggior parte degli esempi è scritta per lui. Se vuoi collegare i progetti a internet, l'ESP32 è la scelta migliore; se vuoi imparare Python, lo è il Raspberry Pi Pico con MicroPython. I concetti di base che impari sono gli stessi su tutte e tre le schede.
Posso imparare Arduino se non ho la scheda?
Sì. Simulatori che funzionano nel browser come Wokwi e Tinkercad ti permettono di collegare virtualmente LED, pulsante, potenziometro, HC-SR04, servo e LCD e di eseguire il codice. Puoi fare tutta la prima settimana del piano in simulazione e, quando arriva la scheda, provare lo stesso codice sul circuito reale.
Qual è il progetto Arduino più facile da fare?
Il più facile è collegare un LED con una resistenza da 220 Ω e farlo lampeggiare (Blink). Poi arrivano il semaforo, il controllo di un LED con un pulsante e la luce notturna con LDR. Questi quattro progetti insegnano le basi di Arduino: uscita digitale, ingresso digitale e lettura analogica.
Serve saper programmare per imparare Arduino?
Non serve saper programmare prima: il linguaggio Arduino è basato su C++, ma nei progetti iniziali bastano pochi comandi e semplici strutture if e for. Il modo più rapido per imparare è eseguire codici di esempio già pronti e modificarli riga per riga. Se conosci Python, puoi fare gli stessi progetti con Raspberry Pi Pico e MicroPython.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
LED lampeggiante
Il primissimo ciao dell'elettronica: accendere e spegnere un solo LED. L'Arduino accende e spegne il LED a intervalli brevissimi, così la luce lampeggia veloce.

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…

Accendere un LED con un pulsante (Push)
Come un campanello: la luce resta accesa finché premi e si spegne quando lasci. L'Arduino ascolta il pulsante di continuo; mentre è premuto accende il LED, e appena togli il dito lo spegne.

Luce notturna con LDR
Una piccola luce notturna che si accende da sola quando fa buio e si spegne quando arriva il mattino.

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é.

Temperatura e umidità con DHT11
Quanti gradi ci sono nella tua stanza, e l'aria è umida o secca? Il sensore DHT11 misura temperatura e umidità, e l'Arduino scrive i valori su uno schermo LCD a due righe, aggiornandoli ogni paio di…

LED Lampeggiante con ESP32
Insegna l'uso di base delle uscite GPIO con l'ESP32. Otteniamo un effetto lampeggiante accendendo e spegnendo un LED dal pin digitale. Versione ESP32 del classico progetto blink su Arduino UNO; i comandi di base di blink nell'ambiente Arduino sono gli stessi, ma la disposizione dei pin e i livelli GPIO a 3,3 V dell'ESP32 sono diversi da quelli di Arduino UNO.

Simulatore Semaforo Raspberry Pi Pico (3 LED Sequenziali)
Simuliamo un vero semaforo con LED rosso, giallo e verde. Verde 4 sec "vai", giallo 1,5 sec "preparati", rosso 3 sec "fermati" e rosso+giallo 1 sec "partenza" (pattern europeo). Impara la definizione di funzione, la logica della macchina a stati e la sincronizzazione multi-GPIO. Circuito semplice: 3 LED su GP11/GP12/GP13.
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

