Cicli e variabili nella programmazione a blocchi con Arduino

I cicli e le variabili nella programmazione a blocchi sono i due mattoncini che trasformano un programma da "fallo una volta" a "fallo sempre, e con criterio". Un ciclo esegue gli stessi blocchi più e più volte, e una variabile ricorda un numero mentre queste ripetizioni avvengono. Nei blocchi di BlueGrays compaiono come "ripeti per sempre", "conta con i", "variabili globali (all’inizio)" e "imposta … a"; nel codice Arduino che finisce sulla scheda, i loro equivalenti sono loop(), il ciclo for, una variabile int e una riga di assegnazione.

In questa parte leggiamo i blocchi di quattro progetti gratuiti accanto al loro vero codice C++: LED in sequenza, che accende sei LED uno dopo l'altro; LED in sequenza a velocità regolabile, che prende la velocità da un potenziometro; Effetto Supercar con LED, che porta la luce da un'estremità all'altra e indietro; e la sua versione con potenziometro, Effetto Supercar a velocità regolabile. Tutti e quattro usano lo stesso circuito: sei LED sui pin D2–D7 e un potenziometro su A0. Alla fine scriverai un tuo esempio di contatore e vedrai uno per uno i tre errori più frequenti di chi inizia: contare uno in più o uno in meno, uscire dall'array e le attese lunghe che rendono ciechi i pulsanti.

Il blocco "ripeti per sempre" e loop(): perché la scheda non si ferma mai?

Un programma sul computer si chiude quando ha finito il suo lavoro; un programma su Arduino no. La scheda non ha un sistema operativo e il processore non ha nient'altro da fare. Per questo tutti i progetti a blocchi hanno lo stesso scheletro: ciò che sta dentro "setup (una volta)" viene eseguito una sola volta quando la scheda si accende o si preme il pulsante di reset, mentre ciò che sta dentro "ripeti per sempre" si ripete dall'alto in basso senza sosta. Lato C++ sono le funzioni setup() e loop(). Quando l'ultima riga di loop() è finita, la scheda torna subito alla prima; un loop() breve e senza attese può girare decine di migliaia di volte al secondo. L'unico modo per fermare la scheda è togliere l'alimentazione o caricare un altro programma. Questa ripetizione infinita non è un difetto, è il progetto stesso: leggere un pulsante, controllare un sensore, accendere un LED, tutto viene rifatto a ogni giro, e così la scheda risponde di continuo a quello che cambia intorno a lei.

Variabili nella programmazione a blocchi: variabili globali e il blocco dichiara

Una variabile è una scatolina in cui metti un numero e che chiami per nome. Nei blocchi le variabili si creano dentro il blocco viola "variabili globali (all’inizio)". Il blocco "dichiara intero (int) potValue = 0" al suo interno diventa nel codice la riga int potValue: int è il tipo, potValue il nome e 0 il valore iniziale. "All’inizio" è importante: queste righe stanno in cima al file, fuori da setup() e da loop(). Una variabile globale dichiarata così è visibile da tutto il programma e non perde il suo valore ogni volta che loop() ricomincia. Su Arduino Uno un int occupa 2 byte e contiene i numeri interi da -32768 a 32767, più che sufficienti per l'intervallo 0–1023 di analogRead() e per i numeri dei pin. Forse noterai che i blocchi di LED in sequenza a velocità regolabile riportano potValue = 0, mentre il codice scrive solo int potValue;. Il risultato è lo stesso: in C++ una variabile globale senza valore iniziale parte da zero.

Il blocco che cambia una variabile in seguito è "imposta … a". Il blocco "imposta potValue a lettura analogica A0" diventa potValue = analogRead(A0); nel codice. Qui il segno = non è l'uguaglianza della matematica; vuol dire "calcola il valore a destra e mettilo nella scatola a sinistra". Un confronto che chiede se due valori sono uguali si scrive con == in C++, come abbiamo visto con il blocco se nella parte precedente della serie. Quando il blocco imposta viene eseguito, il vecchio valore viene cancellato e al suo posto viene scritto quello nuovo. Tutti i blocchi che leggono la variabile usano da quel momento il nuovo valore: "attendi potValue ms" aspetta tanti millisecondi quanti ne contiene potValue in quell'istante.

Il ciclo di conteggio: il blocco "conta con i" e il ciclo for di Arduino

Per ripetere qualcosa un numero fisso di volte si usa il blocco verde "conta con i da 0 a 5 per 1". Crea un contatore chiamato i, gli dà il valore 0, esegue i blocchi al suo interno, aggiunge 1 a i, li esegue di nuovo e continua così finché i non supera 5. Il suo equivalente Arduino è la riga for (int i = 0; i < 6; i++). Tra le parentesi ci sono tre parti separate da punto e virgola: l'inizio (int i = 0), la condizione per continuare (i < 6) e il passo dopo ogni giro (i++, cioè aggiungi uno a i). La cosa più importante: il valore finale del blocco è incluso. "Da 0 a 5" significa 0, 1, 2, 3, 4 e 5, quindi il ciclo fa 6 giri, non 5, e ognuno dei sei LED ha il suo. Per questo il codice scrive i < 6, che equivale a i <= 5. Lo schema "parti da zero e continua finché sei sotto il numero di elementi" è molto comune nel codice Arduino, perché il 6 indica direttamente quanti LED ci sono.

Il blocco array: "array 2 3 4 5 6 7" e ledPins[i]

Invece di dichiarare sei variabili per sei LED, puoi tenerli tutti in un'unica lista. Quando il blocco viola "array 2 3 4 5 6 7" viene agganciato a "dichiara intero (int) ledPins = …", diventa nel codice la riga int ledPins[] = {2, 3, 4, 5, 6, 7};. Le parentesi quadre dicono che è un array e le graffe contengono i suoi valori. A un elemento si arriva tramite la sua posizione, l'indice, e in C++ l'indice parte da 0: il primo elemento è ledPins[0] e l'ultimo ledPins[5]. Nei blocchi lo fa "elemento i di ledPins", che diventa ledPins[i]. Poiché anche il ciclo di conteggio parte da 0, i due si incastrano alla perfezione: a ogni giro i fornisce l'indice successivo e ledPins[i] il numero di pin che vi è salvato. Un altro vantaggio: per cambiare l'ordine dei LED basta scambiare i numeri nella lista, senza toccare il ciclo. Per approfondire, leggi gli array su Arduino.

LED in sequenza: blocchi e C++ riga per riga

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri, yanma sırasıyla / LED pins in lighting order
2
3void setup() {
4  // Tüm LED pinlerini çıkış yap / Set all LED pins as outputs
5  for(int i = 0; i < 6; i++) {
6    pinMode(ledPins[i], OUTPUT);
7  }
8}
9
10void loop() {
11  // Her LED'i sırayla 150 ms yak / Light each LED in turn for 150 ms
12  for(int i = 0; i < 6; i++) {
13    digitalWrite(ledPins[i], HIGH);
14    delay(150);
15    digitalWrite(ledPins[i], LOW);
16  }
17}

Immagina il programma come una linea del tempo. All'avvio, il ciclo nel setup imposta i sei pin come uscite uno alla volta, da 0 a 5, e questo non succede mai più. Poi parte ripeti per sempre: il ciclo di conteggio al suo interno accende il LED su D2, aspetta 150 ms, lo spegne e fa lo stesso con D3, D4, D5, D6 e D7. Un giro dura 6 × 150 = 900 ms. Quando l'ultimo LED si spegne, loop() finisce, la scheda torna subito all'inizio e la luce riparte da D2; dato che tra un giro e l'altro non c'è pausa, la luce sembra scorrere senza interruzioni. Per cambiare velocità basta cambiare un solo numero, il 150: con 50 la luce corre tre volte più veloce, con 500 passeggia con calma. Rendere regolabile con una manopola questa velocità fissa ci porta al progetto successivo.

LED in sequenza a velocità regolabile: il valore del potenziometro diventa l'attesa

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri, yanma sırasıyla / LED pins in lighting order
2int potValue;                         // Pot değeri = bekleme (ms) / Pot value = delay (ms)
3
4void setup() {
5  // Tüm LED pinlerini çıkış yap / Set all LED pins as outputs
6  for(int i = 0; i < 6; i++) {
7    pinMode(ledPins[i], OUTPUT);
8  }
9}
10
11void loop() {
12  for(int i = 0; i < 6; i++) {
13    potValue = analogRead(A0);        // Hızı oku (0-1023) / Read the speed (0-1023)
14    digitalWrite(ledPins[i], HIGH);
15    delay(potValue);                  // Pot değeri kadar ms bekle / Wait as many ms as the pot value
16    digitalWrite(ledPins[i], LOW);
17  }
18}

L'unica differenza rispetto ai LED in sequenza sono due blocchi nuovi. Alle variabili globali si aggiunge "dichiara intero (int) potValue = 0" e il ciclo di conteggio inizia con "imposta potValue a lettura analogica A0". analogRead(A0) trasforma la tensione sul pin centrale del potenziometro in un numero da 0 a 1023; quel numero va dritto ad "attendi potValue ms", cioè alla riga delay(potValue). Ruota la manopola verso un'estremità e ogni LED resta acceso circa un secondo (1023 ms), così un giro dura quasi 6 secondi; verso l'altra estremità l'attesa scende a 0 e i LED commutano così in fretta da sembrare tutti accesi debolmente nello stesso momento. Leggere il potenziometro dentro il ciclo, prima di ogni LED, è una scelta voluta: appena giri la manopola, il LED successivo usa già la nuova velocità, senza aspettare la fine del giro. Come funziona un potenziometro lo trovi in cos'è un potenziometro.

Supercar: due cicli che contano in avanti e all'indietro

Nell'effetto Supercar la luce va da un'estremità all'altra e torna indietro. I blocchi di Effetto Supercar con LED hanno due cicli di conteggio, uno sotto l'altro, dentro ripeti per sempre. Il primo è il già noto "conta con i da 0 a 5 per 1" e porta la luce da D2 a D7. Il secondo è "conta con i da 4 a 1 per 1": dato che l'inizio è più grande della fine, il blocco conta all'indietro e i vale 4, 3, 2, 1. Nel codice è la riga for(int i = 4; i > 0; i--); i-- toglie uno a i. Perché da 4 a 1 e non da 5 a 0? Perché ledPins[5] (D7) è già acceso alla fine dell'andata e ledPins[0] (D2) all'inizio di quella successiva. Saltare le estremità al ritorno evita che i LED alle punte si accendano due volte di fila, e il rimbalzo risulta fluido. Un'andata e ritorno sono 6 + 4 = 10 passi da 100 ms, 1 secondo in tutto. Effetto Supercar a velocità regolabile usa gli stessi due cicli; aggiunge solo "imposta potValue a lettura analogica A0" all'inizio di entrambi e usa "attendi potValue ms" al posto di 100 ms. Per altri motivi luminosi dai un'occhiata a effetto Supercar e LED in sequenza con Arduino.

Il tuo esempio di contatore: contagiri e porta seriale

Ora scriviamo un piccolo esempio che mette insieme tutto: ogni volta che i LED in sequenza finiscono un giro, un contatore aumenta e la scheda invia al computer sia i valori di i sia il numero di giri. Con i blocchi visti nelle immagini lo costruiresti così: sotto l'array ledPins, nelle variabili globali, si aggiunge "dichiara intero (int) rounds = 0". Nel setup entra il blocco "avvia seriale a 9600 baud". Dentro il ciclo di conteggio, prima di accendere il LED, alcuni blocchi "stampa su seriale" scrivono il testo "i = ", poi i e poi il testo " pin = " con l'opzione "stessa riga", e infine "elemento i di ledPins" con l'opzione "a capo". Dopo il ciclo di conteggio, sempre dentro ripeti per sempre, un blocco "imposta rounds a …" riceve la somma rounds + 1 e il numero di giri viene stampato con "stampa su seriale … a capo".

1int ledPins[] = {2, 3, 4, 5, 6, 7};   // LED pinleri / LED pins
2int rounds = 0;                       // tamamlanan tur sayısı / number of finished rounds
3
4void setup() {
5  Serial.begin(9600);                 // seri port 9600 baud / serial port at 9600 baud
6  for (int i = 0; i < 6; i++) {
7    pinMode(ledPins[i], OUTPUT);
8  }
9}
10
11void loop() {
12  for (int i = 0; i < 6; i++) {
13    Serial.print("i = ");             // aynı satırda kal / stay on the same line
14    Serial.print(i);
15    Serial.print("  pin = ");
16    Serial.println(ledPins[i]);       // alt satıra geç / new line
17    digitalWrite(ledPins[i], HIGH);
18    delay(300);
19    digitalWrite(ledPins[i], LOW);
20  }
21  rounds = rounds + 1;                // sayacı bir artır / add one to the counter
22  Serial.print("Tur / Round: ");
23  Serial.println(rounds);
24}

Dopo il caricamento apri il monitor seriale dell'Arduino IDE e impostalo a 9600 baud. A ogni giro vedrai sei righe, da "i = 0 pin = 2" a "i = 5 pin = 7", seguite da una riga "Tur / Round" che conta 1, 2, 3. Questo output è la prova più chiara che il valore finale del blocco conta è incluso: "da 0 a 5" produce esattamente sei valori. Nota anche che rounds è dichiarata nelle variabili globali; non viene azzerata a ogni inizio di loop() e porta con sé il suo valore da un giro all'altro. Un giro dura 6 × 300 = 1,8 secondi, quindi il limite di int, 32767, si raggiunge dopo circa 16 ore; se devi contare più a lungo, rendi la variabile unsigned long. Trovi altro sul monitor seriale in il monitor seriale di Arduino.

Circuito: 6 LED, resistenze da 220 Ω e un potenziometro

Una resistenza da 220 Ω fa scorrere circa (5 − 2) / 220 ≈ 14 mA in un LED rosso alimentato a 5 V, un valore sicuro sia per il LED sia per il pin di Arduino. Se usi LED di un altro colore, verifica la resistenza con il calcolatore di resistenza per LED. Raccogli tutti i catodi sulla linea GND della breadboard e collegala al pin GND di Arduino. Se inverti le gambe esterne del potenziometro non si rompe nulla; cambia solo il verso di rotazione. I LED in sequenza e l'effetto Supercar non usano il potenziometro, ma lasciarlo collegato non dà fastidio: così puoi provare i quattro progetti uno dopo l'altro sullo stesso circuito.

Errori comuni con cicli e variabili

Esplorare i blocchi di cicli e variabili nell'app BlueGrays

I quattro progetti di questo articolo e quelli qui sotto sono completamente gratuiti nell'app BlueGrays, blocchi e codice compresi. Nella sezione codice di un progetto attiva l'interruttore Mostra a blocchi: al posto del codice compaiono i blocchi dello stesso programma; tocca l'immagine per aprirla a schermo intero e ingrandire comodamente i cicli di conteggio più lunghi. La scheda Capire i blocchi ti guida nel programma passo per passo e a ogni passo mostra solo i suoi blocchi e cosa fanno. Altri progetti gratuiti da guardare a blocchi: Lampeggiante della polizia a LED, che funziona con una variabile delayTime e due cicli di conteggio; Semaforo, che attraversa quattro stati dentro ripeti per sempre; Misurare l'intensità luminosa con LDR, che tiene la lettura in una variabile e la stampa sulla porta seriale; e Accendere e spegnere un LED con un pulsante, che ricorda lo stato del LED in una variabile. Ogni esempio Arduino della Guida al codice è disponibile anche a blocchi, e le Domande del giorno ti aiutano a consolidare quello che hai imparato con 5 domande al giorno dal livello A1 al C2. L'elenco completo dei progetti a blocchi è nella pagina programmazione a blocchi. I blocchi non vengono caricati direttamente sulla scheda; sulla scheda va sempre il vero codice del progetto, quindi copi nell'Arduino IDE il programma che hai capito con i blocchi e lo carichi.

Ora che conosci cicli e variabili, il passo successivo è prendere questi numeri dal mondo reale: nella parte 5 della serie parliamo di lettura dei sensori con i blocchi, porta seriale e passaggio a MicroPython sul Pico. Nel frattempo, nell'app BlueGrays puoi guardare i LED in sequenza, l'effetto Supercar e le loro versioni a velocità regolabile con schema e codice, passare ai blocchi con Mostra a blocchi e alla spiegazione passo passo con Capire i blocchi, e seguire da solo a quale riga di codice corrisponde ogni ciclo di conteggio.