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.

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ão | Passos de um lado | Tempo do ciclo | Flashes por segundo |
|---|---|---|---|
| Flash duplo | 60 ms aceso, 60 ms apagado, 60 ms aceso, 180 ms apagado | 720 ms | Cerca de 5,6 |
| Flash triplo | 3 × (50 ms aceso, 50 ms apagado), pausa final de 170 ms | 840 ms | Cerca de 7,1 |
| Alternado (wig-wag) | 250 ms vermelho, 250 ms azul | 500 ms | 4 |
| Barra WS2812B | Flash duplo à esquerda e à direita, depois 4 × 150 ms de troca entre externos e internos | 1320 ms | Depende do padrão |
Componentes e ligações
| Componente | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| LED vermelho (com resistor) | D9 | GPIO 26 | GP11 |
| LED azul (com resistor) | D10 | GPIO 27 | GP12 |
| Buzzer passivo | D8 | GPIO 25 | GP15 |
| Botão de padrão (para o GND) | D2 | - | - |
| Botão da sirene (para o GND) | D3 | - | - |
| DIN do WS2812B (via 330 Ω) | D6 | - | - |
| GND comum | GND | GND | GND |
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.
Primeira tentativa: flash duplo com 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}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.
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 sirene | Frequência | Ciclo | Característica |
|---|---|---|---|
| Wail (longa) | 600 → 1400 → 600 Hz | Cerca de 4 s | A 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 Hz | Cerca de 0,3 s | O uivo rápido usado em cruzamentos e emergências |
| Hi-lo (dois tons) | 440 Hz e 587 Hz | 0,5 s por tom | Parecida com as sirenes de ambulância e de polícia da Europa |
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.

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.
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.
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.
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
| Sintoma | Causa provável | Solução |
|---|---|---|
| O LED não acende | LED colocado invertido | Perna longa no pino passando pelo resistor, perna curta no GND |
| O LED azul fica muito fraco | Em 3,3 V o LED azul fica perto da sua tensão direta | Use um resistor menor (47–68 Ω) ou acione-o em 5 V com um transistor |
| A sirene dá um tom só ou um zumbido | Foi usado um buzzer ativo | Troque por um buzzer passivo |
| Um toque pula dois padrões | Repique dos contatos | Aumente o valor de 200 ms dentro de pressed() |
| O PWM no pino 3 ou 11 falha com a sirene ligada | O tone() usa o Timer2 | Passe as saídas PWM para os pinos 5, 6, 9 ou 10 |
| O WS2812B mostra cores aleatórias | Sem GND comum, sem resistor de dados ou fonte fraca | Una os GNDs e acrescente 330 Ω e 1000 µF |
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.
Projetos para montar depois desta leitura
Ver todos os projetos
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.

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.

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.

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.

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…

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.

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.

Uso da fita LED WS2812B
Conheça uma fita LED inteligente em que você pode definir a cor de cada luz individualmente.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

