Prima lezione con lo Starter Kit per Pico 2 di Elecrow, scopriremo come controllare i tre LED presenti nel kit.
Analizzeremo insieme il circuito e i componenti, poi caricheremo due programmi — disponibili sia per l’IDE di Arduino che per Thonny (MicroPython).
Nelle precedenti lezioni abbiamo visto come configurare il nostro Starter Kit per Pico 2 utilizzando sia l’Arduino IDE che Thonny. Se non l’avete fatto andate a vedere i post:
- 00 Starter Kit per Pico 2 – Configurazione per IDE Arduino
- 00 Starter Kit per Pico 2 – Configurazione per MicroPython
Indice
Introduzione
Lo Starter Kit per Pico 2 RP2350, è stato pensata per rendere l’approccio al mondo del Raspberry Pi Pico 2 il più semplice e coinvolgente possibile.
Si tratta di una vera e propria “scatola degli attrezzi” per chiunque voglia iniziare a creare hardware intelligente senza le complessità iniziali di saldature e cablaggi intricati.
Potete trovare la descrizione e la recensione nei post seguenti:
- All-in-One Starter Kit per Pico 2 RP2350 di Elecrow
- RECENSIONE AIO Starter Kit per Pico 2 di Elecrow
n° Descrizione Quantità Tipo 1 Sensore di temperatura e umidità 1 DHT20 2 Pulsante 4 3 Sensore di distanza ad ultrasuoni 1 HC-SR04 4 Sensore di luce 1 B1750 5 Potenziometro lineare 1 10kΩ 6 LED (rosso, verde, giallo) 3 7 LED RGB 20 WS2812B 8 Buzzer 1 Buzzer passivo 9 Sensore IR 1 VS 1838b 10 Relè 1 Relè SRD-05VDC-SL-C 11 Servomotore 1 MINI SERVO 9G SG90 12 Sensore del suono 1 Microfono a Elettrete 13 Accelerometro e giroscopio 1 MPU650 14 Sensore tattile 1 TIP233 15 Motore a vibrazione 1 16 Sensore Hall 1 HAL248 17 Sensore di fumo, GPL butano, idrogeno 1 Sensore MQ2
Dove acquistare lo Starter Kit per Pico 2
L’All-in-one Starter Kit for Pico 2 può essere trovato in rete presso il sito Elecrow.
Il kit è anche disponibile presso Amazon.it a questo link, oppure AliExpress a questo link
Link utili
- WiKi: https://www.elecrow.com/wiki/All-in-ne_Starter_Kit_for_Pico_2_with_Common_Board_design.html
- Codice originale del corso: https://www.elecrow.com/download/product/SEP0005K/course_code.zip
- Librerie: https://www.elecrow.com/download/product/SEP0005K/Libraries.zip
- github elecrow: https://github.com/Elecrow-RD/All-in-one-Starter-Kit-for-Pico-2
Lezione 01 – Controllo LED
In questa lezione per il Kit Pico 2 impareremo come controllare i tre LED presenti. Manipolando il codice, potremo ottenere l’effetto delle luci LED che si accendono e si spengono a intervalli.
Descrizione dei principali componenti
Sotto è riportato lo schema elettrico relativo ai tre led
Tra i componenti principali sono presenti i LED e i transistor, vediamone una breve descrizione.
LED
Un LED è un diodo che emette luce quando è attraversato da corrente elettrica in direzione diretta.
Il suo nome deriva da Light Emitting Diode, cioè diodo a emissione di luce.
Principio di funzionamento
Quando il LED è polarizzato in diretta (il terminale positivo — anodo — è collegato al positivo dell’alimentazione e il negativo — catodo — alla massa), gli elettroni attraversano la giunzione del diodo e rilasciano energia sotto forma di fotoni, cioè luce. Il colore della luce dipende dal materiale semiconduttore utilizzato.
| Colore | lunghezza d’onda [nm] | Sostanza |
|---|---|---|
| Infrarosso | 850-940 | GaAs, Arseniuro di Gallio |
| Rosso, Arancione, Giallo | 630-660 | GaAsP, Fosfuro Arseniuro di Gallio |
| Arancione, Giallo, Verde | 570-630 | InGaAIP, Fosfuro Nitruro di Gallio Alluminio Indio |
| Verde, Verde-blu, blu / Bianco | 505-570 | InGaN, Nitruro di Gallio e Indio |
| Blu | 430-505 | SiC, Silicio Carbonio |
Caratteristiche principali
- Tensione di lavoro (Vf): tipicamente da 1,8 V (rosso) a 3,3 V (bianco/blu).
- Corrente nominale: di solito 10–20 mA per i LED standard.
- Alta efficienza: consuma poca energia rispetto a una lampadina tradizionale.
- Polarità: funziona solo in un verso (anodo → catodo).
- Durata: può superare le 50 000 ore di funzionamento.
Uso tipico
I LED vengono impiegati in indicatori luminosi, illuminazione, display, e come emettitori di luce in sensori o telecomandi.
Vedere anche il post Led luminosi, calcolo della resistenza limitatrice
TRANSISTOR
Un transistor è un dispositivo elettronico a semiconduttore usato per amplificare o commutare segnali elettrici.
È uno dei componenti fondamentali dell’elettronica moderna — presente in praticamente tutti i circuiti, dai microcontrollori ai computer.
Tipi principali
- BJT (Bipolar Junction Transistor) → come quello dello schema (S9013).
- FET (Field Effect Transistor) → usato soprattutto nei circuiti digitali e di potenza.
Struttura e terminali (per un BJT)
Un transistor BJT ha tre terminali:
- Base (B): controlla il flusso di corrente.
- Collettore (C): è l’ingresso della corrente principale.
- Emettitore (E): è l’uscita della corrente.
Funzionamento base
Nel caso di un transistor NPN (come il S9013):
- Quando una piccola corrente entra nella base, permette il passaggio di una corrente molto più grande dal collettore all’emettitore.
- In pratica, la base agisce come un interruttore elettronico o un amplificatore di corrente.
Modalità d’uso
- Interruttore: acceso o spento (ON/OFF), come nel circuito del LED.
- Amplificatore: per aumentare la potenza o l’ampiezza di un segnale (ad esempio in audio o radiofrequenza).
In sintesi: Il transistor è un componente di controllo della corrente: una piccola corrente alla base regola una corrente più grande tra collettore ed emettitore.
Analisi del singolo circuito
Analizziamo ora uno dei tre circuiti, in quanto sono uguali, cambia solo il colore del LED.
Questo schema rappresenta un circuito di pilotaggio di un LED tramite un transistor NPN (S9013), controllato da un’uscita logica, nel nostro caso da un pin GPIO del microcontrollore Raspberry Pi.
Ecco una spiegazione sintetica del funzionamento:
Componenti principali:
Q1 (S9013) → Transistor NPN che funge da interruttore.
D1 (LED) → LED rosso pilotato dal transistor.
R7 (470 Ω) → Resistenza di limitazione della corrente per il LED.
R6 (1 kΩ) → Resistenza di base che limita la corrente in ingresso al transistor.
R4 (10 kΩ) → Resistenza di pull-down sulla base del transistor.
GPIO18_LED_RED → Uscita digitale che comanda l’accensione del LED.
VCC_5V → Alimentazione a 5 volt.
Funzionamento:
GPIO basso (0 V o logica “0”)
- Nessuna corrente scorre nella base del transistor Q1.
- Q1 è interdetto (spento) → il collettore non conduce.
- Il LED D1 rimane spento.
GPIO alto (3,3 V o logica “1”)
- Una piccola corrente scorre dal GPIO attraverso R6 nella base del transistor.
- Q1 si satura (si accende) → collega il collettore a massa.
- La corrente scorre da VCC_5V → R7 → LED → Q1 → massa, accendendo il LED.
R4 (10 kΩ) serve a garantire che, quando il GPIO è in stato flottante (ad esempio all’avvio del sistema), il transistor resti spento, evitando accensioni indesiderate del LED.
In sintesi
Il GPIO controlla indirettamente il LED tramite il transistor, che agisce come un interruttore.
Serve per pilotare un LED da una linea logica che non può fornire abbastanza corrente direttamente.
Programmi per versione IDE
Hardware richiesto
Dato che nel nostro Kit Pico 2 è già tutto cablato per controllare i led sarà sufficiente il cavo USB per il collegamento con il PC.
Per chi volesse comunque realizzare il progetto con componenti discreti, sotto è riportato lo schema.
In questo caso si è utilizzerà solamente delle resistenze limitatrici da 100 Ω.
Codice base
Sotto il codice di prova nella versione per IDE Arduino
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 | // Include la libreria principale di Arduino #include <Arduino.h> // Definisce i pin dei LED #define Red_LED 18 // LED rosso collegato al pin digitale 18 #define Yellow_LED 20 // LED giallo collegato al pin digitale 20 #define Green_LED 19 // LED verde collegato al pin digitale 19 // Variabile per registrare l'ultimo momento di cambio di stato unsigned long previousMillis = 0; // Intervallo di lampeggio del LED: 1000 millisecondi = 1 secondo const long interval = 1000; // Stati attuali dei tre LED (HIGH = acceso, LOW = spento) int redState = LOW; int yellowState = LOW; int greenState = LOW; // Funzione di inizializzazione: imposta le modalità dei pin void setup() { // Configura i pin dei LED come uscite pinMode(Red_LED, OUTPUT); pinMode(Yellow_LED, OUTPUT); pinMode(Green_LED, OUTPUT); // Imposta lo stato iniziale (tutti i LED spenti) digitalWrite(Red_LED, redState); digitalWrite(Yellow_LED, yellowState); digitalWrite(Green_LED, greenState); } // Funzione principale di loop: controlla il lampeggio dei LED void loop() { // Ottieni il tempo di esecuzione corrente in millisecondi unsigned long currentMillis = millis(); // Verifica se l'intervallo è trascorso if (currentMillis - previousMillis >= interval) { // Aggiorna il momento registrato previousMillis = currentMillis; // Inverti gli stati dei LED (acceso → spento, spento → acceso) redState = (redState == LOW) ? HIGH : LOW; yellowState = (yellowState == LOW) ? HIGH : LOW; greenState = (greenState == LOW) ? HIGH : LOW; // Applica i nuovi stati ai pin digitalWrite(Red_LED, redState); digitalWrite(Yellow_LED, yellowState); digitalWrite(Green_LED, greenState); } } |
👉 Cosa fa questo programma
Questo programma fa lampeggiare tre LED (rosso, giallo e verde) collegati ai pin digitali 18, 19 e 20 .
🔹 Come funziona il programma:
- Nella funzione
setup()i tre pin vengono impostati come uscite e i LED vengono inizialmente spenti. - Nel
loop(), il microcontrollore controlla continuamente quanto tempo è passato usandomillis(), che restituisce il tempo in millisecondi dall’avvio. - Quando è trascorso l’intervallo di 1 secondo (
interval = 1000), il programma:- Aggiorna il tempo dell’ultimo cambio (
previousMillis); - Inverte lo stato di ciascun LED (se era acceso lo spegne, se era spento lo accende);
- Applica i nuovi stati ai pin corrispondenti.
- Aggiorna il tempo dell’ultimo cambio (
🔹 Risultato:
Tutti e tre i LED lampeggiano simultaneamente, accendendosi e spegnendosi ogni secondo, senza usare delay() — quindi il microcontrollore rimane libero di fare altre operazioni nel frattempo.
Codice per simulazione semaforo
Ecco una variante del codice in cui i tre LED lampeggiano in sequenza (rosso → giallo → verde), proprio come un piccolo semaforo:
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 | // Includi la libreria principale di Arduino #include <Arduino.h> // Definisci i pin dei LED #define LED_Rosso 18 #define LED_Giallo 20 #define LED_Verde 19 // Variabili per la gestione del tempo unsigned long tempoPrecedente = 0; // Intervallo per ciascun stato (in millisecondi) const long intervallo = 1000; // Variabile che indica quale LED deve essere acceso int stato = 0; // 0 = rosso, 1 = giallo, 2 = verde void setup() { // Imposta i pin dei LED come uscite pinMode(LED_Rosso, OUTPUT); pinMode(LED_Giallo, OUTPUT); pinMode(LED_Verde, OUTPUT); // Tutti i LED spenti all'avvio digitalWrite(LED_Rosso, LOW); digitalWrite(LED_Giallo, LOW); digitalWrite(LED_Verde, LOW); } void loop() { // Ottieni il tempo corrente unsigned long tempoAttuale = millis(); // Se è passato l'intervallo previsto... if (tempoAttuale - tempoPrecedente >= intervallo) { tempoPrecedente = tempoAttuale; // Aggiorna il tempo // Spegni tutti i LED digitalWrite(LED_Rosso, LOW); digitalWrite(LED_Giallo, LOW); digitalWrite(LED_Verde, LOW); // Accendi il LED corrispondente allo stato attuale if (stato == 0) { digitalWrite(LED_Rosso, HIGH); } else if (stato == 1) { digitalWrite(LED_Giallo, HIGH); } else if (stato == 2) { digitalWrite(LED_Verde, HIGH); } // Passa allo stato successivo (e ricomincia dopo il verde) stato = (stato + 1) % 3; } } |
👉 Cosa fa questo programma:
- Accende solo un LED alla volta, in ordine: rosso → giallo → verde.
- Ogni LED rimane acceso per 1 secondo (
intervallo = 1000). - Dopo il verde, il ciclo ricomincia dal rosso.
- Anche qui non usa
delay(), quindi il microcontrollore resta reattivo.
Caricamento del programma
Consideriamo di aver già configurato l’IDE di Arduino, se non l’avete fatto leggete il post 00 Starter Kit per Pico 2 di Elecrow – Configurazione per IDE Arduino.
A questo punto selezionare la porta COM: Nel menù Strumenti > Porta, seleziona la porta seriale a cui è collegato il tuo Starter Kit, nell’esempio COM11.
Se non sei sicuro, scollega e ricollega lo Starter Kit e vedi quale porta compare/scompare.
Su Windows, di solito è COMx (dove x è un numero); su macOS/Linux, sarà qualcosa come /dev/cu.usbmodemxxxx o /dev/ttyACM0.
Attenzione: A volte la Pico potrebbe non apparire come una porta seriale “tradizionale” subito dopo averla collegata in modalità BOOTSEL. Non preoccuparti, l’IDE la rileverà automaticamente durante il caricamento.
Carica il programma: Clicca sull’icona della freccia verso destra (“Carica“) nella barra degli strumenti dell’Arduino IDE.
Nota: Se ci fossero dei problemi, consiglio di tenere premuto il tasto di BOOT [1] quindi premere brevemente il tasto di RESET [2] e rilasciarlo, quindi rilasciare il tasto di BOOT per forzare l’ingresso in modalità di programmazione.
L’IDE compilerà il codice e lo caricherà sulla vostra Pico. Vedrai dei messaggi nella finestra di stato in basso.
Download programmi per IDE
Link per il download dei programmi per IDE Arduino
Simulazione dei programmi
È possibili vedere anche la simulazione dei due programmi in esecuzione su Wokwi che è un simulatore online per piattaforme Arduino e altre schede elettroniche.
Wokwi è ideale per imparare a programmare con Arduino, creare prototipi di progetti e condividerli poi con altri Developer e maker.
Programmi per versione MicroPython
Come avrete visto nel post 00 Starter Kit per Pico 2 – Configurazione per MicroPython, il Kit può essere programmato anche in MicroPython.
Codice base
Questo programma fa lampeggiare tre LED (rosso, giallo e verde) collegati ai pin digitali 18, 19 e 20.
Sotto il codice da utilizzare
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 | # Importa la classe Pin per controllare i pin GPIO from machine import Pin # Importa il modulo time per la gestione del tempo import time # Definisci i pin GPIO collegati ai LED e impostali in modalità uscita led_rosso = Pin(18, Pin.OUT) # LED rosso collegato al GPIO18 led_giallo = Pin(20, Pin.OUT) # LED giallo collegato al GPIO20 led_verde = Pin(19, Pin.OUT) # LED verde collegato al GPIO19 # Definisci l’intervallo di lampeggio (in millisecondi) intervallo = 1000 # Registra il tempo dell’ultimo cambio di stato ultimo_tempo = time.ticks_ms() # Stati iniziali dei tre LED (False = spento, True = acceso) stato_rosso = False stato_giallo = False stato_verde = False # Funzione di inizializzazione: spegne tutti i LED def inizializza_led(): led_rosso.off() led_giallo.off() led_verde.off() # Funzione principale: lampeggia tutti i LED contemporaneamente def lampeggia_led(): global ultimo_tempo, stato_rosso, stato_giallo, stato_verde inizializza_led() # Imposta tutti i LED come spenti all'avvio while True: # Ottieni il tempo corrente in millisecondi tempo_corrente = time.ticks_ms() # Verifica se è trascorso l’intervallo di lampeggio if time.ticks_diff(tempo_corrente, ultimo_tempo) >= intervallo: # Aggiorna il tempo dell’ultimo cambio ultimo_tempo = tempo_corrente # Inverti lo stato di ciascun LED (acceso ↔ spento) stato_rosso = not stato_rosso stato_giallo = not stato_giallo stato_verde = not stato_verde # Applica i nuovi stati ai pin corrispondenti led_rosso.value(stato_rosso) led_giallo.value(stato_giallo) led_verde.value(stato_verde) # Punto di ingresso del programma: avvia la funzione principale lampeggia_led() |
Versione per simulazione semaforo
Ecco la versione del codice MicroPython che fa lampeggiare tre LED — rosso, giallo e verde — in sequenza, proprio come un semaforo.
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 | # Importa la classe Pin per controllare i pin GPIO from machine import Pin # Importa il modulo time per gestire i ritardi temporali import time # Definisci i pin GPIO collegati ai LED e impostali in modalità uscita led_rosso = Pin(18, Pin.OUT) # LED rosso collegato al GPIO18 led_giallo = Pin(20, Pin.OUT) # LED giallo collegato al GPIO20 led_verde = Pin(19, Pin.OUT) # LED verde collegato al GPIO19 # Funzione di inizializzazione: spegne tutti i LED def inizializza_led(): led_rosso.off() led_giallo.off() led_verde.off() # Funzione principale: simula il comportamento di un semaforo def semaforo(): inizializza_led() # Tutti i LED spenti all'avvio while True: # Accende il LED rosso per 3 secondi led_rosso.on() led_giallo.off() led_verde.off() time.sleep(3) # Accende il LED giallo per 1 secondo led_rosso.off() led_giallo.on() led_verde.off() time.sleep(1) # Accende il LED verde per 3 secondi led_rosso.off() led_giallo.off() led_verde.on() time.sleep(3) # Punto di ingresso del programma: avvia la funzione principale del semaforo semaforo() |
Download programmi per Thonny
Link per il download dei programmi per Thonny
Caricamento del programma
Per caricare il codice dovrete utilizzare il programma Thonny, Thonny è dotato di Python 3.10 integrato, quindi è sufficiente un semplice programma di installazione per iniziare a imparare a programmare.
Per fare partire il programma cliccate sul tasto Esegui
Il programma sarà caricato sulla scheda e sarà mandato in esecuzione.
Per fermare il programma cliccate sul tasto Stop
Nel caso in cui, invece, desiderate rendere l’esecuzione automatica non appena il Pico viene connesso a una fonte di alimentazione, salvate il file con il nome main.py e salvatelo sulla scheda.
Prossima lezione
Nella prossima lezione per il Kit Pico 2, vedremo come controllare i led utilizzando i tasti presenti.
State connessi per non perdervi la lezione.
