Guias · 8 min de leitura

Luzes de polícia com Arduino (giroflex): padrões de flash, WS2812B e sirene

Monte luzes de polícia com Arduino: flash duplo e triplo com LEDs vermelho e azul, código com millis sem bloqueio, barra de luzes WS2812B, sirene com buzzer e código para ESP32 e Pico.

Luzes de polícia com Arduino são um dos primeiros projetos mais divertidos para quem está começando: LEDs vermelhos e azuis piscam com tempos precisos para imitar o giroflex de uma viatura. Você começa com dois LEDs, dois resistores e poucas linhas de código; acrescente uma barra WS2812B e o projeto vira uma barra de luzes de verdade, acrescente um buzzer passivo e você ganha também a sirene. É perfeito para carrinhos de brinquedo, maquetes de cidade, feiras de ciências e apresentações escolares.

Neste guia você vai ver, em uma tabela e com precisão de milissegundos, os padrões de flash duplo e triplo usados pelas barras de luzes. Primeiro você monta a versão mais simples, com delay, e depois escreve um código com millis() que faz as luzes e a sirene funcionarem ao mesmo tempo, sem que uma bloqueie a outra. Em seguida, você monta uma barra de luzes WS2812B de oito LEDs controlada por um único pino e, por fim, leva o mesmo projeto para o ESP32 e para o Raspberry Pi Pico com MicroPython.

LEDs de 5 mm vermelho e azul
LEDs de 5 mm: a perna longa é o ânodo (+) e a perna curta, o cátodo (-). Um LED vermelho e um azul são tudo o que você precisa para as luzes de polícia.

Como funcionam as luzes de polícia? Padrões de flash e tempos

As barras de luzes de verdade não ficam acesas por muito tempo: elas usam flashes muito curtos em rápida sucessão, porque o olho percebe com muito mais facilidade clarões breves e intensos. Cada flash costuma durar 50–60 ms; uma cor pisca duas ou três vezes, vem uma pausa curta e então a outra cor faz o mesmo. Por isso, todo padrão no código é feito de passos que respondem à pergunta “qual LED está aceso e por quanto tempo”. Os tempos da tabela são exatamente os que os sketches deste guia usam; brinque com os números e crie o seu próprio padrão.

PadrãoPassos de um ladoTempo do cicloFlashes por segundo
Flash duplo60 ms aceso, 60 ms apagado, 60 ms aceso, 180 ms apagado720 msCerca de 5,6
Flash triplo3 × (50 ms aceso, 50 ms apagado), pausa final de 170 ms840 msCerca de 7,1
Alternado (wig-wag)250 ms vermelho, 250 ms azul500 ms4
Barra WS2812BFlash duplo à esquerda e à direita, depois 4 × 150 ms de troca entre externos e internos1320 msDepende do padrão

Componentes e ligações

ComponenteArduino UnoESP32Raspberry Pi Pico
LED vermelho (com resistor)D9GPIO 26GP11
LED azul (com resistor)D10GPIO 27GP12
Buzzer passivoD8GPIO 25GP15
Botão de padrão (para o GND)D2--
Botão da sirene (para o GND)D3--
DIN do WS2812B (via 330 Ω)D6--
GND comumGNDGNDGND

A perna longa de cada LED vai ao pino passando pelo resistor, e a perna curta vai ao GND. O valor do resistor sai de R = (Vfonte - VLED) / I. Um LED vermelho precisa de cerca de 2,0 V e um azul, de 3,0–3,2 V. Na saída de 5 V do Uno, 220 Ω deixam passar (5 - 2) / 220 ≈ 13,6 mA pelo LED vermelho e cerca de 8,6 mA pelo azul, e os dois ficam bem visíveis. O ESP32 e o Pico fornecem 3,3 V, o que deixa pouquíssima folga para o LED azul: 150 Ω para o vermelho e 47–68 Ω para o azul funcionam melhor. Para calcular os seus próprios valores, use a calculadora de resistor para LED ou o guia como calcular o resistor do LED. Os botões são lidos com INPUT_PULLUP, então uma perna vai ao pino e a outra, direto ao GND.

Um pino do Arduino foi projetado para fornecer, no máximo, cerca de 20 mA de forma contínua. Se você quiser vários LEDs por cor, não os ligue direto ao pino; use um transistor NPN como o BC547 ou o 2N2222 (com um resistor de base de 1 kΩ) ou um driver ULN2003. O chaveamento com transistores é explicado em o que é um transistor.

Primeira tentativa: flash duplo com 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}

A função flash() liga e desliga o pino duas vezes por 60 ms e depois espera mais 120 ms, de modo que cada lado dura 360 ms, exatamente como na tabela. O código é curto e fácil de acompanhar, mas tem um grande defeito: enquanto o delay() roda, o Arduino não consegue fazer mais nada. Os botões respondem com atraso, a sirene engasga e não dá para fazer dois grupos de luzes funcionarem em velocidades diferentes. Por isso, o próximo passo muda para uma estrutura que mede o tempo com millis() e nunca fica esperando. Para entender a base, leia millis ou delay.

Luzes de polícia e sirene sem bloqueio com millis

Na abordagem sem bloqueio, cada padrão é uma lista de passos: cada passo guarda o estado dos LEDs vermelho e azul e quantos milissegundos ele dura. A cada volta, o loop() só pergunta “o passo atual já acabou?”; se acabou, ele passa para o próximo passo e atualiza os LEDs. No mesmo loop(), a sirene muda de frequência a cada 10 ms e os botões são lidos. As três tarefas correm lado a lado e nenhuma segura as outras.

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}

O array PATTERNS guarda os três padrões em ordem; cada toque no botão do D2 passa para o próximo e zera o contador de passos. O botão do D3 liga e desliga a sirene. A função pressed() só conta o instante em que o botão vai de HIGH para LOW e exige 200 ms entre um toque e outro, o que impede que o repique dos contatos seja lido como vários toques. Para mudar o tipo de sirene, defina a constante SIREN como WAIL, YELP ou HILO. Acrescente uma máquina de estados a essa estrutura e você pode criar modos como “patrulha”, “perseguição” e “estacionado”.

Som da sirene: wail, yelp e dois tons

Tipo de sireneFrequênciaCicloCaracterística
Wail (longa)600 → 1400 → 600 HzCerca de 4 sA clássica subida e descida lenta que se ouve em toda a América do Norte e do Sul
Yelp (rápida)600 → 1400 → 600 HzCerca de 0,3 sO uivo rápido usado em cruzamentos e emergências
Hi-lo (dois tons)440 Hz e 587 Hz0,5 s por tomParecida com as sirenes de ambulância e de polícia da Europa
A sirene precisa de um buzzer passivo; um buzzer ativo sempre soa na sua própria frequência fixa e não consegue fazer a varredura. A diferença e alguns exemplos de melodia estão em o que é um buzzer. No Uno, o tone() usa o Timer2, então o analogWrite nos pinos 3 e 11 se comporta mal enquanto a sirene toca; se você precisar de PWM, escolha os pinos 5, 6, 9 ou 10.

Uma barra de luzes de polícia WS2812B com um único pino

Os LEDs endereçáveis dão o resultado mais próximo de uma barra de luzes de verdade. Em uma barra WS2812B de oito LEDs, os quatro LEDs da esquerda acendem em vermelho e os quatro da direita em azul, todos controlados por um único pino de dados. Cada passo no código é uma máscara mais uma duração: cada bit da máscara representa um LED. Por exemplo, 0x0F acende os quatro LEDs da esquerda, 0xF0 os quatro da direita e 0xC3 os LEDs das pontas (0, 1, 6, 7). Instale a biblioteca Adafruit NeoPixel pelo Gerenciador de Bibliotecas.

LED RGB endereçável WS2812B NeoPixel
Cada LED WS2812B tem o seu próprio driver por dentro, então uma única linha de dados consegue dar uma cor diferente a cada LED.
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}

A função showMask() percorre os oito LEDs, acende na cor do seu lado aqueles cujo bit da máscara é 1, apaga os demais e, no fim, envia tudo de uma vez para a fita com bar.show(). Acrescentando passos ao final do padrão, você cria com facilidade os seus próprios efeitos, que se abrem a partir do centro, giram ou fazem a barra inteira piscar. Se você usar uma fita mais longa, altere NUM_LEDS e amplie as máscaras para um tipo de 16 ou 32 bits.

Coloque um resistor de 330 Ω em série na linha de dados e um capacitor de 1000 µF entre 5 V e GND, e sempre una os GNDs do Arduino e da fita. Um WS2812B mostrando uma única cor no brilho máximo consome cerca de 20 mA; a USB dá conta de 8 LEDs, mas a partir de uns 30 LEDs use uma fonte de 5 V separada. A linha setBrightness(80) reduz tanto a corrente quanto o ofuscamento.

Luzes de polícia com ESP32

No ESP32, os LEDs funcionam com a mesma lógica do digitalWrite; o que muda é a forma de gerar o som. A sirene sai da função ledcWriteTone do controlador LEDC. Na versão 3.x do core Arduino para ESP32, o pino é associado diretamente com ledcAttach(pino, frequência, resolução), enquanto a 2.x primeiro configura um canal com ledcSetup e depois o vincula ao pino com ledcAttachPin. O código abaixo separa os dois casos com #if, então compila nas duas versões. Como o ESP32 trabalha em 3,3 V, lembre-se do resistor menor para o LED azul. Acrescente Wi-Fi e você pode ligar e desligar as luzes pelo celular; para começar, veja o que é o 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}

Luzes de polícia com Raspberry Pi Pico (MicroPython)

No Pico, a mesma ideia cabe em poucas linhas de MicroPython. Os passos são uma lista de tuplas (vermelho, azul, duração); o tempo é medido com time.ticks_ms() e time.ticks_diff(), e o buzzer é acionado com machine.PWM. O LED vermelho vai no GP11, o LED azul no GP12 e o buzzer passivo no GP15. Para usar LEDs WS2812B, aplique a mesma lógica de máscara com o módulo neopixel, que já vem com o MicroPython. Se você ainda não gravou o MicroPython no Pico, comece por o que é o Raspberry Pi Pico e pelos fundamentos de 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)

Ideias de projeto com luzes de polícia

  • Viatura de brinquedo: Monte as luzes no chassi de um carrinho robô e deixe a sirene tocar enquanto ele anda.
  • Maquete de cidade: Controle a viatura com o mesmo Arduino que comanda um semáforo e os postes de luz.
  • Caminhão de bombeiros e ambulância: Crie outros veículos com um padrão vermelho e branco e uma sirene de dois tons.
  • Sistema de alarme: Faça a barra de luzes e a sirene entrarem em ação quando um sensor PIR detectar movimento.
  • Barra de luzes com controle remoto: Troque de padrão com um controle remoto IR e dispare a sirene do outro lado da sala.
  • Coleção de efeitos de luz: Junte os padrões de polícia aos efeitos de Super Máquina e LED sequencial em um único projeto.

Problemas comuns e soluções

SintomaCausa provávelSolução
O LED não acendeLED colocado invertidoPerna longa no pino passando pelo resistor, perna curta no GND
O LED azul fica muito fracoEm 3,3 V o LED azul fica perto da sua tensão diretaUse um resistor menor (47–68 Ω) ou acione-o em 5 V com um transistor
A sirene dá um tom só ou um zumbidoFoi usado um buzzer ativoTroque por um buzzer passivo
Um toque pula dois padrõesRepique dos contatosAumente o valor de 200 ms dentro de pressed()
O PWM no pino 3 ou 11 falha com a sirene ligadaO tone() usa o Timer2Passe as saídas PWM para os pinos 5, 6, 9 ou 10
O WS2812B mostra cores aleatóriasSem GND comum, sem resistor de dados ou fonte fracaUna os GNDs e acrescente 330 Ω e 1000 µF
Usar luzes vermelhas e azuis piscantes ou uma sirene em um veículo de verdade é ilegal na maioria dos países, incluindo os EUA e o Reino Unido. Este projeto é voltado para brinquedos, maquetes, adereços de palco e demonstrações educativas; nunca aponte LEDs fortes para os olhos de ninguém.

As luzes de polícia reúnem LEDs, resistores, temporização e geração de som em um único projeto divertido, e a lógica de lista de passos que você aprendeu aqui vai ajudar em muitos outros, de semáforos a shows de luzes. No app BlueGrays você encontra projetos de luzes de polícia para Arduino, ESP32, Raspberry Pi Pico e WS2812B, com esquemas do circuito e código passo a passo, além de projetos com buzzer para aprimorar a sua sirene.

Perguntas frequentes

O que eu preciso para fazer luzes de polícia com Arduino?

Para a versão mais simples, você precisa de um Arduino Uno, um LED vermelho e um azul, dois resistores de 220 Ω, uma protoboard e jumpers. Acrescente um buzzer passivo para a sirene e uma barra WS2812B de 8 LEDs para a barra de luzes.

Qual resistor devo usar para os LEDs vermelho e azul?

Na saída de 5 V do Arduino Uno, 220 Ω é um bom ponto de partida para as duas cores e resulta em 9–14 mA. No ESP32 e no Pico, de 3,3 V, 150 Ω para o vermelho e 47–68 Ω para o azul dão um resultado mais brilhante. Você também pode calcular por conta própria com R = (V - VLED) / I.

Por que usar millis em vez de delay para piscar LEDs?

Enquanto o delay() roda, o Arduino não consegue fazer mais nada: os botões não são lidos e a sirene falha. Com millis() você cronometra cada tarefa separadamente, e assim luzes, sirene e botões funcionam ao mesmo tempo. Trocar de padrão também fica muito mais fácil com essa estrutura.

Como faço um som de sirene com um buzzer no Arduino?

Use um buzzer passivo e vá mudando a frequência dele com tone(). Faça a varredura entre 600 e 1400 Hz em cerca de 4 segundos para um wail, ou em 0,3 segundo para um yelp. Para uma sirene de dois tons, basta alternar entre 440 e 587 Hz a cada meio segundo.

De quantos LEDs WS2812B eu preciso para uma barra de luzes de polícia?

Uma barra de 8 LEDs, com 4 LEDs vermelhos à esquerda e 4 azuis à direita, já parece uma barra de luzes realista. Para fitas mais longas, use o mesmo código com um NUM_LEDS maior; acima de uns 30 LEDs você precisa de uma fonte de 5 V separada.

É permitido colocar luzes de polícia no meu carro?

Não. As barras de luzes vermelhas e azuis e as sirenes são reservadas a veículos de emergência autorizados, e instalá-las em um carro particular é infração na maioria dos países. Este projeto é só para brinquedos, maquetes e fins educativos.

Ver todos os projetos
Luzes de polícia com LEDs
AR-4Iniciante

Luzes de polícia com LEDs

Como as luzes de uma viatura: o LED vermelho pisca três vezes rapidamente, depois o LED azul pisca três vezes, e a sequência se repete sem parar. Basta ligar dois LEDs e dois resistores ao Arduino.

4.7(105)
283
Raspberry Pi Pico: efeito de luz policial (vermelho + azul)
PI-5Iniciante

Raspberry Pi Pico: efeito de luz policial (vermelho + azul)

Simulamos a barra de luzes de uma viatura com um Raspberry Pi Pico da forma mais simples! Os LEDs vermelho e azul acendem alternadamente (flip-flop): enquanto o vermelho está aceso, o azul fica apagado, e eles trocam de estado a cada 0,3 segundo, para sempre. O código escreve as duas etapas diretamente em um único laço while True; a velocidade é definida pela constante WAIT_MS.

4.7(3)
10
Uso do buzzer
AR-13Iniciante

Uso do buzzer

Já se perguntou como uma campainha ou um alarme produz som? O Arduino faz um pequeno buzzer emitir bipes em intervalos curtos: bipe, pausa, bipe, pausa.

4.7(92)
171
Ajuste de frequência com buzzer
AR-14Intermediário

Ajuste de frequência com buzzer

Você controla o som de um buzzer com quatro botões: um inicia o som, outro o interrompe e os outros dois o deixam mais agudo ou mais grave.

4.6(69)
120
Luzes de polícia com WS2812B
AR-70Intermediário
Premium

Luzes de polícia com WS2812B

Traga as luzes vermelhas e azuis do teto de uma viatura para a sua mesa. Metade de uma fita WS2812B de dez LEDs pisca em vermelho três vezes seguidas rapidamente, depois a outra metade pisca em azul…

4.8(67)
86
Efeito de luzes de viatura com ESP32
ES-7Iniciante
Premium

Efeito de luzes de viatura com ESP32

Simule as luzes de uma viatura fazendo grupos de LEDs vermelhos e azuis piscarem rapidamente. Usar 2 LEDs em cada grupo deixa o efeito mais marcante. Um exemplo clássico de alternância rápida e controle de grupos.

4.6(21)
36
Raspberry Pi Pico: luz policial com 3 piscadas alternadas (2 LEDs)
PI-6Iniciante

Raspberry Pi Pico: luz policial com 3 piscadas alternadas (2 LEDs)

Uma variação rítmica do projeto de luz policial — flip-flop com 3 piscadas! O mesmo circuito de 2 LEDs (GP11 vermelho + GP12 azul), mas com outro padrão: o LED vermelho pisca 3 vezes rapidamente, depois o azul pisca 3 vezes, sem parar. Esse padrão de "rajada + troca" é o ritmo mais reconhecível das luzes de viaturas reais. Aprenda a usar a função com parâmetros def burst(led, count, duration_ms), a criar ritmos e a gerar diferentes efeitos visuais com código no mesmo circuito.

5.0(1)
16
Uso da fita LED WS2812B
AR-69Intermediário
Premium

Uso da fita LED WS2812B

Conheça uma fita LED inteligente em que você pode definir a cor de cada luz individualmente.

4.8(54)
70