App per imparare Arduino: percorso di 30 giorni da zero

Se cerchi un'app per imparare Arduino, parti da un dato di fatto: nessuna app per telefono programma da sola una scheda Arduino. Il codice si carica sulla scheda da un computer, con un cavo USB, usando l'Arduino IDE (o Thonny sul Raspberry Pi Pico). Tutto il resto dell'apprendimento, però, funziona benissimo sul telefono: scegliere il progetto da cui partire, leggere lo schema del circuito, capire cosa fa il codice riga per riga, calcolare le resistenze e ripassare ogni giorno quello che hai imparato. In breve, sì, puoi imparare Arduino con un'app: il telefono diventa il tuo insegnante e il tuo quaderno, il computer il posto in cui parli con la scheda.

In questo articolo trovi un percorso di 30 giorni per chi parte da zero con l'app BlueGrays: cosa devi comprare, a cosa serve ogni sezione dell'app, quali progetti gratuiti realizzare e in che ordine nell'arco di quattro settimane, i comandi che impari ogni settimana, come dividere 30 minuti al giorno e dove ci si blocca più spesso. Tutto il piano si basa su progetti gratuiti; in una sezione a parte spieghiamo, senza esagerare, quando Premium può davvero essere utile.

Cosa fa l'app e cosa fa il computer?

Dividere il lavoro in due fin dall'inizio aiuta ad avere le aspettative giuste. Per mettere un programma nel microcontrollore ATmega328P dell'Arduino Uno, il codice va compilato e trasferito sulla scheda via USB; se ne occupa l'Arduino IDE, che richiede un computer con Windows, macOS o Linux. In BlueGrays, nella sezione Codice Sorgente di un progetto puoi prendere il codice con Copia, oppure usare Copia link per ottenere un collegamento che apre il codice sul computer; così eviti i punti e virgola dimenticati e le maiuscole sbagliate di quando lo ricopi a mano. L'interruttore Mostra a blocchi mostra lo stesso programma a blocchi, ma questi blocchi servono solo a leggere: nell'app non si modificano blocchi e non si caricano blocchi sulla scheda.

Cosa ti serve prima di iniziare?

Il piano di 30 giorni non richiede un kit grande. L'elenco qui sotto copre tutti i progetti gratuiti del percorso, e la maggior parte dei pezzi si trova già nei kit di base. Come scheda consigliamo l'Arduino Uno: funziona a 5 V, l'Arduino IDE la riconosce senza installare pacchetti aggiuntivi e la maggior parte dei tutorial per principianti è scritta per lei. Va bene anche una Nano, ma la disposizione dei pin è diversa, quindi dovrai riportare i collegamenti dello schema sui pin della tua scheda. L'ultima colonna indica il giorno in cui ogni pezzo compare per la prima volta nel piano; non devi comprare tutto subito.

Le sezioni dell'app: a cosa serve ciascuna?

BlueGrays funziona su iOS e Android in 10 lingue. Le schede in basso sono Scopri, Impara, Strumenti, Officina e Profilo; a progetti e componenti arrivi dalle sezioni Progetti e Componenti in cima alla scheda Scopri, alle domande del giorno e alla guida al codice da Impara › Lezioni, e al forum da Impara › Forum. La tabella riassume quale sezione userai nei 30 giorni, per fare cosa, e se è gratuita.

Se il primo giorno non sai da dove cominciare, apri Trova progetto: rispondi Arduino Uno / Nano alla domanda sulla scheda e "Sarà il mio primo progetto" a quella sull'esperienza. La scheda PRIMA IL RISCALDAMENTO · GRATIS nel risultato ti mostra un progetto di riscaldamento gratuito che puoi iniziare con gli stessi pezzi. Se non hai ancora una scheda, c'è anche l'opzione "Non ho ancora una scheda". Trova progetto non è un'alternativa al piano di questo articolo ma un complemento: ti servirà di nuovo nella settimana 4, quando sceglierai il tuo progetto.

Il percorso di 30 giorni per imparare Arduino

Il piano aggiunge una sola idea nuova a settimana: prima la scheda fa qualcosa (uscita), poi ascolta il mondo (ingresso), quindi misura valori intermedi e ripete azioni (analogico, porta seriale, cicli) e alla fine combini ciò che hai imparato. Dai due giorni a ogni progetto: il primo monti il circuito e lo fai funzionare, il secondo completi Capire il codice e svolgi il compito Prova tu. I giorni 7, 14 e 21 sono di ripasso, senza progetti nuovi. Tutti i progetti della tabella sono gratuiti in BlueGrays con schema, codice e blocchi, e la maggior parte dei nomi nella colonna dei comandi ha anche una propria scheda nella Guida al codice.

Settimana 1 (giorni 1–7): LED, tempi e struttura del programma

Il primo giorno è il più difficile, perché quasi tutto il lavoro è installazione: installa l'Arduino IDE, collega la scheda via USB, scegli scheda e porta dal menu Strumenti e carica il codice del progetto LED lampeggiante. Se il LED lampeggia, il primo obiettivo è raggiunto. Il giorno 2 apri Capire il codice nello stesso progetto: setup() viene eseguito una volta, loop() all'infinito; pinMode trasforma un pin in uscita, digitalWrite ci scrive HIGH o LOW e delay attende in millisecondi. Svolgi il compito Prova tu, poi abbassa il valore di delay da 1000 a 200 e osserva la differenza. I giorni 3–4 tocca a Due LED lampeggianti alternati: gli stessi comandi su due pin; guarda come cambia il comportamento quando cambi l'ordine delle righe. I giorni 5–6 tocca al Semaforo: tre LED in sequenza con tempi come rosso 2000 ms, giallo 300 ms e verde 2000 ms. Il giorno 7 non aprire progetti nuovi; dai al semaforo i tuoi tempi e risolvi nella Guida al codice i mini test delle schede pinMode, digitalWrite e delay.

Settimana 2 (giorni 8–14): pulsante, decisioni e suono

Questa settimana la scheda comincia ad ascoltare il mondo. Accendere un LED con un pulsante (Push) accende il LED finché tieni premuto il pulsante: digitalRead legge se il pin è HIGH o LOW e if / else decide di conseguenza. Se nello schema vedi una resistenza accanto al pulsante, il motivo è questo: quando il pulsante non è premuto, un pin scollegato legge valori casuali, e la resistenza lo porta a un livello definito. Lo spieghiamo con la differenza tra pull-up e pull-down nella guida come collegare un pulsante ad Arduino. Accendere e spegnere un LED con un pulsante fa un passo in più: una pressione accende, la successiva spegne. Per farlo il programma deve ricordare lo stato del LED in una variabile (ledState = !ledState) e filtrare i rimbalzi del pulsante con una breve attesa, per esempio 50 ms. I giorni 12–13 tocca a Uso del cicalino: tone() suona a una certa frequenza e noTone() lo zittisce. Il giorno 14 è di ripasso: prova una piccola modifica che faccia suonare un bip quando premi il pulsante.

Settimana 3 (giorni 15–21): sensore analogico, porta seriale e cicli

Finora tutto era HIGH o LOW. Con Misurare l'intensità luminosa con LDR vedi per la prima volta i valori intermedi: analogRead(A0) restituisce un numero tra 0 e 1023 e, grazie alla porta seriale che apri con Serial.begin(9600), segui quel numero nel monitor seriale del computer. Copri la LDR con la mano e guarda il numero scendere. Luce notturna con LDR confronta lo stesso valore con una soglia: quando la stanza si fa buia, il LED si accende. Regolare la soglia sulla luce della tua stanza è il compito più istruttivo della settimana. I giorni 18–19 tocca a Lampeggiante della polizia a LED: tenere il tempo di attesa in una variabile int e ripetere lo stesso lampeggio più volte con un ciclo for. I giorni 20–21 tocca a LED in sequenza: mettere i numeri di pin di sei LED in un array e accenderli uno dopo l'altro con un ciclo for. Se nel monitor seriale vedi caratteri strani, controlla il baud rate; la guida al monitor seriale di Arduino è l'aiuto di questa settimana.

Settimana 4 (giorni 22–30): unisci due progetti nel tuo

L'ultima settimana si apre con un sensore nuovo: HC-SR04 Misura della distanza (display seriale) misura con pulseIn quanto impiega a tornare l'impulso sonoro del sensore, lo converte in centimetri e lo scrive nel monitor seriale. I giorni 22–23 monta e capisci questo progetto. Se vuoi fare un po' più di pratica con i moduli sensore, aggiungi il progetto facoltativo Temperatura e umidità con DHT11; questi sensori di solito si leggono con una libreria, quindi se serve guarda la guida per aggiungere una libreria ad Arduino. I giorni 24–29 sono il lavoro vero: unire due progetti che hai già fatto in un piccolo progetto tuo. L'abbinamento più naturale è l'HC-SR04 con il cicalino: un mini sensore di parcheggio i cui bip accelerano man mano che un ostacolo si avvicina. Il giorno 30 condividi il tuo progetto nel forum. Ecco i passi:

1. Scegli due progetti gratuiti e fai funzionare prima ciascuno da solo (qui HC-SR04 Misura della distanza (display seriale) e Uso del cicalino).
2. Dai passi di Capire il codice di entrambi i progetti annota cosa fa ogni riga: uno misura la distanza, l'altro produce il suono.
3. Controlla i conflitti di pin: se i due progetti usano lo stesso pin, spostane uno su un pin libero e scrivi una piccola tabella dei pin come quella qui sotto.
4. Monta il circuito combinato con il cavo USB scollegato; poi riunisci in un unico sketch le righe pinMode di setup(), fai la misura in loop() e trasforma il risultato in suono con if / else if / else.
5. Stampa la distanza nel monitor seriale e regola le soglie di 10 cm e 30 cm in base alle tue prove.
6. Quando funziona, fotografa il circuito e condividilo nel forum in Tutorial o Idea; allega il codice con Aggiungi codice.

1// Gün 24-29 örneği: HC-SR04 + buzzer = mini park sensörü / Day 24-29 example: HC-SR04 + buzzer = mini parking sensor
2const int TRIG_PIN = 9;     // HC-SR04 TRIG / HC-SR04 TRIG
3const int ECHO_PIN = 10;    // HC-SR04 ECHO / HC-SR04 ECHO
4const int BUZZER_PIN = 8;   // buzzer (+) bacağı / buzzer (+) leg
5const int LED_PIN = 7;      // kırmızı LED, 220 ohm ile / red LED, with 220 ohm
6
7// Mesafeyi cm olarak ölçer, yankı yoksa -1 döner / Measures distance in cm, returns -1 if there is no echo
8long readDistanceCm() {
9  digitalWrite(TRIG_PIN, LOW);
10  delayMicroseconds(2);
11  digitalWrite(TRIG_PIN, HIGH);                       // 10 µs tetik darbesi / 10 µs trigger pulse
12  delayMicroseconds(10);
13  digitalWrite(TRIG_PIN, LOW);
14  long duration = pulseIn(ECHO_PIN, HIGH, 30000UL);   // en fazla 30 ms bekle / wait at most 30 ms
15  if (duration == 0) return -1;                       // yankı yok / no echo
16  return duration / 58;                               // µs -> cm / µs -> cm
17}
18
19void setup() {
20  pinMode(TRIG_PIN, OUTPUT);
21  pinMode(ECHO_PIN, INPUT);
22  pinMode(BUZZER_PIN, OUTPUT);
23  pinMode(LED_PIN, OUTPUT);
24  Serial.begin(9600);                                 // Seri Monitör'de 9600 seç / select 9600 in the Serial Monitor
25}
26
27void loop() {
28  long cm = readDistanceCm();
29  Serial.print("cm: ");
30  Serial.println(cm);
31
32  if (cm > 0 && cm < 10) {                            // çok yakın: sürekli ses / very close: continuous tone
33    digitalWrite(LED_PIN, HIGH);
34    tone(BUZZER_PIN, 1000);
35    delay(100);
36  } else if (cm > 0 && cm < 30) {                     // yakın: kesik bip / close: short beeps
37    digitalWrite(LED_PIN, HIGH);
38    tone(BUZZER_PIN, 1000, 80);                       // 80 ms bip / 80 ms beep
39    delay(80 + cm * 10);                              // yaklaştıkça bipler sıklaşır / beeps get faster as you get closer
40    digitalWrite(LED_PIN, LOW);
41  } else {                                            // uzak ya da ölçüm yok: sessiz / far or no reading: silent
42    noTone(BUZZER_PIN);
43    digitalWrite(LED_PIN, LOW);
44    delay(100);
45  }
46}
47

La novità di questo codice è spostare la misura della distanza in una tua funzione chiamata readDistanceCm(), così loop() resta corto e leggibile. Sotto i 10 cm il suono è continuo, tra 10 e 30 cm i bip accelerano con la distanza e più lontano c'è silenzio. La riga delay(80 + cm * 10) accorcia la pausa man mano che l'ostacolo si avvicina: 330 ms a 25 cm, 200 ms a 12 cm. Per condividerlo nel forum bastano una foto del circuito (fino a 5 immagini per post), il codice e una frase su cosa fa; se scrivi anche cosa vorresti migliorare, i commenti saranno più utili. Se hai fatto una domanda e hai trovato la risposta, chiudi la discussione con Segna come risolto.

Una routine di studio di 30 minuti al giorno

Arduino, ESP32 o Raspberry Pi Pico?

Questo piano si basa sull'Arduino Uno perché è la scheda con meno sorprese per chi comincia. L'app lo rispecchia: sui 200+ progetti, più di 110 sono per Arduino, una cinquantina per ESP32 e più di 30 per il Raspberry Pi Pico. I progetti gratuiti, invece, sono distribuiti in modo uniforme: dei 60 progetti gratuiti, 20 sono per Arduino, 20 per ESP32 e 20 per il Raspberry Pi Pico. Il nostro consiglio pratico: completa i primi 30 giorni con un Arduino Uno e poi passa all'ESP32 se vuoi Wi-Fi o Bluetooth. Se vuoi controllare un ESP32 dal telefono, con BlueGrays IoT nell'app il tuo primo dispositivo è gratuito; spieghiamo i passaggi nella guida per controllare un ESP32 dal telefono. La maggior parte dei comandi resta uguale e cominci con un progetto familiare come il Semaforo ESP32. Se scegli la strada di Python, le 18 schede MicroPython della guida al codice e la preferenza MicroPython delle domande del giorno ti semplificano il lavoro. Pin, ingressi, uscite, condizioni e cicli funzionano allo stesso modo sulle tre schede; le differenze di tensione, memoria e connessione wireless le trovi in Arduino o ESP32, l'installazione di MicroPython sul Pico in cos'è il Raspberry Pi Pico.

Cosa si fa gratis e quando ha senso Premium?

Tutto il piano di 30 giorni di questo articolo è gratuito: schema, elenco dei pezzi, codice, blocchi e sezione Capire il codice di ogni progetto del percorso sono aperti. A questo si aggiungono 7 strumenti di elettronica (Codice colori, Resistenza per LED, Legge di Ohm e altri), il nucleo delle domande del giorno, la guida al codice con 36 schede, il forum e Trova progetto, e puoi vedere l'elenco e la vetrina di tutti gli altri progetti. In altre parole, puoi studiare con regolarità per un mese e realizzare un piccolo progetto tuo senza Premium. Il momento in cui Premium ha senso arriva di solito dopo il giorno 30, quando ti orienti verso un argomento preciso e i progetti gratuiti cominciano a non bastare. Premium individuale è offerto come abbonamento mensile o annuale, e vedi il prezzo aggiornato per il tuo paese nella schermata dell'abbonamento dell'app. Vale la pena pensarci se ti ritrovi in uno di questi casi:

• Hai un obiettivo preciso (macchinina robot, orologio con display, controllo dal telefono via Wi-Fi) e ti servono i passi, il codice e gli schemi di quei progetti.
• Quando ti blocchi, vuoi usare l'elenco Risoluzione dei problemi nella pagina del progetto e la sezione Capire il codice nei progetti Premium.
• Vuoi usare gli 11 strumenti Premium, come resistenze in serie/parallelo, partitore di tensione o timer 555, e conservare i risultati su tutti i tuoi dispositivi con Calcoli salvati.
• Vuoi salvare i tuoi pezzi in Officina › Pezzi e vedere i progetti che puoi realizzare con quello che hai.
• Se nessuno di questi casi ti riguarda, non c'è fretta: passa il primo mese con i progetti gratuiti e decidi quando sai di cosa hai davvero bisogno.

Blocchi frequenti e dove cercare aiuto nell'app

Il segreto per imparare Arduino non è fare molto in una volta, ma capire davvero un piccolo passo ogni giorno: accendi il LED, leggi perché si accende, cambia un valore e ripassa il giorno dopo con tre minuti di domande. Alla fine di questi 30 giorni avrai usato i comandi di base, da pinMode a una tua funzione, letto dati da un sensore e condiviso un progetto tuo nato da altri due. Se vuoi portare il piano con te sul telefono, scarica BlueGrays e apri il primo giorno il progetto LED lampeggiante; tutti i progetti di questo percorso ti aspettano lì gratis.