Lampeggiante polizia Arduino: LED, striscia WS2812B e sirena
Costruisci un lampeggiante polizia con Arduino: doppio e triplo flash con LED rossi e blu, codice senza delay con millis, barra WS2812B, sirena, ESP32 e Pico.
Un lampeggiante polizia con Arduino è uno dei primi progetti più divertenti per chi inizia: LED rossi e blu lampeggiano con un ritmo preciso e imitano la barra luminosa di un'auto della polizia. Si parte con due LED, due resistenze e poche righe di codice; con una barretta WS2812B diventa una vera barra luminosa e con un buzzer passivo arriva anche la sirena. Qui usiamo lo schema rosso-blu all'americana; per un lampeggiante all'italiana basta montare due LED blu. Perfetto per macchinine giocattolo, plastici, diorami e presentazioni a scuola.
In questa guida vedrai in una tabella, al millisecondo, gli schemi di doppio e triplo flash usati dalle barre luminose. Prima farai la versione più semplice con delay, poi scriverai un codice con millis() che fa funzionare luci e sirena insieme senza che l'una blocchi l'altra. Dopo costruirai una barra di otto LED WS2812B comandata da un solo pin e infine porterai lo stesso progetto su ESP32 e su Raspberry Pi Pico con MicroPython.

Come funziona un lampeggiante? Schemi di flash e tempi
Le barre luminose vere non restano accese a lungo: usano flash brevissimi e ravvicinati, perché l'occhio nota molto più facilmente lampi brevi e intensi. Ogni flash dura di solito 50–60 ms; un colore lampeggia due o tre volte, c'è una breve pausa e poi l'altro colore fa lo stesso. Per questo ogni schema nel codice è fatto di passi che rispondono alla domanda "quale LED è acceso, e per quanto tempo". I tempi della tabella sono esattamente quelli usati dagli sketch di questa guida; gioca pure con i numeri per creare il tuo schema.
| Schema | Passi per un lato | Durata del ciclo | Flash al secondo |
|---|---|---|---|
| Doppio flash | 60 ms acceso, 60 ms spento, 60 ms acceso, 180 ms spento | 720 ms | Circa 5,6 |
| Triplo flash | 3 × (50 ms acceso, 50 ms spento), pausa finale di 170 ms | 840 ms | Circa 7,1 |
| Alternato (wig-wag) | 250 ms rosso, 250 ms blu | 500 ms | 4 |
| Barra WS2812B | Doppio flash a sinistra e a destra, poi 4 × 150 ms di scambio esterno-interno | 1320 ms | Dipende dallo schema |
Materiale e collegamenti
| Componente | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| LED rosso (con resistenza) | D9 | GPIO 26 | GP11 |
| LED blu (con resistenza) | D10 | GPIO 27 | GP12 |
| Buzzer passivo | D8 | GPIO 25 | GP15 |
| Pulsante schema (verso GND) | D2 | - | - |
| Pulsante sirena (verso GND) | D3 | - | - |
| DIN della WS2812B (tramite 330 Ω) | D6 | - | - |
| Massa comune | GND | GND | GND |
Sulla breadboard la gamba lunga di ogni LED va al pin passando per la resistenza e quella corta a GND. Il valore della resistenza si ricava con R = (Valim - VLED) / I. Un LED rosso richiede circa 2,0 V e uno blu 3,0–3,2 V. Sull'uscita a 5 V dell'Uno una resistenza da 220 Ω fa passare (5 - 2) / 220 ≈ 13,6 mA nel LED rosso e circa 8,6 mA in quello blu, ed entrambi si vedono bene. ESP32 e Pico forniscono 3,3 V, quindi al LED blu resta pochissimo margine: 150 Ω per il rosso e 47–68 Ω per il blu funzionano meglio. Per calcolare i tuoi valori usa il calcolatore di resistenza per LED o la guida calcolare la resistenza di un LED. I pulsanti vengono letti con INPUT_PULLUP, quindi una gamba va al pin e l'altra direttamente a GND.
Prima prova: doppio flash con delay
1// En basit çakar: delay ile çift flaş / simplest police light: double flash with delay
2const int RED_PIN = 9;
3const int BLUE_PIN = 10;
4
5void flash(int pin) {
6 for (int i = 0; i < 2; i++) { // iki kısa flaş / two short flashes
7 digitalWrite(pin, HIGH);
8 delay(60);
9 digitalWrite(pin, LOW);
10 delay(60);
11 }
12 delay(120); // iki taraf arası boşluk / gap between the sides
13}
14
15void setup() {
16 pinMode(RED_PIN, OUTPUT);
17 pinMode(BLUE_PIN, OUTPUT);
18}
19
20void loop() {
21 flash(RED_PIN);
22 flash(BLUE_PIN);
23}La funzione flash() accende e spegne il pin due volte per 60 ms e poi aspetta altri 120 ms; così ogni lato dura 360 ms, come in tabella. Il codice è breve e facile da capire, ma ha un grosso difetto: mentre delay() è in corso, Arduino non può fare nient'altro. I pulsanti rispondono in ritardo, la sirena suona a scatti e non puoi gestire insieme due gruppi di luci a velocità diverse. Per questo nel passo successivo passiamo a una struttura che misura il tempo con millis() e non aspetta mai. Per le basi leggi la guida millis o delay.
Lampeggiante senza delay con millis e sirena
Nel metodo non bloccante ogni schema è un elenco di passi: ogni passo memorizza lo stato del LED rosso e di quello blu e quanti millisecondi dura. A ogni giro loop() si chiede soltanto "il passo attuale è finito?"; se sì, passa al successivo e aggiorna i LED. Nella stessa loop() la sirena cambia frequenza ogni 10 ms e vengono letti i pulsanti. Così i tre compiti procedono in parallelo e nessuno rallenta gli altri.
1// millis ile bekletmesiz çakar + siren / non-blocking police lights + siren with millis
2const int RED_PIN = 9;
3const int BLUE_PIN = 10;
4const int BUZZER_PIN = 8; // pasif buzzer / passive buzzer
5const int PATTERN_BTN = 2; // desen değiştir / change pattern
6const int SIREN_BTN = 3; // sireni aç-kapat / siren on-off
7
8struct Step { bool red; bool blue; uint16_t ms; };
9
10// Çift flaş / double flash: 720 ms
11const Step DOUBLE_FLASH[] = {
12 {1, 0, 60}, {0, 0, 60}, {1, 0, 60}, {0, 0, 180},
13 {0, 1, 60}, {0, 0, 60}, {0, 1, 60}, {0, 0, 180}
14};
15// Üçlü flaş / triple flash: 840 ms
16const Step TRIPLE_FLASH[] = {
17 {1, 0, 50}, {0, 0, 50}, {1, 0, 50}, {0, 0, 50}, {1, 0, 50}, {0, 0, 170},
18 {0, 1, 50}, {0, 0, 50}, {0, 1, 50}, {0, 0, 50}, {0, 1, 50}, {0, 0, 170}
19};
20// Sırayla yanıp sönme / alternating wig-wag: 500 ms
21const Step WIG_WAG[] = { {1, 0, 250}, {0, 1, 250} };
22
23struct Pattern { const Step* steps; uint8_t count; };
24const Pattern PATTERNS[] = {
25 {DOUBLE_FLASH, sizeof(DOUBLE_FLASH) / sizeof(Step)},
26 {TRIPLE_FLASH, sizeof(TRIPLE_FLASH) / sizeof(Step)},
27 {WIG_WAG, sizeof(WIG_WAG) / sizeof(Step)},
28};
29const uint8_t PATTERN_COUNT = sizeof(PATTERNS) / sizeof(Pattern);
30
31enum SirenMode { WAIL, YELP, HILO };
32const SirenMode SIREN = WAIL; // siren türü / siren type
33
34uint8_t pattern = 0;
35uint8_t step = 0;
36unsigned long stepStart = 0;
37bool sirenOn = false;
38unsigned long lastTone = 0;
39unsigned long lastPress = 0;
40bool lastPatternBtn = HIGH;
41bool lastSirenBtn = HIGH;
42
43void applyStep() {
44 const Step& s = PATTERNS[pattern].steps[step];
45 digitalWrite(RED_PIN, s.red);
46 digitalWrite(BLUE_PIN, s.blue);
47}
48
49void updateLights() {
50 const Pattern& p = PATTERNS[pattern];
51 if (millis() - stepStart >= p.steps[step].ms) { // adım süresi doldu mu? / step time over?
52 stepStart = millis();
53 step = (step + 1) % p.count;
54 applyStep();
55 }
56}
57
58void updateSiren() {
59 if (!sirenOn || millis() - lastTone < 10) return; // 10 ms'de bir güncelle / update every 10 ms
60 lastTone = millis();
61 unsigned long t = millis();
62 unsigned int freq;
63 if (SIREN == HILO) {
64 freq = (t / 500) % 2 ? 587 : 440; // iki ton / two tones
65 } else {
66 unsigned long period = (SIREN == WAIL) ? 4000 : 300;
67 unsigned long half = period / 2;
68 unsigned long phase = t % period;
69 unsigned long pos = phase < half ? phase : period - phase;
70 freq = 600 + (800UL * pos) / half; // 600-1400 Hz üçgen tarama / triangle sweep
71 }
72 tone(BUZZER_PIN, freq);
73}
74
75bool pressed(int pin, bool& last) {
76 bool now = digitalRead(pin);
77 bool fell = (last == HIGH && now == LOW && millis() - lastPress > 200);
78 if (fell) lastPress = millis();
79 last = now;
80 return fell;
81}
82
83void setup() {
84 pinMode(RED_PIN, OUTPUT);
85 pinMode(BLUE_PIN, OUTPUT);
86 pinMode(PATTERN_BTN, INPUT_PULLUP);
87 pinMode(SIREN_BTN, INPUT_PULLUP);
88 applyStep();
89}
90
91void loop() {
92 if (pressed(PATTERN_BTN, lastPatternBtn)) {
93 pattern = (pattern + 1) % PATTERN_COUNT;
94 step = 0;
95 stepStart = millis();
96 applyStep();
97 }
98 if (pressed(SIREN_BTN, lastSirenBtn)) {
99 sirenOn = !sirenOn;
100 if (!sirenOn) noTone(BUZZER_PIN);
101 }
102 updateLights();
103 updateSiren();
104}L'array PATTERNS contiene i tre schemi in ordine; ogni pressione del pulsante su D2 passa allo schema successivo e azzera il contatore dei passi. Il pulsante su D3 accende e spegne la sirena. La funzione pressed() conta solo il momento in cui il pulsante passa da HIGH a LOW e richiede 200 ms tra una pressione e l'altra, così i rimbalzi non vengono letti come pressioni multiple. Per cambiare tipo di sirena basta impostare la costante SIREN su WAIL, YELP o HILO. Aggiungendo una macchina a stati a questa struttura puoi creare modalità come "pattuglia", "inseguimento" e "in sosta".
Suono della sirena: wail, yelp e bitonale
| Tipo di sirena | Frequenza | Ciclo | Carattere |
|---|---|---|---|
| Wail (lunga) | 600 → 1400 → 600 Hz | Circa 4 s | Il classico suono che sale e scende lentamente, diffuso in tutto il continente americano |
| Yelp (veloce) | 600 → 1400 → 600 Hz | Circa 0,3 s | Il richiamo rapido usato agli incroci e nelle emergenze |
| Hi-lo (bitonale) | 440 Hz e 587 Hz | 0,5 s per tono | Simile alla sirena bitonale dei mezzi di soccorso in Italia e in Europa |
Barra luminosa WS2812B da un solo pin
Il risultato più simile a una vera barra luminosa lo ottieni con i LED indirizzabili. Su una barretta WS2812B da otto LED, i quattro a sinistra si accendono di rosso e i quattro a destra di blu, tutti comandati da un unico pin dati. Ogni passo del codice è composto da una maschera e da una durata: ogni bit della maschera rappresenta un LED. Per esempio 0x0F accende i quattro LED di sinistra, 0xF0 i quattro di destra e 0xC3 quelli alle estremità (0, 1, 6, 7). Installa la libreria Adafruit NeoPixel dal Gestore librerie.

1// WS2812B ışık çubuğu: tek pinden 8 LED / WS2812B light bar: 8 LEDs from one pin
2#include <Adafruit_NeoPixel.h>
3
4const int LED_PIN = 6;
5const int NUM_LEDS = 8; // 0-3 kırmızı, 4-7 mavi / 0-3 red, 4-7 blue
6Adafruit_NeoPixel bar(NUM_LEDS, LED_PIN, NEO_GRB + NEO_KHZ800);
7
8struct Step { uint8_t mask; uint16_t ms; }; // her bit bir LED / each bit is one LED
9
10const Step PATTERN[] = {
11 {0x0F, 60}, {0x00, 60}, {0x0F, 60}, {0x00, 180}, // sol çift flaş / left double flash
12 {0xF0, 60}, {0x00, 60}, {0xF0, 60}, {0x00, 180}, // sağ çift flaş / right double flash
13 {0xC3, 150}, {0x3C, 150}, {0xC3, 150}, {0x3C, 150} // dış-iç geçiş / outer-inner swap
14};
15const uint8_t STEP_COUNT = sizeof(PATTERN) / sizeof(Step);
16
17uint8_t step = 0;
18unsigned long stepStart = 0;
19
20void showMask(uint8_t mask) {
21 for (int i = 0; i < NUM_LEDS; i++) {
22 uint32_t color = (i < NUM_LEDS / 2) ? bar.Color(255, 0, 0) : bar.Color(0, 0, 255);
23 bar.setPixelColor(i, (mask >> i) & 1 ? color : 0);
24 }
25 bar.show();
26}
27
28void setup() {
29 bar.begin();
30 bar.setBrightness(80); // akımı sınırla / limit the current
31 showMask(PATTERN[0].mask);
32}
33
34void loop() {
35 if (millis() - stepStart >= PATTERN[step].ms) {
36 stepStart = millis();
37 step = (step + 1) % STEP_COUNT;
38 showMask(PATTERN[step].mask);
39 }
40}La funzione showMask() scorre gli otto LED, accende con il colore del proprio lato quelli con il bit a 1, spegne gli altri e alla fine invia tutto alla striscia in un colpo solo con bar.show(). Aggiungendo passi alla fine dello schema puoi creare facilmente effetti tuoi, che si aprono dal centro, ruotano o fanno lampeggiare tutta la barra. Con una striscia più lunga cambia NUM_LEDS e allarga le maschere a un tipo a 16 o 32 bit.
Lampeggiante polizia con ESP32
Sull'ESP32 i LED funzionano con la stessa logica di digitalWrite; cambia il modo di generare il suono. La sirena esce dalla funzione ledcWriteTone del controller LEDC. Nella versione 3.x del core Arduino per ESP32 il pin si collega direttamente con ledcAttach(pin, frequenza, risoluzione), mentre nella 2.x prima si configura un canale con ledcSetup e poi lo si associa al pin con ledcAttachPin. Il codice qui sotto separa i due casi con #if e quindi si compila con entrambe le versioni. Poiché l'ESP32 lavora a 3,3 V, ricorda la resistenza più piccola per il LED blu. Aggiungendo il Wi-Fi puoi accendere il lampeggiante dal telefono; per iniziare leggi cos'è l'ESP32.
1// ESP32 çakar + siren (çekirdek 2.x ve 3.x) / ESP32 police lights + siren (core 2.x and 3.x)
2const int RED_PIN = 26;
3const int BLUE_PIN = 27;
4const int BUZZER_PIN = 25;
5
6struct Step { bool red; bool blue; uint16_t ms; };
7const Step DOUBLE_FLASH[] = {
8 {1, 0, 60}, {0, 0, 60}, {1, 0, 60}, {0, 0, 180},
9 {0, 1, 60}, {0, 0, 60}, {0, 1, 60}, {0, 0, 180}
10};
11const uint8_t STEP_COUNT = sizeof(DOUBLE_FLASH) / sizeof(Step);
12
13uint8_t step = 0;
14unsigned long stepStart = 0;
15unsigned long lastTone = 0;
16
17void buzzerTone(uint32_t freq) { // 0 = sessiz / 0 = silent
18#if ESP_ARDUINO_VERSION_MAJOR >= 3
19 ledcWriteTone(BUZZER_PIN, freq);
20#else
21 ledcWriteTone(0, freq);
22#endif
23}
24
25void setup() {
26 pinMode(RED_PIN, OUTPUT);
27 pinMode(BLUE_PIN, OUTPUT);
28#if ESP_ARDUINO_VERSION_MAJOR >= 3
29 ledcAttach(BUZZER_PIN, 2000, 8); // pin, frekans, çözünürlük / pin, frequency, resolution
30#else
31 ledcSetup(0, 2000, 8); // kanal 0 / channel 0
32 ledcAttachPin(BUZZER_PIN, 0);
33#endif
34}
35
36void loop() {
37 if (millis() - stepStart >= DOUBLE_FLASH[step].ms) {
38 stepStart = millis();
39 step = (step + 1) % STEP_COUNT;
40 digitalWrite(RED_PIN, DOUBLE_FLASH[step].red);
41 digitalWrite(BLUE_PIN, DOUBLE_FLASH[step].blue);
42 }
43 if (millis() - lastTone >= 10) { // wail sireni: 4 saniyelik tarama / wail siren: 4 s sweep
44 lastTone = millis();
45 unsigned long phase = millis() % 4000;
46 unsigned long pos = phase < 2000 ? phase : 4000 - phase;
47 buzzerTone(600 + (800UL * pos) / 2000);
48 }
49}Lampeggiante polizia con Raspberry Pi Pico (MicroPython)
Sulla Pico la stessa idea sta in poche righe di MicroPython. I passi sono un elenco di terne (rosso, blu, durata); il tempo si misura con time.ticks_ms() e time.ticks_diff() e il buzzer è pilotato con machine.PWM. Il LED rosso va su GP11, quello blu su GP12 e il buzzer passivo su GP15. Se vuoi usare dei WS2812B, applica la stessa logica delle maschere con il modulo neopixel incluso in MicroPython. Se non hai ancora installato MicroPython sulla Pico, comincia da cos'è il Raspberry Pi Pico e basi di MicroPython.
1# Raspberry Pi Pico çakar + siren (MicroPython) / police lights + siren (MicroPython)
2from machine import Pin, PWM
3import time
4
5red = Pin(11, Pin.OUT)
6blue = Pin(12, Pin.OUT)
7buzzer = PWM(Pin(15)) # pasif buzzer / passive buzzer
8
9# (kırmızı, mavi, süre ms) / (red, blue, duration ms): çift flaş / double flash
10DOUBLE_FLASH = [(1, 0, 60), (0, 0, 60), (1, 0, 60), (0, 0, 180),
11 (0, 1, 60), (0, 0, 60), (0, 1, 60), (0, 0, 180)]
12
13siren_on = True
14step = 0
15step_start = time.ticks_ms()
16red.value(DOUBLE_FLASH[0][0])
17blue.value(DOUBLE_FLASH[0][1])
18
19
20def wail(t, period=4000):
21 # 600-1400 Hz üçgen tarama / triangle sweep
22 phase = t % period
23 half = period // 2
24 pos = phase if phase < half else period - phase
25 return 600 + 800 * pos // half
26
27
28while True:
29 now = time.ticks_ms()
30 if time.ticks_diff(now, step_start) >= DOUBLE_FLASH[step][2]:
31 step = (step + 1) % len(DOUBLE_FLASH)
32 step_start = now
33 red.value(DOUBLE_FLASH[step][0])
34 blue.value(DOUBLE_FLASH[step][1])
35 if siren_on:
36 buzzer.freq(wail(now))
37 buzzer.duty_u16(32768) # %50 görev oranı / 50 % duty cycle
38 else:
39 buzzer.duty_u16(0)
40 time.sleep_ms(5)Idee di progetto con il lampeggiante
- Volante della polizia giocattolo: monta il lampeggiante sul telaio di una macchinina robot e fai suonare la sirena mentre si muove.
- Plastico di città: comanda l'auto della polizia con lo stesso Arduino che gestisce un semaforo e l'illuminazione stradale.
- Vigili del fuoco e ambulanza: crea altri mezzi con schema blu-bianco e sirena bitonale.
- Sistema d'allarme: fai partire lampeggiante e sirena quando un sensore PIR rileva un movimento.
- Lampeggiante telecomandato: cambia schema con un telecomando IR e avvia la sirena a distanza.
- Raccolta di effetti luminosi: unisci gli schemi della polizia agli effetti Supercar e luci in sequenza nello stesso progetto.
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| Il LED non si accende | LED montato al contrario | Gamba lunga al pin tramite la resistenza, gamba corta a GND |
| Il LED blu è molto debole | A 3,3 V il LED blu è quasi alla sua tensione di soglia | Usa una resistenza più piccola (47–68 Ω) o pilotalo a 5 V con un transistor |
| La sirena fa un solo tono o ronza | È stato usato un buzzer attivo | Passa a un buzzer passivo |
| Una pressione salta due schemi | Rimbalzi del pulsante | Aumenta i 200 ms dentro pressed() |
| Con la sirena accesa il PWM sui pin 3 o 11 va in tilt | tone() usa il Timer2 | Sposta le uscite PWM sui pin 5, 6, 9 o 10 |
| La WS2812B mostra colori casuali | Manca la massa comune o la resistenza dati, oppure alimentazione debole | Collega le masse, aggiungi 330 Ω e 1000 µF |
Il lampeggiante unisce LED, resistenze, tempi e generazione del suono in un unico progetto divertente, e la logica degli elenchi di passi che hai imparato qui ti servirà in molti altri, dal semaforo agli spettacoli di luci. Nell'app BlueGrays trovi progetti di lampeggiante della polizia per Arduino, ESP32, Raspberry Pi Pico e WS2812B con schemi e codice passo passo, insieme a progetti con buzzer per perfezionare la sirena.
Domande frequenti
Cosa serve per fare un lampeggiante della polizia con Arduino?
Per la versione più semplice bastano un Arduino Uno, un LED rosso e uno blu, due resistenze da 220 Ω, una breadboard e qualche cavetto jumper. Per la sirena aggiungi un buzzer passivo e, per la barra luminosa, una striscia WS2812B da 8 LED.
Che resistenza uso per LED rosso e blu?
Sull'uscita a 5 V di Arduino Uno, 220 Ω sono un buon punto di partenza per entrambi i colori e danno 9–14 mA. Su ESP32 e Pico a 3,3 V, 150 Ω per il rosso e 47–68 Ω per il blu rendono di più. Puoi anche calcolarla con R = (V - VLED) / I.
Perché usare millis invece di delay per far lampeggiare i LED?
Durante delay() Arduino non fa nient'altro: i pulsanti non vengono letti e la sirena si interrompe. Con millis() misuri il tempo di ogni compito separatamente, così luci, sirena e pulsanti funzionano insieme. In più cambiare schema diventa molto più semplice.
Come si fa il suono della sirena con un buzzer e Arduino?
Con un buzzer passivo di cui cambi continuamente la frequenza con tone(). Una scansione tra 600 e 1400 Hz in circa 4 secondi dà la sirena wail, in 0,3 secondi la yelp. Per la bitonale basta alternare 440 e 587 Hz ogni mezzo secondo.
Quanti LED WS2812B servono per una barra luminosa?
Una barretta da 8 LED, 4 rossi a sinistra e 4 blu a destra, sembra già una barra vera. Per strisce più lunghe usa lo stesso codice aumentando NUM_LEDS; oltre i 30 LED circa serve un alimentatore a 5 V separato.
È legale montare un lampeggiante fai da te in auto?
No. Lampeggianti blu e sirene sono riservati ai veicoli autorizzati e il loro uso su un'auto privata è sanzionato dal Codice della Strada. Questo progetto è solo per giocattoli, plastici e scopi didattici.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Lampeggiante della polizia a LED
Proprio come le luci di un'auto della polizia: il LED rosso lampeggia tre volte velocissimo, poi tocca al blu per altre tre volte, e la sequenza si ripete senza sosta.

Raspberry Pi Pico Effetto Lampeggiante Polizia (Rosso + Blu Stroboscopio)
Simuliamo il lampeggiante di un'auto della polizia con un Raspberry Pi Pico nella sua forma più semplice! I LED rosso e blu si alternano (flip-flop): mentre il rosso è acceso il blu è spento, e ogni 0,3 secondi si scambiano, all'infinito. Il codice scrive i due passi direttamente in un unico ciclo while True; la velocità si regola con la costante WAIT_MS.

Uso del cicalino
Ti sei mai chiesto come fa un campanello o un allarme a suonare? L'Arduino fa suonare un piccolo cicalino a intervalli brevi: bip, pausa, bip, pausa.

Impostazione della frequenza con cicalino
Comandi il suono di un buzzer con quattro pulsanti: uno avvia il suono, uno lo zittisce e gli altri due lo rendono più acuto o più grave.

Lampeggiante della polizia con WS2812B
Porti sulla scrivania il lampeggiante rosso e blu del tetto di un'auto della polizia.

ESP32 Effetto Lampeggiante della Polizia
Simula i lampeggianti di un'auto della polizia facendo lampeggiare rapidamente gruppi di LED rossi e blu. Con 2 LED in ogni gruppo l'effetto è più drammatico. Un classico esempio di pattern di toggle veloce e controllo a gruppi.

Raspberry Pi Pico Flip-Flop Polizia 3 Burst (2 LED)
Variazione ritmica del progetto lampeggiante polizia — flip-flop 3 burst! Stesso circuito a 2 LED, ma pattern diverso: LED rosso lampeggia 3 volte velocemente, poi blu 3 volte, all'infinito.

Utilizzo della striscia LED WS2812B
Conosci una striscia LED intelligente in cui puoi colorare ogni singola luce per conto suo.
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

