Guide · 14 min di lettura

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.

MaterialeQuantitàGiorni in cui serve
Arduino Uno, ESP32 o Raspberry Pi Pico + cavo USB1Ogni giorno
Breadboard e cavi jumper maschio-maschio1 + 30Ogni giorno
LED (rosso, giallo, verde)6–81, 2, 3, 6, 7, 9, 11
Resistenza da 220 Ω81, 2, 3, 6, 7, 11
Resistenza da 10 kΩ27
Resistenza da 1 kΩ (partitore di tensione per ESP32 e Pico)310, 11
Pulsante24, 7, 9
Potenziometro da 10 kΩ15, 13
LED RGB16
LDR (fotoresistenza)17
Buzzer passivo18, 11
Sensore di distanza HC-SR04110, 11
Sensore di temperatura e umidità DHT11112
Display LCD 16x2 I2C112, 14
Servomotore SG90113, 14
Dedica la prima sera all'installazione: segui la guida all'installazione dell'Arduino IDE, collega la scheda e carica l'esempio File > Esempi > 01.Basics > Blink. Se il LED sulla scheda lampeggia una volta al secondo, scheda, cavo e driver funzionano e il giorno 1 puoi già costruire il circuito.

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.

PercorsoPer chi èLinguaggio ed editorPunto di forzaA cosa fare attenzione
Arduino UnoChi inizia con l'elettronicaArduino C++, Arduino IDEPin a 5 V, compatibile con tutti i moduli del kit, il maggior numero di esempiNiente Wi-Fi, solo 2 KB di RAM
ESP32Chi conosce le basi e vuole collegarsi a internetArduino C++, Arduino IDE (pacchetto schede ESP32)Wi-Fi e Bluetooth, dual-core a 240 MHz, ADC a 12 bitPin a 3,3 V: con sensori a 5 V serve un partitore di tensione
Raspberry Pi PicoChi vuole imparare PythonMicroPython, ThonnyEsecuzione immediata senza compilare, dual-core a 133 MHz, prezzo bassoPin 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.

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.

C++ (Arduino IDE)
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.

Collegare un LED senza resistenza mette sotto stress sia il LED sia il pin di Arduino. Per un LED rosso alimentato a 5 V, con una caduta di circa 2 V e una corrente di 15 mA, la resistenza necessaria è (5 − 2) / 0,015 = 200 Ω; il valore standard più vicino, 220 Ω, è per questo la resistenza più usata. Per altri colori puoi usare lo strumento calcolatore di resistenza per LED.

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.

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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.
  7. 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.

C++ (Arduino IDE)
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}
CollegamentoArduino UnoESP32Raspberry Pi Pico
HC-SR04 VCC5VVIN / 5VVBUS (5 V)
HC-SR04 GNDGNDGNDGND
HC-SR04 TRIGD7GPIO 5GP14
HC-SR04 ECHOD6GPIO 18 (con partitore di tensione)GP15 (con partitore di tensione)
Buzzer (+)D5GPIO 19GP13
LED (con 220 Ω)D4GPIO 23GP12
L'HC-SR04 si alimenta a 5 V e dal pin ECHO esce un segnale a 5 V. I pin di ESP32 e Pico sono a 3,3 V: collegare la linea ECHO direttamente può danneggiare il pin col tempo. Inserisci un partitore di tensione con resistenze da 1 kΩ e 2 kΩ: 5 × 2 / (1 + 2) ≈ 3,3 V. Se non hai la resistenza da 2 kΩ, puoi mettere in serie due resistenze da 1 kΩ. Controlla i valori con il calcolatore di partitore di tensione.

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.

C++ (Arduino IDE)
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.

MicroPython
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 / percorsoProgetto finaleGiorni che unisceMateriale extra
Uno – principianteAssistente di parcheggio intelligente: bip che accelera con la distanza, centimetri sull'LCD, barriera con servo che si abbassa a 10 cm4, 9, 10, 11, 12, 13Nessuno, il kit basta
Uno – alternativaMini stazione meteo: dati del DHT11 sull'LCD, il pulsante cambia pagina, la retroilluminazione si spegne al buio4, 7, 9, 12Nessuno, il kit basta
ESP32Stazione della stanza controllabile dal telefono: temperatura, umidità e distanza su una pagina web, LED acceso e spento dal browser6, 9, 10, 12 + Wi-FiNessuno, la scheda ESP32 basta
PicoGioco 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 buzzer4, 8, 9Un secondo pulsante
  1. 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".
  2. 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à.
  3. 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.
  4. 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.
  5. 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.
  6. 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

ProblemaCausa probabileSoluzione
Il codice non si carica, la porta non compareScheda o porta sbagliata, driver CH340 mancante o un cavo che serve solo per la ricaricaSeleziona scheda e porta dal menu Strumenti, usa un cavo USB per dati, installa il driver
Il LED non si accende maiLED montato al contrario o gambe non sulla stessa fila della breadboardLa 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 premerloPin lasciato flottante (floating), manca la resistenza pull-upUsa pinMode(pin, INPUT_PULLUP) e collega l'altro capo del pulsante a GND
L'HC-SR04 mostra sempre 0 o -1TRIG ed ECHO scambiati o il sensore non riceve 5 VControlla 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'è testoContrasto o indirizzo I2C sbagliatoGira il trimmer blu dietro il modulo, prova gli indirizzi 0x27 e 0x3F
La scheda si resetta quando il servo si muoveIl servo assorbe più corrente di quanta ne possa dare l'USBAlimenta 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'ESP32La scheda non entra in modalità downloadTieni premuto il tasto BOOT all'inizio del caricamento e rilascialo quando compare "Connecting..."
Quando ti blocchi, consulta prima il Monitor seriale: aggiungendo Serial.println nei punti chiave del codice puoi vedere il valore delle variabili e fino a dove arriva il programma. Se il problema continua, gli articoli Arduino non carica il codice, GND in comune ed ESP32 Failed to connect risolvono passo per passo i problemi più frequenti.

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.

Vedi tutti i progetti
LED lampeggiante
AR-1Principiante

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.

4.6(200)
1246
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
Accendere un LED con un pulsante (Push)
AR-9Principiante

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.

4.8(114)
253
Luce notturna con LDR
AR-12Principiante

Luce notturna con LDR

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

4.7(105)
224
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
Temperatura e umidità con DHT11
AR-55Intermedio

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…

4.7(47)
83
LED Lampeggiante con ESP32
ES-1Principiante

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.

4.7(37)
108
Simulatore Semaforo Raspberry Pi Pico (3 LED Sequenziali)
PI-4Principiante

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.

4.0(1)
12