Comandi Arduino: elenco in 36 schede tra C++ e MicroPython
Comandi Arduino in elenco nell'ordine giusto: 18 schede da pinMode a tone, equivalenti MicroPython, codice a confronto, piano di 4 settimane e 8 errori comuni.
Il modo più affidabile per imparare i comandi Arduino non è memorizzare un lungo elenco, ma affrontarli in ordine, ciascuno con un piccolo esempio e un progetto reale. Per questo l'app BlueGrays ha, nella sezione Lezioni della scheda Impara, la Guida al codice: 18 schede nel percorso Arduino C++, da pinMode a tone, e 18 schede nel percorso MicroPython, da import a I2C, 36 schede in tutto. Ogni scheda segue lo stesso schema: A cosa serve?, Perché?, Sintassi, Esempio (con le linguette Blocchi, Arduino e MicroPython), Errore comune, Suggerimento, Vedilo nei progetti e un Mini test di due domande. Anche l'ordine è fisso: prima i pin (pinMode, digitalWrite, digitalRead, analogRead, analogWrite), poi il tempo (delay, millis), quindi variabili, condizioni, cicli e funzioni, e infine Serial, map, random e tone. Se usi un Raspberry Pi Pico, impari gli stessi concetti nel percorso MicroPython con Pin, Pin.value, time.sleep, ADC.read_u16 e PWM.
Questo articolo è una mappa della guida. Prima vedrai cosa c'è dentro una scheda, poi le 18 schede di ogni percorso nel loro ordine reale nell'app, con l'equivalente nell'altro linguaggio. Seguono tre brevi esempi che affiancano la versione C++ e quella MicroPython dello stesso programma, come funzionano il mini test e il registro dei progressi, un ordine di studio di 4 settimane, una routine quotidiana di 20 minuti e gli 8 errori più comuni con questi comandi. Se cerchi una spiegazione dettagliata di ogni comando, l'articolo comandi Arduino con sintassi ed esempi dedica una sezione a ciascuno; questo spiega in che ordine impararli e come esercitarti.
Dov'è la Guida al codice e come funziona?
Entri nella guida dalla scheda Impara in basso: nella sezione Lezioni, in alto, tocca il riquadro Guida al codice. Aperta la guida, in alto vedi due linguette: Arduino C++ e MicroPython; l'app ricorda l'ultimo percorso aperto. Subito sotto ci sono il contatore Cosa hai imparato e la riga Prossima scheda, così non devi mai cercare dove eri rimasto. Le schede sono raggruppate per argomento: Pin, Tempo, Variabili, Condizioni, Cicli, Funzioni, Porta seriale, Matematica e Suono; il percorso MicroPython aggiunge Struttura di base e Gestione degli errori. La Guida al codice è gratuita: non serve Premium per leggere le schede, vedere gli esempi o risolvere i mini test. Le schede sono disponibili in 10 lingue, quindi leggi le spiegazioni nella lingua in cui usi l'app.
Cosa c'è dentro una scheda?
Tutte le schede hanno la stessa struttura, quindi dalla terza in poi sai già dove guardare. La tabella mostra le sezioni sulla 7ª scheda del percorso Arduino, millis; la colonna di destra riassume quello che dice la scheda. L'ordine delle sezioni è già un ordine di studio: prima scopri in una frase cosa fa il comando, poi capisci a cosa ti serve con un paragone quotidiano, vedi come si scrive, leggi un esempio funzionante, conosci la trappola più comune e ti metti alla prova con due domande.
| Sezione | Cosa spiega | Nella scheda millis |
|---|---|---|
| A cosa serve? | Il compito del comando in una frase | Ti dice quanti millisecondi sono passati dall'avvio della scheda. |
| Perché? | Perché ti serve, con un paragone quotidiano | Come una torta in forno: ogni tanto guardi l'orologio e intanto fai altro. |
| Sintassi | Come si scrive il comando | unsigned long now = millis(); |
| Esempio | Un breve programma funzionante; linguette Blocchi, Arduino e MicroPython | Codice che inverte un LED ogni 500 ms; sul Pico la stessa cosa con time.ticks_ms |
| Errore comune | La trappola in cui cadono più spesso i principianti | Tenere millis in un int: il numero diventa sbagliato dopo circa 33 secondi. |
| Suggerimento | Una piccola regola che semplifica il lavoro | Scrivi sempre il controllo nella forma adesso - precedente >= intervallo. |
| Vedilo nei progetti | I progetti che usano il comando, dal più facile al più difficile | Oltre 50 progetti; l'elenco parte da un progetto ESP32 gratuito con pulsante |
| Mini test | Due domande, una breve spiegazione dopo ogni risposta | Che cosa restituisce millis()? In quale tipo devi salvare millis? |
La sezione Esempio si apre sul percorso della scheda stessa: in una scheda Arduino viene prima la linguetta Arduino, in una scheda MicroPython la linguetta MicroPython. Ma l'altra linguetta è sempre lì, e questo trasforma la guida in un dizionario. Nella scheda Pin in uscita: Pin(15, Pin.OUT) del percorso MicroPython, per esempio, la linguetta Arduino contiene un codice che fa la stessa cosa con pinMode e digitalWrite, e i commenti dicono quale riga corrisponde a cosa (come la riga che sostituisce led.toggle()). Quasi tutte le schede hanno anche una terza linguetta, Blocchi, che mostra il programma d'esempio a blocchi. Se passi da Arduino al Pico, il metodo più rapido è questo: apri una scheda che conosci, cambia linguetta e abbina i due programmi riga per riga.
Percorso Arduino C++: 18 schede e i loro equivalenti MicroPython
La tabella riporta l'ordine reale del percorso Arduino nell'app; l'ultima colonna mostra come si fa la stessa cosa in MicroPython su un Raspberry Pi Pico. I numeri dei pin sono quelli degli esempi delle schede: per un LED, 13 o 9 sull'Uno e GP15 sul Pico; per un pulsante, 2 sull'Uno e GP14 sul Pico; per la lettura analogica, A0 sull'Uno e GP26 sul Pico. Le prime cinque schede trattano i pin, la 6 e la 7 il tempo, dalla 8 alla 14 le basi della programmazione, le ultime quattro la porta seriale, il cambio di scala, i numeri casuali e il suono. L'ordine è voluto: prima impari come la scheda tocca il mondo esterno, poi governi questi contatti con variabili, condizioni e cicli.
| N. | Scheda | A cosa serve? | Equivalente MicroPython |
|---|---|---|---|
| 1 | pinMode | Dice se un pin è un'uscita (LED, buzzer) o un ingresso (pulsante, sensore) | Pin(15, Pin.OUT) · Pin(14, Pin.IN, Pin.PULL_UP) |
| 2 | digitalWrite | Accende (HIGH, 5 V) o spegne (LOW, 0 V) un pin di uscita | led.value(1) · led.on() · led.off() |
| 3 | digitalRead | Legge se un pin di ingresso è HIGH o LOW | button.value() → 1 o 0 |
| 4 | analogRead | Converte la tensione su A0–A5 in un numero da 0 a 1023 | ADC(26).read_u16() → 0–65535 |
| 5 | analogWrite (PWM) | Abbassa la luminosità di un LED o rallenta un motore con un valore da 0 a 255 su un pin ~ | PWM(Pin(15)) · freq(1000) · duty_u16(0–65535) |
| 6 | delay | Ferma il codice per i millisecondi indicati | time.sleep(0.5) · time.sleep_ms(500) |
| 7 | millis | Millisecondi dall'avvio; temporizzare senza fermare il codice | time.ticks_ms() · time.ticks_diff() |
| 8 | Variabili e tipi | Memorizza valori con tipi come int, float, bool, unsigned long | Il tipo non si scrive: count = 0, volts = 3.3 |
| 9 | if / else if / else | Esegue un codice o un altro in base a una condizione | if / elif / else |
| 10 | Operatori di confronto e logici | Costruisce condizioni con ==, !=, <, >, &&, ||, ! | ==, !=, <, > · and, or, not |
| 11 | Ciclo for | Ripete un compito un numero fisso di volte | for i in range(10): |
| 12 | Ciclo while | Ripete finché una condizione è vera | while condizione: |
| 13 | Funzioni (void, parametri, return) | Divide il codice in pezzi con un nome e riutilizzabili | def blink(times): … return |
| 14 | Array | Tiene in ordine valori dello stesso tipo sotto un solo nome | Lista: pins = [2, 3, 4] · len(pins) |
| 15 | Serial.begin / print / println | Invia testo e valori al computer (monitor seriale) | print(x) · f-string; Serial.begin non serve |
| 16 | map | Converte un intervallo di numeri in un altro | Nessun comando pronto: raw * 255 // 1023 o una tua funzione |
| 17 | random / randomSeed | Genera numeri casuali | import random · random.randint(1, 6) |
| 18 | tone / noTone | Fa suonare un buzzer a una data frequenza e lo ferma | PWM: freq(440) · duty_u16(32768); duty_u16(0) per zittirlo |
Percorso MicroPython: 18 schede e i loro equivalenti Arduino
Il percorso MicroPython è pensato per il Raspberry Pi Pico; gli esempi delle schede sono brevi programmi che puoi eseguire su un Pico, per esempio con Thonny. L'ordine è un po' diverso dal percorso Arduino, perché in Python bisogna prima abituarsi alle regole del linguaggio: aggiungere moduli con import, stampare con print, la regola dell'indentazione e dei due punti. La linguetta Arduino di ogni scheda MicroPython contiene anche la versione C++ dello stesso programma; se conosci già Arduino, puoi leggere la tabella da destra a sinistra. Se è il tuo primo Pico, l'articolo cos'è il Raspberry Pi Pico è una buona preparazione per installazione e pin.
| N. | Scheda | A cosa serve? | Equivalente Arduino |
|---|---|---|---|
| 1 | import e from … import | Aggiunge al programma moduli come machine e time | #include per le librerie; i comandi di base come pinMode e delay sono già inclusi |
| 2 | print e f-string | Stampa testo e valori nella shell di Thonny | Serial.begin(9600) + Serial.println() |
| 3 | Pin in uscita: Pin(15, Pin.OUT) | Rende un pin GP un'uscita; value(), on(), off(), toggle() | pinMode(13, OUTPUT) + digitalWrite() |
| 4 | Pin in ingresso: Pin.IN, PULL_UP, PULL_DOWN | Rende un pin un ingresso, sceglie la resistenza interna, lo legge con value() | pinMode(2, INPUT_PULLUP) + digitalRead() |
| 5 | time.sleep e sleep_ms | Mette in pausa il programma in secondi o millisecondi | delay() |
| 6 | while True: il ciclo infinito | Ripete le righe sotto finché il Pico è acceso | loop() |
| 7 | Indentazione e due punti (:) | Stabilisce a quale blocco appartiene ogni riga | Parentesi graffe { } e punto e virgola ; |
| 8 | Variabili: int, float, str, bool | Memorizza valori; il tipo si decide da solo | int, float, String, bool |
| 9 | if / elif / else, and / or / not | Sceglie un ramo in base a condizioni e le combina | if / else if / else · &&, ||, ! |
| 10 | for e range | Ripete un numero fisso di volte; range(0, 10) conta da 0 a 9 | for (int i = 0; i < 10; i++) |
| 11 | Liste: [ ], indice, len | Tiene più valori in ordine; il primo elemento ha indice 0 | Array: int pins[] = {2, 3, 4}; |
| 12 | def e return (funzioni) | Dà un nome a codice riutilizzabile e restituisce un risultato | Funzioni void o con tipo, return |
| 13 | ADC: lettura analogica con read_u16 | Legge la tensione su GP26, GP27, GP28 come 0–65535 | analogRead() → 0–1023 |
| 14 | PWM: freq e duty_u16 | Abbassa la luminosità di un LED, suona note con un buzzer | analogWrite() e tone() |
| 15 | time.ticks_ms e ticks_diff | Misura il tempo trascorso senza fermare il codice | millis() |
| 16 | Pin.irq: pulsanti con gli interrupt | Esegue una funzione nell'istante in cui si preme un pulsante | attachInterrupt() |
| 17 | try / except (catturare gli errori) | Evita che il programma si fermi quando c'è un errore | Nessun equivalente comune su Arduino; si controllano i valori restituiti |
| 18 | I2C e scan() | Trova gli indirizzi dei dispositivi sul bus I2C | Wire.begin() + codice scanner I2C |
Lo stesso programma in due linguaggi: 3 esempi affiancati
Il primo esempio è il "ciao mondo" di ogni linguaggio: far lampeggiare il LED della scheda ogni mezzo secondo. Sull'Uno il LED integrato è collegato al pin 13, quindi non serve montare alcun circuito. Sul Pico è un po' diverso: sul Pico normale il LED integrato è su GP25, ma sul Pico W è collegato al chip wireless e Pin(25) non lo accende. Per questo in MicroPython è più sicuro scrivere Pin("LED", Pin.OUT); nelle versioni attuali di MicroPython questo nome trova il LED integrato sia sul Pico sia sul Pico W. Se il firmware della tua scheda non riconosce il nome "LED", installa un MicroPython aggiornato sul Pico. Il progetto gratuito Lampeggio LED Integrato Raspberry Pi Pico (Pico e Pico W) spiega proprio questa differenza.
1// Örnek 1: dahili LED'i yakıp söndür / Example 1: blink the built-in LED
2void setup() {
3 pinMode(13, OUTPUT); // Uno'da dahili LED 13. pinde / built-in LED is on pin 13 on the Uno
4}
5
6void loop() {
7 digitalWrite(13, HIGH); // LED yanar / LED on
8 delay(500); // 500 ms bekle / wait 500 ms
9 digitalWrite(13, LOW); // LED söner / LED off
10 delay(500); // 500 ms bekle / wait 500 ms
11}1# Örnek 1: dahili LED'i yakıp söndür / Example 1: blink the onboard LED
2from machine import Pin
3import time
4
5led = Pin("LED", Pin.OUT) # Pico ve Pico W'de dahili LED / onboard LED on Pico and Pico W
6# Pin(25, Pin.OUT) yalnız düz Pico'da çalışır / Pin(25, Pin.OUT) works only on the plain Pico
7
8while True: # Arduino'daki loop() gibi / like loop() in Arduino
9 led.on() # LED yanar / LED on
10 time.sleep_ms(500) # 500 ms bekle / wait 500 ms
11 led.off() # LED söner / LED off
12 time.sleep_ms(500) # 500 ms bekle / wait 500 msIl secondo esempio aggiunge un ingresso: il LED resta acceso finché il pulsante è premuto. Il pulsante va tra il pin 2 e GND sull'Uno, e tra GP14 e GND sul Pico. Sull'Uno usiamo di nuovo il LED integrato del pin 13; sul Pico collega un LED esterno a GP15 con una resistenza da 220 Ω (lo strumento Resistenza per LED calcola il valore per il tuo LED). In entrambi i linguaggi si attiva la resistenza di pull-up interna: INPUT_PULLUP in Arduino, Pin.PULL_UP in MicroPython. Con questo collegamento la logica è invertita: premendo, il pin va a GND, quindi l'Arduino legge LOW e il Pico legge 0. La pausa di 20 ms alla fine non elimina del tutto i rimbalzi meccanici del pulsante, ma riduce i lampeggi brevissimi. I dettagli del collegamento sono nell'articolo come collegare un pulsante ad Arduino.
1// Örnek 2: butona basılıyken LED yanar / Example 2: LED on while the button is pressed
2const int BUTTON_PIN = 2; // buton: 2. pin ile GND arasında / button between pin 2 and GND
3const int LED_PIN = 13; // dahili LED / built-in LED
4
5void setup() {
6 pinMode(BUTTON_PIN, INPUT_PULLUP); // iç pull-up direnci açık / internal pull-up on
7 pinMode(LED_PIN, OUTPUT);
8}
9
10void loop() {
11 if (digitalRead(BUTTON_PIN) == LOW) { // basılıyken LOW okunur / reads LOW while pressed
12 digitalWrite(LED_PIN, HIGH);
13 } else {
14 digitalWrite(LED_PIN, LOW);
15 }
16 delay(20); // kısa bekleme / short pause
17}1# Örnek 2: butona basılıyken LED yanar / Example 2: LED on while the button is pressed
2from machine import Pin
3import time
4
5button = Pin(14, Pin.IN, Pin.PULL_UP) # buton: GP14 ile GND arasında / button between GP14 and GND
6led = Pin(15, Pin.OUT) # LED: GP15 + 220 ohm direnç / LED on GP15 with 220 ohm
7
8while True:
9 if button.value() == 0: # basılıyken 0 okunur / reads 0 while pressed
10 led.value(1)
11 else:
12 led.value(0)
13 time.sleep_ms(20) # kısa bekleme / short pauseIl terzo esempio mostra la differenza più importante tra i due linguaggi: gli intervalli numerici. Il piedino centrale del potenziometro va su A0 sull'Uno e su GP26 sul Pico; i piedini esterni vanno su 5V e GND sull'Uno, e su 3V3 (OUT) e GND sul Pico. Il LED va sul pin 9 (segnato con ~) dell'Uno e su GP15 del Pico, in entrambi i casi con una resistenza da 220 Ω. In Arduino analogRead restituisce 0–1023 ma analogWrite vuole 0–255, per questo in mezzo c'è map(raw, 0, 1023, 0, 255). Sul Pico read_u16 e duty_u16 usano entrambi 0–65535, quindi puoi passare la lettura direttamente al PWM. Come funziona il PWM lo trovi nell'articolo cos'è il PWM, e come guardare i valori in tempo reale nella guida al monitor seriale.
1// Örnek 3: potansiyometreyle LED parlaklığı / Example 3: LED brightness with a potentiometer
2const int POT_PIN = A0; // potansiyometrenin orta ucu / potentiometer wiper
3const int LED_PIN = 9; // ~ işaretli PWM pini / PWM pin marked with ~
4
5void setup() {
6 pinMode(LED_PIN, OUTPUT);
7 Serial.begin(9600);
8}
9
10void loop() {
11 int raw = analogRead(POT_PIN); // 0-1023
12 int brightness = map(raw, 0, 1023, 0, 255); // 0-255 aralığına ölçekle / scale to 0-255
13 analogWrite(LED_PIN, brightness);
14 Serial.println(raw); // Seri Monitör'de izle / watch in the Serial Monitor
15 delay(50);
16}1# Örnek 3: potansiyometreyle LED parlaklığı / Example 3: LED brightness with a potentiometer
2from machine import Pin, ADC, PWM
3import time
4
5pot = ADC(26) # GP26 = ADC0, orta uç / wiper on GP26 (ADC0)
6led = PWM(Pin(15)) # LED: GP15 + 220 ohm direnç / LED on GP15 with 220 ohm
7led.freq(1000) # saniyede 1000 aç-kapa / 1000 cycles per second
8
9while True:
10 raw = pot.read_u16() # 0-65535
11 led.duty_u16(raw) # aynı aralık, ölçekleme gerekmez / same range, no scaling needed
12 print(raw) # Thonny kabuğunda izle / watch in the Thonny shell
13 time.sleep_ms(50)| Concetto | Arduino C++ | MicroPython (Pico) |
|---|---|---|
| Eseguito una volta | void setup() { … } | Le righe prima di while True: |
| Ripetuto all'infinito | void loop() { … } | while True: e le righe indentate sotto |
| Blocco di codice | Parentesi graffe { } e ; a fine riga | : a fine riga e indentazione di 4 spazi |
| Commento | // commento | # commento |
| Pin in uscita | pinMode(13, OUTPUT); digitalWrite(13, HIGH); | led = Pin(15, Pin.OUT) · led.value(1) |
| Pin in ingresso | pinMode(2, INPUT_PULLUP); digitalRead(2) | Pin(14, Pin.IN, Pin.PULL_UP) · button.value() |
| Lettura analogica | analogRead(A0) → 0–1023 | ADC(26).read_u16() → 0–65535 |
| Uscita PWM | analogWrite(9, 0–255) | PWM(Pin(15)).duty_u16(0–65535) |
| Attesa | delay(500) | time.sleep_ms(500) o time.sleep(0.5) |
| Stampa | Serial.begin(9600); Serial.println(x); | print(x) |
Mini test, "Capito" e i tuoi progressi in Il mio livello
- Mini test: Ogni scheda termina con due domande, e il titolo dice Mini test · 1 / 2. Quando tocchi una risposta ricevi subito Giusto. o Non proprio. con una breve spiegazione; prosegui con Prossima domanda.
- Punteggio: Finite le due domande vedi un punteggio come 2 / 2 giuste. La scheda non si può completare senza il test; al posto del pulsante compare Risolvi il mini test per completare la scheda.
- Capito: Finito il test compare il pulsante Capito, prossima scheda (sull'ultima scheda di un percorso solo Capito). Toccandolo, la scheda viene salvata come imparata nel tuo account, una piccola festa mostra i tuoi progressi, per esempio Ottimo! 5 / 18 schede, e si apre la scheda successiva.
- Badge e contatore: Le schede imparate hanno il segno Imparata nell'elenco, e il contatore Cosa hai imparato in cima alla guida sale. Quando finisci tutte le schede di un percorso compare Hai imparato tutte le schede di questo percorso.
- Il mio livello: Nella schermata Il mio livello della sezione Impara, sotto il titolo Guida al codice e la nota Schede imparate, ci sono due barre separate: Arduino C++ x/18 e MicroPython x/18. Queste barre contano solo le schede della guida al codice.
- Una regola onesta con te stesso: L'app non ti blocca dopo una risposta sbagliata; il pulsante Capito compare appena il test è finito. Prima di toccarlo, quindi, assicurati di saper spiegare ad alta voce perché entrambe le risposte sono corrette; se non ci riesci, torna alla sezione Esempio e rileggi il codice riga per riga.
Vedilo nei progetti: trovare il comando nel codice vero
L'ultimo passo per imparare un comando è riconoscerlo in un progetto funzionante scritto da qualcun altro. Nella sezione Vedilo nei progetti la scheda mostra alcuni progetti scelti e, sotto, una frase che dice in quanti progetti compare il comando; il link Tutti apre l'elenco completo. È ordinato dal più facile al più difficile e si restringe con i filtri Tutti, Gratuito e Premium. millis, per esempio, compare nel codice di oltre 50 progetti: l'elenco parte dal progetto gratuito Controllo LED ESP32 con pulsante (Toggle), prosegue con progetti per principianti sul Pico come Pianoforte a pulsanti con Raspberry Pi Pico (5 pulsanti + buzzer + registratore) e Sensore di parcheggio con Raspberry Pi Pico (HC-SR04 + 3 LED + buzzer) e sale a progetti di livello intermedio come Semaforo Raspberry Pi Pico con selettore a 4 posizioni (macchina a stati, GP11-13 + GP4), che uniscono pulsante e temporizzazione. Il nostro consiglio: apri un progetto gratuito dell'elenco, cerca il comando nel codice, cambia un valore e prevedi prima il risultato. Per vedere cosa fa ogni riga del codice, la linguetta Capire il codice del progetto è il passo naturale successivo.
Ordine di studio consigliato: un piano di 4 settimane
Supponiamo che tu possa dedicare circa 20 minuti al giorno, 5 giorni a settimana. Per finire un percorso in 4 settimane basta una scheda nella maggior parte dei giorni; negli altri ripassi e lavori su un progetto invece che su una scheda nuova. Se hai un Arduino, segui solo la colonna Arduino; se hai un Pico, la colonna MicroPython. Se hai entrambe le schede, completa prima il percorso Arduino e passa a MicroPython nel secondo mese; i concetti sono gli stessi, quindi il secondo percorso va molto più veloce. Tutti i progetti della tabella sono gratuiti su BlueGrays. Se vuoi un piano più ampio, la tabella di marcia di 30 giorni dell'articolo app per imparare Arduino si abbina bene a questa tabella; se insegni con il Pico, le lezioni con il Raspberry Pi Pico distribuiscono le schede MicroPython su 6 settimane di lezione.
| Settimana | Schede Arduino C++ | Schede MicroPython | Progetti gratuiti della settimana | Cosa sai fare a fine settimana |
|---|---|---|---|---|
| 1 | 1–5: pinMode, digitalWrite, digitalRead, analogRead, analogWrite | 1–5: import, print, pin in uscita, pin in ingresso, time.sleep | LED lampeggiante, Accendere un LED con un pulsante (Push); Pico: Lampeggio LED Integrato Raspberry Pi Pico (Pico e Pico W) | Far lampeggiare un LED, leggere un pulsante; su Arduino, vedere un valore analogico |
| 2 | 6–10: delay, millis, variabili, if / else, operatori | 6–9: while True, indentazione, variabili, if / elif / else | Luce notturna con LDR, Controllo LED ESP32 con pulsante (Toggle); Pico: Raspberry Pi Pico Due LED alternati (Flip-Flop, GP14 + GP13) | Decidere in base a una lettura, temporizzare senza fermare il programma |
| 3 | 11–14: for, while, funzioni, array | 10–13: for e range, liste, def, ADC | Effetto Supercar con LED, LED in sequenza; Pico: Simulatore Semaforo Raspberry Pi Pico (3 LED Sequenziali, GP11/GP12/GP13) | Mettere le ripetizioni nei cicli, i pin negli array e i compiti nelle funzioni |
| 4 | 15–18: Serial, map, random, tone | 14–18: PWM, ticks_ms, Pin.irq, try / except, I2C | Uso del cicalino, Misurare l'intensità luminosa con LDR; Pico: Semaforo Raspberry Pi Pico con selettore a 4 posizioni (macchina a stati, GP11-13 + GP4) | Stampare valori, regolare suono e luminosità, costruire da zero un piccolo progetto |
Una routine quotidiana di 20 minuti
- 3 minuti, riscaldamento: Risolvi le domande del giorno nella sezione Impara o rifai il mini test di ieri. Lo scopo è verificare che oggi ricordi ancora il comando di ieri.
- 5 minuti, nuova scheda: Leggi le sezioni A cosa serve?, Perché? e Sintassi. Ricopia la sintassi a mano su un foglio; scrivendola, ti sfuggono molto meno parentesi e punti e virgola.
- 3 minuti, esempio: Spiegati l'esempio riga per riga, poi cambia linguetta. In una scheda Arduino guarda la linguetta MicroPython, in una scheda MicroPython la linguetta Arduino, e abbina le righe che fanno la stessa cosa nei due programmi.
- 2 minuti, mini test: Rispondi alle due domande e leggi la spiegazione di quella sbagliata. A questo punto dai un'altra occhiata ai riquadri Errore comune e Suggerimento.
- 6 minuti, progetto: Apri un progetto gratuito e facile dall'elenco Vedilo nei progetti, trova il comando nel codice e cambia un solo valore: un'attesa, un numero di pin o una soglia. Se il circuito è pronto, carica il codice sulla scheda; altrimenti prevedi il risultato e controllalo con Capire il codice.
- 1 minuto, appunto: Scrivi una riga sul quaderno: il nome del comando, il suo significato in una frase e l'equivalente nell'altro linguaggio. Dopo quattro settimane quella pagina sarà il tuo dizionario personale dei comandi.
8 errori comuni con questi comandi
| Errore | Sintomo | Soluzione | Scheda |
|---|---|---|---|
| Dimenticare pinMode | Il LED non si accende o è molto debole | Scrivi pinMode(pin, OUTPUT) in setup(); sul Pico crea il pin con Pin(15, Pin.OUT) | pinMode · pin in uscita |
| Scrivere = invece di == in una condizione | if (x = 5) è sempre vero, il programma entra sempre nello stesso ramo | Usa == per confrontare; in Python if x = 5 dà subito un SyntaxError | if / else · operatori |
| Bloccare il codice con un delay lungo | Premi il pulsante, ma la reazione arriva tardi o non arriva | Fai l'attesa con millis; sul Pico usa time.ticks_ms e ticks_diff | delay · millis · ticks_ms |
| Confondere l'intervallo di analogRead | Una soglia copiata da Arduino sul Pico non scatta mai | Sull'Uno analogRead dà 0–1023, sul Pico read_u16 dà 0–65535; ricalcola la soglia per il nuovo intervallo | analogRead · ADC |
| Portare un valore di analogWrite in duty_u16 | Sul Pico, con duty_u16(255) il LED resta quasi spento | duty_u16 vuole 0–65535: metà luminosità è 32768, piena luminosità 65535 | analogWrite · PWM |
| Tenere millis in un int | Sull'Uno la temporizzazione si guasta dopo circa 33 secondi | Dichiara le variabili di tempo come unsigned long e scrivi il controllo come adesso - precedente >= intervallo | millis |
| Aspettarsi la logica di INPUT_PULLUP al contrario | Ti aspetti HIGH o 1 premendo il pulsante, ma arriva LOW o 0 | Con il pull-up, premuto è LOW (0) e rilasciato è HIGH (1) | digitalRead · pin in ingresso |
| Scrivere sleep(500) sul Pico | Il Pico aspetta 500 secondi, più di 8 minuti, invece di mezzo secondo | sleep vuole i secondi: scrivi sleep(0.5) o sleep_ms(500) | time.sleep |
La linguetta Blocchi: capire un comando guardandolo
La linguetta Blocchi ti fa vedere cosa fa un comando senza scrivere codice, soprattutto nelle prime schede di un percorso. Nell'immagine sopra, pinMode diventa il blocco "imposta pin 9 come USCITA", digitalWrite diventa "scrivi ALTO sul pin 9" e delay "attendi 100 ms"; nella scheda pinMode, una nota sotto la vista a blocchi riporta anche le opzioni del menu a tendina: USCITA, INGRESSO e INGRESSO (PULLUP). I blocchi appaiono nella lingua dell'app e servono per leggere: nell'app non trascini blocchi per scrivere un programma, e sulla scheda si carica sempre il codice vero. Il modo consigliato di usarli: prima prevedi nella linguetta Blocchi cosa farà il programma, poi passa alla linguetta Arduino e trova a quale riga corrisponde ogni blocco. Nei progetti con vista a blocchi, l'interruttore Mostra a blocchi nella pagina del progetto ti permette di fare lo stesso abbinamento su un progetto intero; le basi sono nell'articolo cos'è la programmazione a blocchi.
In breve, per imparare i comandi Arduino non serve un lungo elenco: bastano l'ordine giusto, un piccolo esempio funzionante per ogni comando, una verifica di due domande e un progetto reale che usa il comando. Se oggi inizi dalla scheda pinMode, tra quattro settimane avrai completato tutte le 18 schede e visto ogni comando con i tuoi occhi in almeno un progetto; quando passerai al Pico, percorrerai gli stessi concetti nel percorso MicroPython molto più in fretta. Se vuoi provare le schede e i progetti che contengono, installa BlueGrays sul telefono e apri la prima scheda nella sezione Impara.
Domande frequenti
Quali sono i comandi base di Arduino?
I comandi Arduino più usati sono quelli dei pin (pinMode, digitalWrite, digitalRead, analogRead, analogWrite), quelli del tempo (delay, millis), quelli della porta seriale con Serial e aiuti come map, random e tone. Accanto a questi, strutture C++ come if, for e while, insieme alle funzioni, costruiscono il flusso del programma. Il percorso Arduino C++ della Guida al codice di BlueGrays tratta questi argomenti in ordine in 18 schede.
Da quale comando Arduino si comincia?
Comincia da pinMode e digitalWrite, perché con questi due accendi già un LED e vedi subito il risultato. Poi aggiungi la temporizzazione con delay e la lettura di un pulsante con digitalRead. analogRead, millis, if e for si basano tutti su questi quattro comandi.
Che differenza c'è tra i comandi Arduino e MicroPython?
I concetti sono gli stessi, cambia la scrittura: Pin(15, Pin.OUT) e led.value(1) sostituiscono pinMode e digitalWrite, time.sleep_ms sostituisce delay e while True sostituisce loop(). Cambiano anche gli intervalli numerici; analogRead restituisce 0–1023 sull'Uno, read_u16 restituisce 0–65535 sul Pico. In Python l'indentazione e i due punti prendono il posto delle parentesi graffe e dei punti e virgola del C++.
In MicroPython esiste il comando delay?
Non esiste un comando chiamato delay; fanno lo stesso lavoro sleep (secondi), sleep_ms (millisecondi) e sleep_us (microsecondi) del modulo time. Il delay(500) di Arduino diventa sul Pico time.sleep_ms(500) o time.sleep(0.5). Per temporizzare senza fermare il codice, time.ticks_ms e time.ticks_diff sostituiscono millis.
Su quale pin è il LED integrato del Raspberry Pi Pico?
Sul Pico normale il LED integrato è collegato a GP25. Sul Pico W il LED è collegato al chip wireless, quindi Pin(25) non lo accende. Nelle versioni attuali di MicroPython, Pin("LED", Pin.OUT) trova il LED integrato su entrambe le schede.
La Guida al codice di BlueGrays è gratuita?
Sì, la Guida al codice è gratuita: puoi leggere tutte le 36 schede, vedere gli esempi e risolvere i mini test. Gli elenchi di Vedilo nei progetti contengono progetti gratuiti e Premium; il filtro Gratuito mostra solo quelli gratuiti.
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. Vedi nel modo più semplice come la sche
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. Con questo
Luce notturna con LDR
Una piccola luce notturna che si accende da sola quando fa buio e si spegne quando arriva il mattino. Un sensore di luce misura quanto è illuminata la stanza, e l'Arduino accende il LED quando è abbas
Controllo LED ESP32 con pulsante (Toggle)
Ogni volta che si preme il pulsante, lo stato del LED cambia: se è acceso si spegne, se è spento si accende. Classico schema toggle. Con il debounce puliamo il rumore meccanico del pulsante per garantire una singola commutazione con una sola pressione.
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. L'Arduino accende ogni LED per un decimo di secondo prima di passare al successivo, inve
Lampeggio LED Integrato Raspberry Pi Pico (Pico e Pico W)
Il progetto di apertura della serie Raspberry Pi Pico! Facciamo lampeggiare il LED verde integrato per verificare che la scheda funzioni — un classico primo esperimento "Hello World". NESSUN componente esterno, solo Pico e cavo USB. Il codice è scritto in MicroPython (il linguaggio ufficialmente supportato dalla Raspberry Pi Foundation). Impara la classe machine.Pin, la modalità Pin.OUT, i metodi led.on()/off() e time.sleep() in Thonny IDE. Segui ogni commutazi
Raspberry Pi Pico Due LED alternati (Flip-Flop)
Il passo successivo dopo il LED singolo sul Pico: due LED lampeggiano alternativamente in un pattern flip-flop classico. Due LED di colori diversi (rosso su GP14, verde su GP13) scambiano stati ogni 500ms. Pin.toggle() di MicroPython rende il codice breve. Base di semafori, lampeggianti.
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.