Effetto Supercar con Arduino: LED in sequenza, circuito e codice

L'effetto Supercar con Arduino è un classico gioco di luci in cui una fila di LED si accende uno dopo l'altro, scorrendo da un'estremità all'altra e tornando indietro, proprio come la luce frontale di KITT, l'auto parlante della famosa serie anni '80 Supercar (Knight Rider in originale). Ti bastano un Arduino Uno, 6 o 8 LED, una resistenza da 220 Ω per ogni LED e qualche cavetto jumper. Se la luce scorre in una sola direzione e poi riparte dall'inizio, si parla di LED in sequenza o luci rincorrenti. Sono due progetti classici che si fanno subito dopo il semaforo, e il modo più divertente per imparare due degli strumenti più importanti della programmazione: gli array e il ciclo for.

In questa guida monterai il circuito e scriverai prima il codice dei LED in sequenza, poi quello dell'effetto Supercar che va avanti e indietro. Poi regolerai la velocità con un potenziometro, aggiungerai un effetto in cui i LED si accumulano a un'estremità e farai girare lo stesso effetto con millis(), senza mai bloccare il codice. Nelle ultime sezioni vedrai come pilotare 8 LED con soli 3 pin usando il chip 74HC595, come realizzare un effetto Supercar con scia da un unico pin con i LED indirizzabili WS2812B, le versioni per ESP32 e Raspberry Pi Pico (MicroPython) e le soluzioni agli errori più comuni.

Che cos'è l'effetto Supercar e che differenza c'è con i LED in sequenza?

Nella serie, la luce rossa sul paraurti anteriore di KITT scorre senza sosta da sinistra a destra, come un occhio che scruta. In elettronica questo effetto si chiama anche scanner Larson (Larson scanner), dal nome del produttore della serie, Glen A. Larson; gli occhi dei robot Cylon della sua altra serie, Galactica, funzionano allo stesso modo. Nello scanner vero, dietro il punto acceso si vede una traccia rossa che si spegne lentamente, una scia. In un semplice circuito a LED ogni LED è o tutto acceso o tutto spento; per imitare la scia bisogna abbassare la luminosità dei LED in modo graduale con il PWM. Lo faremo più avanti con i WS2812B e l'ESP32. La tabella riassume gli effetti che programmerai in questo articolo e quanti passi dura un giro con 8 LED.

Materiali e scelta della resistenza

Un LED non limita da solo la propria corrente, quindi ogni LED ha una resistenza in serie. Il valore si calcola con la legge di Ohm: R = (tensione di alimentazione − tensione diretta del LED) / corrente. Un LED rosso ha una tensione diretta di circa 2 V, quindi a 5 V con 220 Ω la corrente è (5 − 2) / 220 ≈ 13,6 mA. Il LED si accende bello luminoso e resti sotto i 20 mA consigliati per un pin di Arduino. Nell'effetto ad accumulo, quando tutti e otto i LED sono accesi insieme, la corrente totale è di circa 109 mA, ancora entro il limite di 200 mA che l'Uno accetta sommando tutti i pin. Per riconoscere una resistenza da 220 Ω dalle sue fasce colorate usa lo strumento codice colori delle resistenze; per altri colori e tensioni, il calcolatore di resistenza per LED.

Collegamenti: 8 LED e un potenziometro

La gamba lunga (anodo) di ogni LED va a un pin digitale della scheda attraverso una resistenza, la gamba corta (catodo) va a GND. Sulla breadboard la soluzione più ordinata è collegare il pin GND di Arduino alla linea blu (−) e portare lì le gambe corte di tutti e otto i LED. Disponi i LED a distanza regolare, da sinistra a destra nell'ordine dei pin: così l'ordine dell'array nel codice corrisponde all'ordine reale della luce. Le due gambe esterne del potenziometro vanno a 5V e GND, quella centrale (il cursore) va ad A0. La tabella mostra i pin usati da tutti i codici di questo articolo; se usi 6 LED, salta le ultime due righe dei LED e cancella gli ultimi due pin dall'array nel codice. Puoi vedere la piedinatura della tua scheda con lo strumento Pinout.

Passo 1: codice dei LED in sequenza con array e ciclo for

Potresti scrivere otto righe pinMode e sedici righe digitalWrite per otto LED, ma il codice si allunga e cambiare il numero di LED diventa scomodo. Invece metti i numeri dei pin in un array e lo percorri in ordine con un ciclo for. Il primo elemento dell'array è LEDS[0], cioè D2; l'ultimo è LEDS[7], cioè D9. Così lo stesso codice funziona senza modifiche con 6, 8 o 12 LED: cambi solo l'array. Trovi le basi di array e cicli spiegate più in dettaglio in Basi di programmazione Arduino.

1// Yürüyen LED: 8 LED sırayla yanar / Running light: 8 LEDs light up one after another
2const int LEDS[] = {2, 3, 4, 5, 6, 7, 8, 9};             // LED pinleri / LED pins
3const int LED_SAYISI = sizeof(LEDS) / sizeof(LEDS[0]);  // dizideki LED sayısı (8) / number of LEDs (8)
4const int BEKLE = 100;                                  // adım süresi (ms) / step time (ms)
5
6void setup() {
7  for (int i = 0; i < LED_SAYISI; i++) {
8    pinMode(LEDS[i], OUTPUT);                           // tüm LED pinleri çıkış / all LED pins as outputs
9  }
10}
11
12void loop() {
13  for (int i = 0; i < LED_SAYISI; i++) {
14    digitalWrite(LEDS[i], HIGH);                        // sıradaki LED'i yak / light the next LED
15    delay(BEKLE);
16    digitalWrite(LEDS[i], LOW);                         // söndür ve devam et / turn it off and move on
17  }
18}

Con BEKLE (il tempo di passo) a 100 ms la luce attraversa gli otto LED in 0,8 secondi e riparte subito. Se lo abbassi a 30 ms lo scorrimento diventa velocissimo; se lo alzi a 300 ms sembra lento, come lampade che si accendono una alla volta. Per caricare lo sketch scegli scheda e porta nel menu Strumenti e premi Carica; se il caricamento non va a buon fine, segui la lista di controllo in Arduino non carica lo sketch.

Passo 2: codice dell'effetto Supercar (avanti e indietro)

Per l'effetto Supercar la luce deve tornare indietro quando arriva all'estremità destra. Lo fai con due cicli: il primo conta da sinistra a destra, il secondo da destra a sinistra. Il punto delicato sono i LED alle estremità. Se entrambi i cicli contano per intero da 0 a 7 e da 7 a 0, il LED di destra si accende una volta alla fine del ciclo di andata e un'altra all'inizio di quello di ritorno; la luce resta il doppio del tempo alle estremità e il movimento sembra scattoso. Per questo il ciclo di andata si ferma a 6 e quello di ritorno a 1. Così ogni giro dura esattamente 14 passi e la luce resta alle estremità quanto al centro. Abbiamo anche spostato le tre righe che accendono e spengono un LED in una piccola funzione chiamata yakSondur() ("accendi e spegni"): il codice diventa più corto e più leggibile.

1// Karaşimşek (Knight Rider): ışık iki uç arasında gidip gelir / light bounces between the two ends
2const int LEDS[] = {2, 3, 4, 5, 6, 7, 8, 9};
3const int LED_SAYISI = sizeof(LEDS) / sizeof(LEDS[0]);
4const int BEKLE = 80;                                   // adım süresi (ms) / step time (ms)
5
6void yakSondur(int i) {
7  digitalWrite(LEDS[i], HIGH);
8  delay(BEKLE);
9  digitalWrite(LEDS[i], LOW);
10}
11
12void setup() {
13  for (int i = 0; i < LED_SAYISI; i++) pinMode(LEDS[i], OUTPUT);
14}
15
16void loop() {
17  for (int i = 0; i < LED_SAYISI - 1; i++) {           // soldan sağa: 0..6 / left to right: 0..6
18    yakSondur(i);
19  }
20  for (int i = LED_SAYISI - 1; i > 0; i--) {           // sağdan sola: 7..1 / right to left: 7..1
21    yakSondur(i);
22  }
23}

Passo 3: regolare la velocità con un potenziometro

Invece di modificare il codice e ricaricarlo ogni volta che vuoi un'altra velocità, puoi usare un potenziometro. Un potenziometro è un partitore di tensione: la tensione sulla gamba centrale varia tra 0 e 5 V a seconda della posizione dell'albero, e analogRead() la trasforma in un numero tra 0 e 1023. map(deger, 0, 1023, 400, 20) converte quel numero in un tempo di passo tra 400 e 20 ms; dato che l'intervallo è scritto al contrario, più alto è il valore letto, più corto è il passo e più veloce va la luce. Il verso in cui girare per accelerare dipende da quale gamba esterna hai collegato a 5V; se ti sembra al contrario, scambia i due fili esterni oppure inverti 400 e 20 in map(). Puoi leggere come funziona un potenziometro all'interno in Che cos'è un potenziometro?.

1// Hız ayarlı karaşimşek: potansiyometre adım süresini belirler / Speed-adjustable Knight Rider: the pot sets the step time
2const int LEDS[] = {2, 3, 4, 5, 6, 7, 8, 9};
3const int LED_SAYISI = sizeof(LEDS) / sizeof(LEDS[0]);
4const int POT = A0;                                     // potansiyometrenin orta bacağı / pot wiper
5
6int adimSuresi() {
7  int deger = analogRead(POT);                          // 0–1023
8  return map(deger, 0, 1023, 400, 20);                  // değer büyüdükçe hızlanır / faster as the value rises
9}
10
11void yakSondur(int i) {
12  digitalWrite(LEDS[i], HIGH);
13  delay(adimSuresi());                                  // her adımda yeniden okunur / read again on every step
14  digitalWrite(LEDS[i], LOW);
15}
16
17void setup() {
18  for (int i = 0; i < LED_SAYISI; i++) pinMode(LEDS[i], OUTPUT);
19}
20
21void loop() {
22  for (int i = 0; i < LED_SAYISI - 1; i++) yakSondur(i);   // sağa / to the right
23  for (int i = LED_SAYISI - 1; i > 0; i--) yakSondur(i);   // sola / to the left
24}

In questa versione il tempo di passo viene riletto a ogni LED, quindi la velocità cambia non appena giri l'albero. Mentre delay() è in esecuzione, però, Arduino non può fare nient'altro: anche se giri l'albero a metà di un passo lento da 400 ms, la nuova velocità vale solo dal passo successivo. Per un effetto con pochi LED non è un problema, ma quando aggiungi un pulsante per cambiare modalità o letture di sensori devi passare al metodo con millis() del passo 5.

Passo 4: l'effetto ad accumulo

Nell'effetto ad accumulo la prima luce corre fino in fondo a destra e lì resta accesa. Anche la seconda corre, ma questa volta si ferma un posto più a sinistra; a ogni giro la destinazione si sposta di un LED verso sinistra finché tutta la barra è piena. Nel codice lo fai con due cicli annidati: quello esterno conta quanti LED si sono già accumulati (dolu, "pieno"), quello interno quanti passi corre la luce in questo giro. Il LED che raggiunge la sua destinazione (hedef) non viene spento; se ne occupa proprio la riga if (i < hedef). Con otto LED, riempire tutta la barra richiede 8 + 7 + 6 + ... + 1 = 36 passi.

1// Birikerek dolan efekt: her ışık en boş uca kadar gider ve orada kalır / Stacking effect: each light runs to the last free spot and stays
2const int LEDS[] = {2, 3, 4, 5, 6, 7, 8, 9};
3const int LED_SAYISI = sizeof(LEDS) / sizeof(LEDS[0]);
4const int BEKLE = 60;
5
6void setup() {
7  for (int i = 0; i < LED_SAYISI; i++) pinMode(LEDS[i], OUTPUT);
8}
9
10void loop() {
11  for (int dolu = 0; dolu < LED_SAYISI; dolu++) {       // dolu: sağda birikmiş LED sayısı / LEDs already stacked on the right
12    int hedef = LED_SAYISI - 1 - dolu;                  // bu turda ışığın duracağı yer / where the light stops this round
13    for (int i = 0; i <= hedef; i++) {
14      digitalWrite(LEDS[i], HIGH);
15      delay(BEKLE);
16      if (i < hedef) digitalWrite(LEDS[i], LOW);        // hedefte yanık kalır / stays lit at the target
17    }
18  }
19  delay(600);                                           // dolu çubuğu göster / show the full bar
20  for (int i = LED_SAYISI - 1; i >= 0; i--) {           // sağdan sola boşalt / empty from right to left
21    digitalWrite(LEDS[i], LOW);
22    delay(BEKLE);
23  }
24  delay(300);
25}

Alla fine dello sketch la barra piena resta visibile per 0,6 secondi, poi i LED si spengono uno alla volta da destra a sinistra e l'effetto ricomincia. Se vuoi una barra che si riempie più semplice, basta togliere il ciclo interno e accendere i LED in ordine senza mai spegnerli; questo aspetto è perfetto per un indicatore di carica o una barra del livello sonoro. Ricorda che in questo effetto tutti e otto i LED sono accesi insieme: finché ogni LED ha la sua resistenza, la luminosità non cala.

Passo 5: effetto Supercar non bloccante con millis()

Nel codice che usa delay(), Arduino si blocca per il tempo indicato a ogni passo; se nel frattempo qualcuno preme un pulsante, non se ne accorge. millis(), invece, restituisce i millisecondi trascorsi dall'accensione della scheda. La logica è questa: il loop gira di continuo, a ogni giro controlla se dall'ultimo passo è passato abbastanza tempo e, se sì, fa un solo passo ed esce subito. Nel codice qui sotto l'effetto Supercar e il LED integrato funzionano insieme come due compiti indipendenti: mentre la luce scorre alla velocità impostata dal potenziometro, il LED su D13 lampeggia una volta al secondo con il suo ritmo. Per approfondire, leggi Arduino millis() e delay().

1// millis() ile bekletmesiz karaşimşek + potansiyometre / Non-blocking Knight Rider with millis() + pot
2const int LEDS[] = {2, 3, 4, 5, 6, 7, 8, 9};
3const int LED_SAYISI = sizeof(LEDS) / sizeof(LEDS[0]);
4const int POT = A0;
5
6int konum = 0;                     // şu an yanan LED / the LED that is lit now
7int yon = 1;                       // +1 sağa, -1 sola / +1 right, -1 left
8unsigned long sonAdim = 0;         // son adımın zamanı / time of the last step
9unsigned long sonBlink = 0;        // dahili LED için / for the onboard LED
10
11void setup() {
12  for (int i = 0; i < LED_SAYISI; i++) pinMode(LEDS[i], OUTPUT);
13  pinMode(LED_BUILTIN, OUTPUT);    // Uno'da D13 / D13 on the Uno
14  digitalWrite(LEDS[konum], HIGH);
15}
16
17void loop() {
18  unsigned long simdi = millis();
19  unsigned long aralik = map(analogRead(POT), 0, 1023, 400, 20);   // adım süresi (ms) / step time (ms)
20
21  // Görev 1: karaşimşek / Task 1: Knight Rider
22  if (simdi - sonAdim >= aralik) {          // taşmaya karşı güvenli / overflow-safe
23    sonAdim = simdi;
24    digitalWrite(LEDS[konum], LOW);
25    konum += yon;
26    if (konum == LED_SAYISI - 1 || konum == 0) yon = -yon;   // uçta yön değiştir / reverse at the ends
27    digitalWrite(LEDS[konum], HIGH);
28  }
29
30  // Görev 2: dahili LED kendi temposunda yanıp söner / Task 2: the onboard LED blinks at its own pace
31  if (simdi - sonBlink >= 500) {
32    sonBlink = simdi;
33    digitalWrite(LED_BUILTIN, !digitalRead(LED_BUILTIN));
34  }
35  // Buraya buton, sensör ya da seri port kodu eklenebilir / button, sensor or serial code can go here
36}

Qui contano due dettagli. Primo, le variabili di tempo devono essere unsigned long; se usi int, sull'Uno il valore va in overflow dopo circa 32,7 secondi e la temporizzazione si guasta: l'effetto si ferma oppure accelera senza controllo. Secondo, il confronto si fa con una sottrazione nella forma simdi - sonAdim >= aralik (adesso meno l'ultimo passo, confrontato con l'intervallo); questo metodo continua a funzionare correttamente anche quando millis() torna a zero, all'incirca ogni 49,7 giorni. Dato che teniamo posizione e direzione della luce in due variabili (konum e yon), non ci sono più cicli: a ogni passo la posizione sale o scende di uno e, alle estremità, la direzione cambia segno.

8 LED con 3 pin usando il 74HC595

Otto LED occupano otto pin dell'Uno; quando vuoi aggiungere al progetto un display LCD, sensori e pulsanti, i pin cominciano a mancare. Il registro a scorrimento 74HC595 pilota le sue otto uscite con soli tre pin di Arduino (dati, clock e latch). Lo stato di ogni LED è un bit di un byte: l'espressione 1 << i mette a 1 solo il bit i, cioè accende un solo LED. Con le operazioni sui bit è facile anche creare motivi: (1 << i) | (0x80 >> i) produce due luci che arrivano contemporaneamente dalle due estremità verso il centro. Collegando in cascata due chip puoi fare persino un effetto Supercar da 16 LED con gli stessi tre pin; il collegamento in cascata, il pilotaggio veloce via SPI e l'uso con i display a 7 segmenti sono spiegati passo per passo nell'articolo Registro a scorrimento 74HC595.

1// 74HC595 ile 3 pinden 8 LED: karaşimşek ve ortada buluşma / 8 LEDs from 3 pins with a 74HC595: Knight Rider and meet-in-the-middle
2const int DATA_PIN = 11;    // DS (14)
3const int CLOCK_PIN = 13;   // SH_CP (11)
4const int LATCH_PIN = 10;   // ST_CP (12)
5const int POT = A0;
6
7void yaz595(byte desen) {
8  digitalWrite(LATCH_PIN, LOW);
9  shiftOut(DATA_PIN, CLOCK_PIN, MSBFIRST, desen);   // 8 biti gönder / send the 8 bits
10  digitalWrite(LATCH_PIN, HIGH);                    // çıkışlara aktar / copy to the outputs
11}
12
13void setup() {
14  pinMode(DATA_PIN, OUTPUT);
15  pinMode(CLOCK_PIN, OUTPUT);
16  pinMode(LATCH_PIN, OUTPUT);
17  yaz595(0);                                        // açılışta hepsi sönük / all off at startup
18}
19
20void loop() {
21  int bekle = map(analogRead(POT), 0, 1023, 400, 20);
22
23  for (int i = 0; i < 7; i++) { yaz595(1 << i); delay(bekle); }   // Q0 -> Q7
24  for (int i = 7; i > 0; i--) { yaz595(1 << i); delay(bekle); }   // Q7 -> Q0
25
26  for (int i = 0; i < 4; i++) {                     // uçlardan ortaya / from the ends to the middle
27    yaz595((1 << i) | (0x80 >> i));
28    delay(bekle);
29  }
30  for (int i = 3; i >= 0; i--) {                    // ortadan uçlara / from the middle to the ends
31    yaz595((1 << i) | (0x80 >> i));
32    delay(bekle);
33  }
34}

Sulle uscite del 74HC595 si consiglia 470 Ω invece di 220 Ω: la corrente totale che passa dai pin VCC e GND del chip non dovrebbe superare 70 mA. Con 470 Ω scorrono circa 6,4 mA per LED e, anche con tutti e otto i LED accesi, il totale resta a 51 mA. Nell'effetto Supercar comunque sono accesi solo uno o due LED alla volta, quindi i LED si vedono bene lo stesso.

Effetto Supercar con scia da un solo pin con i WS2812B

La versione che somiglia di più al vero scanner di KITT si realizza con i LED indirizzabili WS2812B. Ogni WS2812B ha il suo driver integrato; per quanto lunga sia la striscia, imposti colore e luminosità di ogni LED separatamente con un unico filo dati. Per la scia teniamo un array: a ogni passo la luminosità di tutti i LED viene divisa per tre e il LED di testa viene portato a 255. Così i LED dietro si spengono rapidamente passando per 255, 85, 28 e 9, e dietro la luce si forma una scia naturale. Se dividi per 2 invece che per 3 la scia si allunga, con 5 si accorcia. Per passare da 8 a 60 LED con lo stesso metodo basta cambiare il valore di NUM_LEDS.

1// WS2812B ile kuyruklu karaşimşek (tek veri pini) / Knight Rider with a fading tail on WS2812B (one data pin)
2#include <Adafruit_NeoPixel.h>
3
4const int DATA_PIN = 6;      // DIN, 330 Ω üzerinden / DIN through 330 Ω
5const int NUM_LEDS = 8;      // şerit ya da çubuktaki LED sayısı / LEDs on the strip or stick
6const int POT = A0;
7
8Adafruit_NeoPixel strip(NUM_LEDS, DATA_PIN, NEO_GRB + NEO_KHZ800);
9
10uint8_t seviye[NUM_LEDS];    // her LED'in kırmızı parlaklığı / red brightness of each LED
11int konum = 0;
12int yon = 1;
13
14void setup() {
15  strip.begin();
16  strip.setBrightness(80);   // 0–255; USB için düşük tut / keep it low on USB power
17  strip.show();              // hepsini söndür / all off
18}
19
20void loop() {
21  for (int i = 0; i < NUM_LEDS; i++) seviye[i] = seviye[i] / 3;   // kuyruk söner / the tail fades
22  seviye[konum] = 255;                                            // baştaki LED tam parlak / the head is full brightness
23
24  for (int i = 0; i < NUM_LEDS; i++) {
25    strip.setPixelColor(i, strip.Color(seviye[i], 0, 0));         // yalnız kırmızı / red only
26  }
27  strip.show();
28
29  konum += yon;
30  if (konum == NUM_LEDS - 1 || konum == 0) yon = -yon;            // uçta yön değiştir / reverse at the ends
31  delay(map(analogRead(POT), 0, 1023, 150, 20));
32}

Effetto Supercar con ESP32: scia in PWM su ogni pin

Sull'Uno un effetto Supercar con scia è difficile da fare con LED normali, perché il PWM c'è solo sui pin 3, 5, 6, 9, 10 e 11, e nel nostro array D2–D9 ce ne sono solo quattro. Sull'ESP32, grazie all'hardware LEDC, quasi ogni pin di uscita può generare PWM, e l'ESP32 classico ha 16 canali PWM. Dato che analogWrite() funziona direttamente nel core Arduino attuale per ESP32, puoi applicare la logica della scia dei WS2812B a LED normali. I pin della tabella sono GPIO sicuri che non influiscono sull'avvio; il potenziometro va al GPIO 34 sul canale ADC1, che legge bene anche con il Wi-Fi attivo, e poiché l'ADC dell'ESP32 è a 12 bit il valore va da 0 a 4095. I pin dell'ESP32 forniscono 3,3 V, quindi con 220 Ω in un LED rosso scorrono circa 6 mA; i LED appaiono un po' meno luminosi che sull'Uno. Per preparare la scheda, leggi Che cos'è l'ESP32?.

1// ESP32: her pinde PWM ile kuyruklu karaşimşek / ESP32: Knight Rider with a PWM tail on every pin
2const int LEDS[] = {18, 19, 21, 22, 23, 25, 26, 27};
3const int LED_SAYISI = sizeof(LEDS) / sizeof(LEDS[0]);
4const int POT = 34;                        // ADC1, yalnızca giriş / ADC1, input only
5
6int parlaklik[LED_SAYISI];                 // 0–255
7int konum = 0;
8int yon = 1;
9unsigned long sonAdim = 0;
10
11void setup() {
12  // analogWrite() pini PWM için kendisi hazırlar / analogWrite() sets the pin up for PWM itself
13}
14
15void loop() {
16  unsigned long aralik = map(analogRead(POT), 0, 4095, 400, 20);   // ESP32 ADC 12 bit: 0–4095
17  if (millis() - sonAdim >= aralik) {
18    sonAdim = millis();
19    for (int i = 0; i < LED_SAYISI; i++) parlaklik[i] /= 3;        // kuyruk söner / the tail fades
20    parlaklik[konum] = 255;
21    for (int i = 0; i < LED_SAYISI; i++) analogWrite(LEDS[i], parlaklik[i]);
22    konum += yon;
23    if (konum == LED_SAYISI - 1 || konum == 0) yon = -yon;
24  }
25}

Effetto Supercar con Raspberry Pi Pico e MicroPython

Sul Raspberry Pi Pico scrivi lo stesso effetto in poche righe di MicroPython. Tenere gli oggetti Pin in una lista svolge lo stesso compito dell'array su Arduino. time.ticks_ms() e time.ticks_diff() sono gli equivalenti in MicroPython di millis() e della sottrazione sicura contro l'overflow. Il potenziometro va a GP26 (ADC0); read_u16() restituisce un valore da 0 a 65535 e il codice lo converte in 400–20 ms. Si consiglia che la corrente totale prelevata da tutti i GPIO del Pico resti sotto i 50 mA; per questo in tabella abbiamo scelto 330 Ω: scorrono circa 4 mA per LED e, anche con tutti e otto accesi, il totale si aggira sui 32 mA. Il progetto Supercar per Pico di BlueGrays usa 6 LED sui pin GP9–GP14; se hai montato quel circuito, ti basta cambiare la lista PINLER in [9, 10, 11, 12, 13, 14]. Per l'installazione e il caricamento con Thonny, leggi Che cos'è il Raspberry Pi Pico?.

1# Raspberry Pi Pico: potansiyometreyle hız ayarlı karaşimşek / Pico: Knight Rider with pot speed control
2from machine import Pin, ADC
3import time
4
5PINLER = [8, 9, 10, 11, 12, 13, 14, 15]        # GP8–GP15
6leds = [Pin(p, Pin.OUT) for p in PINLER]
7pot = ADC(26)                                   # GP26 = ADC0
8
9def adim_suresi():
10    # read_u16: 0–65535 -> 400–20 ms
11    return 400 - pot.read_u16() * 380 // 65535
12
13konum, yon = 0, 1
14leds[konum].on()
15son = time.ticks_ms()
16
17while True:
18    if time.ticks_diff(time.ticks_ms(), son) >= adim_suresi():   # millis() benzeri / like millis()
19        son = time.ticks_ms()
20        leds[konum].off()
21        konum += yon
22        if konum == len(leds) - 1 or konum == 0:
23            yon = -yon                          # uçta yön değiştir / reverse at the ends
24        leds[konum].on()

Anche ogni GPIO del Pico può generare PWM; con machine.PWM e un valore duty_u16() per ogni LED puoi portare l'effetto scia dell'ESP32 sul Pico. Se vuoi usare i WS2812B, il modulo neopixel integrato in MicroPython pilota una striscia da un solo GPIO; però un WS2812B alimentato a 5 V non sempre legge in modo affidabile il segnale dati a 3,3 V del Pico, quindi se i colori impazziscono aggiungi un traslatore di livello in mezzo.

Idee di progetti con l'effetto Supercar

• Vu meter (indicatore di livello sonoro): decidi quanti LED della barra si accendono in base al volume misurato con il sensore di suono KY-038.
• Barra LED per sensore di parcheggio: accendi più LED man mano che la distanza misurata con l'HC-SR04 diminuisce, e falli lampeggiare tutti quando sei vicinissimo.
• Gioco "acchiappa la luce": mentre la luce va avanti e indietro veloce, prova a premere un pulsante proprio quando si accende il LED centrale; a ogni centro accorcia il tempo di passo.
• Decorazione notturna automatica: fai partire l'effetto da solo quando una fotoresistenza (LDR) rileva che fa buio.
• Luce posteriore per modellino o bicicletta: crea un effetto Supercar rosso con scia su uno stick WS2812B e accendi tutti i LED al massimo quando premi il pulsante del freno.
• Indicatore di livello: mostra la posizione di un potenziometro o la tensione di una batteria come una barra che si riempie.
• Display più grandi: porta la stessa logica su una matrice LED MAX7219 o su un cubo di LED.

Errori comuni e come risolverli

L'effetto Supercar sembra semplice, ma contiene idee di base che userai poi in ogni progetto: array, cicli, letture analogiche, map(), temporizzazione non bloccante, operazioni sui bit e LED indirizzabili. Come passo successivo dai un'occhiata al progetto semaforo con Arduino o all'elenco di idee per progetti Arduino. Nell'app BlueGrays trovi i LED in sequenza, l'effetto Supercar e le loro versioni a velocità regolabile, gli effetti ad accumulo e Supercar con WS2812B e i progetti LED in sequenza con ESP32 e Supercar con Pico, ognuno con schema passo passo e codice pronto da provare sulla tua scheda.