Guide · 8 min di lettura

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.

LED rosso e blu da 5 mm
LED da 5 mm: la gamba lunga è l'anodo (+), quella corta il catodo (-). Per il lampeggiante bastano un LED rosso e uno blu, due blu per la versione italiana.

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.

SchemaPassi per un latoDurata del cicloFlash al secondo
Doppio flash60 ms acceso, 60 ms spento, 60 ms acceso, 180 ms spento720 msCirca 5,6
Triplo flash3 × (50 ms acceso, 50 ms spento), pausa finale di 170 ms840 msCirca 7,1
Alternato (wig-wag)250 ms rosso, 250 ms blu500 ms4
Barra WS2812BDoppio flash a sinistra e a destra, poi 4 × 150 ms di scambio esterno-interno1320 msDipende dallo schema

Materiale e collegamenti

ComponenteArduino UnoESP32Raspberry Pi Pico
LED rosso (con resistenza)D9GPIO 26GP11
LED blu (con resistenza)D10GPIO 27GP12
Buzzer passivoD8GPIO 25GP15
Pulsante schema (verso GND)D2--
Pulsante sirena (verso GND)D3--
DIN della WS2812B (tramite 330 Ω)D6--
Massa comuneGNDGNDGND

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.

Un pin di Arduino è pensato per circa 20 mA continui al massimo. Se vuoi più LED per colore, non collegarli direttamente al pin: usa un transistor NPN come il BC547 o il 2N2222 (resistenza di base da 1 kΩ) oppure un driver ULN2003. La commutazione con transistor è spiegata in cos'è un transistor.

Prima prova: doppio flash con delay

C++ (Arduino IDE)
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.

C++ (Arduino IDE)
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 sirenaFrequenzaCicloCarattere
Wail (lunga)600 → 1400 → 600 HzCirca 4 sIl classico suono che sale e scende lentamente, diffuso in tutto il continente americano
Yelp (veloce)600 → 1400 → 600 HzCirca 0,3 sIl richiamo rapido usato agli incroci e nelle emergenze
Hi-lo (bitonale)440 Hz e 587 Hz0,5 s per tonoSimile alla sirena bitonale dei mezzi di soccorso in Italia e in Europa
Per la sirena serve un buzzer passivo; un buzzer attivo suona sempre alla sua frequenza fissa e non può fare scansioni. La differenza e alcuni esempi di melodie sono nella guida cos'è un buzzer. Sull'Uno tone() usa il Timer2: mentre suona la sirena, analogWrite sui pin 3 e 11 non funziona bene, quindi se ti serve il PWM scegli i pin 5, 6, 9 o 10.

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.

LED RGB indirizzabile WS2812B NeoPixel
Ogni LED WS2812B ha al suo interno un proprio driver, quindi con una sola linea dati puoi dare a ciascuno un colore diverso.
C++ (Arduino IDE)
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.

Metti una resistenza da 330 Ω in serie sulla linea dati e un condensatore da 1000 µF tra 5 V e GND, e collega sempre le masse di Arduino e striscia. Un WS2812B acceso su un solo colore alla massima luminosità assorbe circa 20 mA; per 8 LED basta l'USB, ma da circa 30 LED in su serve un alimentatore a 5 V separato. La riga setBrightness(80) riduce sia la corrente sia l'abbagliamento.

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.

C++ (Arduino IDE)
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.

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

SintomoCausa probabileSoluzione
Il LED non si accendeLED montato al contrarioGamba lunga al pin tramite la resistenza, gamba corta a GND
Il LED blu è molto deboleA 3,3 V il LED blu è quasi alla sua tensione di sogliaUsa 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 attivoPassa a un buzzer passivo
Una pressione salta due schemiRimbalzi del pulsanteAumenta i 200 ms dentro pressed()
Con la sirena accesa il PWM sui pin 3 o 11 va in tilttone() usa il Timer2Sposta le uscite PWM sui pin 5, 6, 9 o 10
La WS2812B mostra colori casualiManca la massa comune o la resistenza dati, oppure alimentazione deboleCollega le masse, aggiungi 330 Ω e 1000 µF
In Italia, come nella maggior parte dei Paesi, i lampeggianti blu e la sirena bitonale sono riservati ai veicoli di soccorso e di polizia autorizzati; montarli su un'auto privata è vietato dal Codice della Strada. Questo progetto è pensato per giocattoli, plastici, scenografie e dimostrazioni didattiche; non puntare mai LED luminosi negli occhi di qualcuno.

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.

Vedi tutti i progetti
Lampeggiante della polizia a LED
AR-4Principiante

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.

4.7(105)
283
Raspberry Pi Pico Effetto Lampeggiante Polizia (Rosso + Blu Stroboscopio)
PI-5Principiante

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.

4.7(3)
10
Uso del cicalino
AR-13Principiante

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.

4.7(92)
171
Impostazione della frequenza con cicalino
AR-14Intermedio

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.

4.6(69)
120
Lampeggiante della polizia con WS2812B
AR-70Intermedio
Premium

Lampeggiante della polizia con WS2812B

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

4.8(67)
86
ESP32 Effetto Lampeggiante della Polizia
ES-7Principiante
Premium

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.

4.6(21)
36
Raspberry Pi Pico Flip-Flop Polizia 3 Burst (2 LED)
PI-6Principiante

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.

5.0(1)
16
Utilizzo della striscia LED WS2812B
AR-69Intermedio
Premium

Utilizzo della striscia LED WS2812B

Conosci una striscia LED intelligente in cui puoi colorare ogni singola luce per conto suo.

4.8(54)
70