Programmazione a blocchi Arduino: far lampeggiare un LED

Con la programmazione a blocchi di Arduino, il primo programma è quasi sempre lo stesso: far lampeggiare un LED. In questo articolo lo facciamo dall'inizio alla fine. Colleghiamo un LED al pin 9 con una resistenza da 220 Ω, leggiamo uno per uno i blocchi del progetto LED lampeggiante di BlueGrays e vediamo, affiancati, in quale riga del codice C++ caricato sulla scheda si trasforma ogni blocco. Proverai anche a cambiare un solo numero, il 100 del blocco "attendi 100 ms", per regolare la velocità del lampeggio.

Non ci fermiamo a un solo LED. Faremo crescere la stessa logica passo dopo passo fino a programmi che accendono due LED a turno, si comportano come un semaforo e lampeggiano come le luci della polizia. Poi vedrai la stessa idea sull'ESP32 e sul Raspberry Pi Pico con MicroPython. In fondo trovi una tabella con gli errori che quasi tutti i principianti fanno almeno una volta. Tutti i progetti di questo articolo sono gratuiti in BlueGrays, blocchi e codice compresi, e puoi vedere tutti i progetti con blocchi divisi per piattaforma nella pagina programmazione a blocchi.

Cosa ti serve?

Il circuito: collegare il LED al pin 9

Un LED ha due gambe e il verso conta. La gamba lunga è l'anodo (+), quella corta il catodo (-); dal lato del catodo il corpo in plastica ha un lato piatto. La corrente scorre solo dall'anodo al catodo, quindi se lo inserisci al contrario non succede niente. Collega il pin 9 di Arduino a un capo della resistenza da 220 Ω e l'altro capo alla gamba lunga del LED. La gamba corta va a GND. La resistenza limita la corrente: togli dai 5 V i circa 2 V del LED rosso, sulla resistenza restano 3 V, e 3 V / 220 Ω fanno circa 14 mA. È una corrente comoda per il LED e sicura per il pin di Arduino. Puoi verificare il valore per il colore del tuo LED con il calcolatore di resistenza per LED. Come funziona un LED è spiegato in cos'è un LED, e come sono collegate all'interno le file della breadboard in cos'è una breadboard.

Il tuo primo programma a blocchi: LED lampeggiante

Con il circuito pronto, passiamo al programma. Apri il progetto LED lampeggiante in BlueGrays e attiva Mostra a blocchi nella sezione del codice: vedrai i blocchi qui sotto. In tutto sono sette blocchi, divisi in due grandi gruppi: in alto setup (una volta), sotto ripeti per sempre. I blocchi compaiono nella lingua dell'app: in italiano si legge "scrivi ALTO sul pin", in inglese "write HIGH to pin".

I blocchi del gruppo setup (una volta) vengono eseguiti una sola volta, quando la scheda si accende o premi reset. Qui c'è un solo blocco: "imposta pin 9 come USCITA". I pin digitali di Arduino possono essere ingressi o uscite. Dato che pilotiamo un LED, diciamo alla scheda "da questo pin farò uscire corrente". Il gruppo ripeti per sempre parte quando il setup è finito e viene eseguito dall'alto in basso ancora e ancora finché la scheda resta accesa. I suoi quattro blocchi accendono il LED, aspettano 100 millisecondi, lo spengono e aspettano altri 100 millisecondi. Dopo l'ultimo blocco il programma torna all'inizio e il LED si riaccende. Quello che chiamiamo lampeggio non è altro che questi quattro passi ripetuti cinque volte al secondo.

Blocco → riga C++: in cosa si trasforma ogni blocco?

1// Led Yakma (proje 1): D9'daki LED 100 ms yanar, 100 ms söner
2// LED Blink (project 1): the LED on D9 is on for 100 ms, off for 100 ms
3void setup() {
4  pinMode(9,OUTPUT);     // LED pini çıkış / LED pin as output
5}
6
7void loop() {
8  digitalWrite(9,HIGH);  // LED'i yak / turn the LED on
9  delay(100);            // 100 ms bekle (1000 ms = 1 s) / wait 100 ms (1000 ms = 1 s)
10  digitalWrite(9,LOW);   // LED'i söndür / turn the LED off
11  delay(100);            // 100 ms bekle / wait 100 ms
12}
13

Mettendo la tabella accanto al codice vedi cosa fanno i blocchi al posto tuo. La forma dei gruppi setup e ripeti per sempre corrisponde alle parentesi graffe delle funzioni void setup() e void loop(): il gruppo in cui si trova un blocco decide dentro quali graffe viene scritta la sua riga. Con i blocchi non devi pensare al punto e virgola alla fine di ogni istruzione, a maiuscole e minuscole (pinMode, digitalWrite) né alle parentesi. Ma quando inizi a modificare tu stesso il codice nell'Arduino IDE diventano importanti; basta un punto e virgola dimenticato per avere un errore di compilazione. È proprio questo il vantaggio dei blocchi: prima fissi la logica del programma, poi impari come quella stessa logica si scrive in codice.

Cosa succede se cambi "attendi 100 ms"?

Il tempo di attesa è in millisecondi (ms) e 1000 ms sono un secondo. I due blocchi di attesa del progetto sono a 100 ms, quindi il LED resta acceso 0,1 secondi e spento 0,1 secondi. Un ciclo completo dura 200 ms: il LED lampeggia cinque volte al secondo. Se aumenti il numero in entrambi i blocchi il LED rallenta, se lo diminuisci accelera. Sotto una certa soglia l'occhio non distingue più i lampeggi e il LED sembra sempre acceso. La tabella mostra cosa vedrai cambiando le due attese:

Far crescere il programma: due LED, semaforo, lampeggiante della polizia

Se sai far lampeggiare un LED, per gestirne diversi non ti serve niente di nuovo: ripeti gli stessi tre blocchi con altri pin. Nel progetto Due LED lampeggianti alternati nel setup diventano uscite due pin: 8 e 9. Dentro ripeti per sempre ci sono "scrivi ALTO sul pin 8" e "scrivi BASSO sul pin 9", poi "attendi 200 ms". Dopo si scrive il contrario e si aspettano di nuovo 200 ms. Il trucco è che i due blocchi di scrittura vengono eseguiti uno dopo l'altro senza attesa in mezzo, quindi i due LED sembrano scambiarsi nello stesso istante. Il blocco di attesa decide quanto dura ogni stato.

Il progetto Semaforo porta la stessa idea a tre LED: rosso su D2, giallo su D3, verde su D4. Il gruppo ripeti per sempre ha quattro fasi e tutte seguono lo stesso schema: un blocco scrivi ALTO o BASSO per ciascuno dei tre LED, poi un blocco di attesa. I blocchi di scrittura decidono quale LED resta acceso, quello di attesa per quanto tempo. Più blocchi non lo rendono più difficile, solo più lungo. Una versione con pulsante pedonale, più vicina a un incrocio reale, è nell'articolo semaforo con Arduino.

1// Trafik Lambası (proje 3) / Traffic Light (project 3)
2void setup() {
3  pinMode(2,OUTPUT);    // Kırmızı / Red
4  pinMode(3,OUTPUT);    // Sarı / Yellow
5  pinMode(4,OUTPUT);    // Yeşil / Green
6}
7
8void loop() {
9  // Kırmızı yanar, 2 s bekle / Red on, wait 2 s
10  digitalWrite(2,HIGH);
11  digitalWrite(3,LOW);
12  digitalWrite(4,LOW);
13  delay(2000);
14  // Sarı yanar, 0,3 s bekle / Yellow on, wait 0.3 s
15  digitalWrite(2,LOW);
16  digitalWrite(3,HIGH);
17  digitalWrite(4,LOW);
18  delay(300);
19  // Yeşil yanar, 2 s bekle / Green on, wait 2 s
20  digitalWrite(2,LOW);
21  digitalWrite(3,LOW);
22  digitalWrite(4,HIGH);
23  delay(2000);
24  // Sarı yanar, sonra başa (kırmızıya) dön / Yellow on, then back to red
25  digitalWrite(2,LOW);
26  digitalWrite(3,HIGH);
27  digitalWrite(4,LOW);
28  delay(300);
29}
30

Nel progetto Lampeggiante della polizia a LED compaiono due nuovi tipi di blocco. Il primo è il gruppo variabili globali (all’inizio) con il blocco "dichiara intero (int) delayTime = 60". È la riga int delayTime = 60; del codice e dà un nome al tempo di lampeggio. Poiché i blocchi di attesa usano delayTime invece di un numero, per cambiare la velocità modifichi solo il 60 e non quattro blocchi diversi. Il secondo è il blocco verde "ripeti 3 volte": esegue tre volte i quattro blocchi che contiene e in C++ diventa il ciclo for(int i=0;i<3;i++).

Facciamo i conti: a ogni lampo il LED rosso resta acceso 60 ms e spento 60 ms, quindi un lampo dura 120 ms. Tre lampi fanno 360 ms, e lo stesso vale per il LED blu. Un ciclo completo dura circa 0,7 secondi. Con delayTime a 30 lampeggia due volte più veloce, con 120 più lento. Variabili e cicli sono l'argomento della parte 4 della serie; li vediamo in dettaglio in "ripeti per sempre", blocchi di conteggio e array. Il progetto LED in sequenza, che fa scorrere la luce lungo una fila di LED, è il passo successivo sulla stessa strada.

La stessa idea su ESP32 e Raspberry Pi Pico

Sull'ESP32 i blocchi sono quasi identici a quelli di Arduino, perché anche l'ESP32 si programma in C++ con l'Arduino IDE. Nel progetto LED lampeggiante con ESP32 il LED è sul GPIO 5 e i blocchi di attesa sono da 500 ms. Anche le righe di codice sono le stesse: pinMode(5, OUTPUT); digitalWrite(5, HIGH); delay(500);. Le uniche differenze sono il numero del pin, i 3,3 V forniti dai pin dell'ESP32 e la scelta di una scheda ESP32 nell'Arduino IDE. Tutto quello che impari sull'Uno si trasferisce direttamente sull'ESP32.

Nei progetti per Raspberry Pi Pico i blocchi diventano codice MicroPython e i nomi dei blocchi cambiano un po'. Nel progetto LED esterno con il Pico il LED è su GP14. Il blocco "pin led : GP LED_PIN, USCITA" corrisponde a led = Pin(LED_PIN, Pin.OUT), "accendi (on) il pin led" a led.on(), "attendi 0.5 secondi" a time.sleep(0.5) e ripeti per sempre al ciclo while True:. Attenzione: in MicroPython l'attesa è in secondi, non in millisecondi; il delay(500) di Arduino qui diventa time.sleep(0.5). Se vuoi provare senza nessun cavo, il progetto LED integrato del Pico accende il LED su GP25 direttamente sulla scheda; sul Pico W al LED integrato si accede con il nome "LED" invece di GP25.

1# Pico harici LED (proje 8163), seri port satırları çıkarıldı
2# Pico external LED (project 8163), serial print lines removed
3from machine import Pin
4import time
5
6LED_PIN = 14                    # GP14, herhangi bir boş GPIO / any free GPIO
7led = Pin(LED_PIN, Pin.OUT)     # pini çıkış yap / set the pin as output
8
9while True:                     # sürekli tekrarla / loop forever
10    led.on()                    # LED'i yak / turn the LED on
11    time.sleep(0.5)             # 0,5 saniye bekle / wait 0.5 s
12    led.off()                   # LED'i söndür / turn the LED off
13    time.sleep(0.5)
14

Errori comuni e come risolverli

Passo passo nell'app: dai blocchi alla scheda

1. In BlueGrays, apri il progetto LED lampeggiante, che ha il badge dei blocchi nell'elenco dei progetti. Con il filtro puoi anche mostrare solo i progetti con blocchi.
2. Seguendo lo schema, monta sulla breadboard il LED, la resistenza da 220 Ω e due cavi.
3. Nella sezione del codice attiva Mostra a blocchi. Al posto del codice compaiono i blocchi; toccando l'immagine si apre a schermo intero.
4. Passa alla scheda Capire i blocchi. Il programma viene spiegato passo dopo passo e in ogni passo vedi solo i suoi blocchi e cosa fanno.
5. Disattiva l'interruttore per tornare al codice vero, copialo e incollalo nell'Arduino IDE. I blocchi non vengono caricati direttamente sulla scheda; sulla scheda va sempre questo codice.
6. Nell'Arduino IDE scegli Arduino Uno come scheda e la porta giusta, poi premi Carica. Se non hai ancora l'IDE, l'articolo installare Arduino IDE ti guida passo passo.
7. Quando il LED lampeggia, cambia le due righe delay(100) in delay(1000), ricarica e guarda la differenza con i tuoi occhi.

In questo articolo il LED ha sempre lampeggiato con lo stesso ritmo; il programma non ascoltava nulla dal mondo esterno. Il passo successivo è far prendere decisioni alla scheda: la parte 3 della serie, il pulsante e il blocco "se", mostra un programma che accende il LED quando premi un pulsante e come quel blocco diventa un if/else in C++.

Nell'app BlueGrays puoi guardare LED lampeggiante, Due LED lampeggianti alternati, Semaforo, Lampeggiante della polizia a LED e i progetti LED per ESP32 e Pico con schema e codice, passare alla versione a blocchi dello stesso programma con Mostra a blocchi e leggere cosa fa ogni passo con Capire i blocchi.