Guías · 8 min de lectura

Luces de policía con Arduino: LED, tira WS2812B y sirena

Haz luces de policía con Arduino: LED rojo y azul con destello doble y triple, código sin delay con millis, torreta WS2812B, sirena con buzzer, ESP32 y Pico.

Las luces de policía con Arduino son uno de los primeros proyectos más divertidos para quien empieza: unos LED rojo y azul que se encienden y apagan con un ritmo preciso para imitar la torreta de una patrulla. Empiezas con dos LED, dos resistencias y unas pocas líneas de código; si quieres, con una barra WS2812B lo conviertes en una torreta de verdad y con un buzzer pasivo le agregas la sirena. Es ideal para carritos de juguete, maquetas, ferias de ciencias y exposiciones en la escuela.

En esta guía verás en una tabla, al milisegundo, los patrones de destello doble y triple que usan las torretas. Primero harás la versión más simple con delay, luego escribirás un código con millis() que hace funcionar las luces y la sirena al mismo tiempo sin que una espere a la otra. Después armarás una barra de ocho LED WS2812B controlada desde un solo pin y, al final, llevarás el mismo proyecto al ESP32 y a la Raspberry Pi Pico con MicroPython.

LED rojo y azul de 5 mm
LED de 5 mm: la pata larga es el ánodo (+) y la corta el cátodo (-). Para las luces de policía basta con un LED rojo y uno azul.

¿Cómo funcionan las luces de policía? Patrones de destello y tiempos

Las torretas reales no se quedan encendidas mucho tiempo: usan destellos muy cortos y seguidos, porque el ojo detecta mucho mejor los golpes de luz breves e intensos. Cada destello suele durar entre 50 y 60 ms; el mismo color destella dos o tres veces, hay una pausa corta y luego el otro color hace lo mismo. Por eso cada patrón del código está formado por pasos que responden a la pregunta "qué LED está encendido y por cuánto tiempo". Los tiempos de la tabla son exactamente los que usan los programas de esta guía; puedes jugar con los números y crear tu propio patrón.

PatrónPasos de un ladoDuración del cicloDestellos por segundo
Destello doble60 ms encendido, 60 ms apagado, 60 ms encendido, 180 ms apagado720 msUnos 5,6
Destello triple3 × (50 ms encendido, 50 ms apagado), pausa final de 170 ms840 msUnos 7,1
Alternado (wig-wag)250 ms rojo, 250 ms azul500 ms4
Barra WS2812BDestello doble izquierdo y derecho, luego 4 × 150 ms de cambio exterior-interior1320 msDepende del patrón

Materiales y conexiones

ComponenteArduino UnoESP32Raspberry Pi Pico
LED rojo (con resistencia)D9GPIO 26GP11
LED azul (con resistencia)D10GPIO 27GP12
Buzzer pasivoD8GPIO 25GP15
Botón de patrón (a GND)D2--
Botón de sirena (a GND)D3--
DIN de la WS2812B (con 330 Ω)D6--
Tierra comúnGNDGNDGND

En la protoboard, la pata larga del LED va al pin a través de la resistencia y la pata corta a GND. El valor de la resistencia sale de la fórmula R = (Vfuente - VLED) / I. Un LED rojo necesita unos 2,0 V y uno azul entre 3,0 y 3,2 V. Con los 5 V del Uno, una resistencia de 220 Ω deja pasar (5 - 2) / 220 ≈ 13,6 mA por el LED rojo y unos 8,6 mA por el azul, y los dos se ven bien. El ESP32 y la Pico trabajan a 3,3 V, así que al LED azul le queda muy poco margen: funcionan mejor 150 Ω para el rojo y 47–68 Ω para el azul. Para calcular tus propios valores usa la calculadora de resistencia para LED o la guía para calcular la resistencia de un LED. Los botones se leen con INPUT_PULLUP, así que una pata va al pin y la otra directo a GND.

Un pin de Arduino está pensado para unos 20 mA continuos como máximo. Si vas a poner varios LED por color, no los conectes directo al pin: usa un transistor NPN como el BC547 o el 2N2222 (con 1 kΩ en la base) o un driver ULN2003. Los detalles para conmutar con transistor están en la guía qué es un transistor.

Primera prueba: destello doble 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 función flash() enciende y apaga el pin dos veces durante 60 ms y espera otros 120 ms; así cada lado dura 360 ms, como en la tabla. El código es corto y fácil de entender, pero tiene un defecto importante: mientras delay() corre, el Arduino no puede hacer nada más. El botón responde tarde, la sirena suena entrecortada y no puedes manejar dos grupos de luces a ritmos distintos. Por eso en el siguiente paso pasamos a una estructura que mide el tiempo con millis() y nunca se queda esperando. Para la base del tema revisa la guía sobre millis y delay.

Luces de policía sin delay con millis y sirena

En el método sin bloqueos, cada patrón es una lista de pasos: cada paso guarda el estado del rojo y del azul y cuántos milisegundos dura. En cada vuelta, loop() solo pregunta "¿ya terminó el paso actual?"; si terminó, pasa al siguiente y actualiza los LED. En el mismo loop() la sirena cambia su frecuencia cada 10 ms y se leen los botones. Así las tres tareas avanzan al mismo tiempo y ninguna frena a las demás.

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}

El arreglo PATTERNS guarda los tres patrones en orden; cada vez que presionas el botón de D2 pasas al siguiente y el contador de pasos vuelve a cero. El botón de D3 enciende y apaga la sirena. La función pressed() solo cuenta el momento en que el botón baja de HIGH a LOW y exige 200 ms entre pulsaciones, lo que evita que el rebote se lea como varias pulsaciones. Para cambiar el tipo de sirena basta con poner la constante SIREN en WAIL, YELP o HILO. Si a esta estructura le agregas una máquina de estados, puedes diseñar modos como "patrullaje", "persecución" o "estacionado".

Sonido de sirena: wail, yelp y de dos tonos

Tipo de sirenaFrecuenciaCicloCarácter
Wail (larga)600 → 1400 → 600 HzUnos 4 sEl sonido clásico que sube y baja despacio, común en toda América
Yelp (rápida)600 → 1400 → 600 HzUnos 0,3 sEl ulular rápido que se usa en cruces y emergencias
Hi-lo (dos tonos)440 Hz y 587 Hz0,5 s cada tonoParecida a las sirenas de ambulancias y policía en Europa
Para la sirena necesitas un buzzer pasivo; el activo suena siempre en su propia frecuencia fija y no puede hacer barridos. La diferencia y algunos ejemplos de melodías están en la guía qué es un buzzer. En el Uno, tone() usa el Timer2; mientras suena la sirena falla el analogWrite de los pines 3 y 11, así que si necesitas PWM elige los pines 5, 6, 9 o 10.

Torreta de policía con WS2812B desde un solo pin

El resultado más parecido a una torreta real lo consigues con LED direccionables. En una barra WS2812B de ocho LED, los cuatro de la izquierda encienden en rojo y los cuatro de la derecha en azul, y todos se controlan desde un único pin de datos. Cada paso del código tiene una máscara y una duración: cada bit de la máscara representa un LED. Por ejemplo, 0x0F enciende los cuatro LED de la izquierda, 0xF0 los cuatro de la derecha y 0xC3 los de los extremos (0, 1, 6, 7). Instala la librería Adafruit NeoPixel desde el Gestor de librerías.

LED RGB direccionable WS2812B NeoPixel
Cada LED WS2812B lleva su propio controlador interno; por eso con una sola línea de datos puedes darle un color distinto a cada uno.
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 función showMask() recorre los ocho LED, enciende con el color de su lado los que tienen el bit en 1, apaga los demás y al final manda todo a la tira de una sola vez con bar.show(). Agregando pasos al final del patrón puedes diseñar fácilmente tus propios efectos: que se abra desde el centro, que gire o que destelle completa. Si usas una tira más larga, cambia NUM_LEDS y amplía las máscaras a un tipo de 16 o 32 bits.

Pon una resistencia de 330 Ω en serie en la línea de datos, un capacitor de 1000 µF entre 5 V y GND, y une siempre la GND del Arduino con la de la tira. Una WS2812B encendida en un solo color a brillo máximo consume unos 20 mA; para 8 LED alcanza el USB, pero desde 30 LED usa una fuente de 5 V aparte. La línea setBrightness(80) reduce tanto la corriente como el deslumbramiento.

Luces de policía con ESP32

En el ESP32 los LED se encienden con la misma lógica de digitalWrite; lo que cambia es la forma de generar el sonido. La sirena sale con la función ledcWriteTone del controlador LEDC. En la versión 3.x del núcleo Arduino para ESP32 el pin se asigna directo con ledcAttach(pin, frecuencia, resolución); en la 2.x primero se configura un canal con ledcSetup y luego se une al pin con ledcAttachPin. El código de abajo separa esta diferencia con #if, así que compila en las dos versiones. Como el ESP32 trabaja a 3,3 V, recuerda usar una resistencia pequeña para el LED azul. Si le agregas Wi-Fi, puedes encender las luces desde el celular; para empezar revisa la guía qué es el 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}

Luces de policía con Raspberry Pi Pico (MicroPython)

En la Pico la misma idea cabe en unas pocas líneas de MicroPython. Los pasos son una lista de tríos (rojo, azul, duración); el tiempo se mide con time.ticks_ms() y time.ticks_diff(), y el buzzer se maneja con machine.PWM. El LED rojo va a GP11, el azul a GP12 y el buzzer pasivo a GP15. Si quieres usar WS2812B, puedes aplicar la misma lógica de máscaras con el módulo neopixel que ya trae MicroPython. Si todavía no sabes cargar MicroPython en la Pico, empieza por las guías qué es la Raspberry Pi Pico y 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)

Ideas de proyectos con luces de policía

  • Patrulla de juguete: Monta las luces sobre el chasis de un carrito robot y haz que suene la sirena mientras avanza.
  • Ciudad en maqueta: Controla la patrulla con el mismo Arduino que maneja un semáforo y el alumbrado de la calle.
  • Bomberos y ambulancia: Crea otros vehículos con patrón rojo-blanco y sirena de dos tonos.
  • Sistema de alarma: Que la torreta y la sirena se activen cuando un sensor PIR detecte movimiento.
  • Torreta con control remoto: Cambia los patrones con un control IR y enciende la sirena a distancia.
  • Colección de efectos de luz: Junta los patrones de policía con los efectos del auto fantástico y LED secuenciales en un mismo proyecto.

Errores comunes y soluciones

SíntomaCausa probableSolución
El LED no enciendeEl LED está al revésPata larga al pin a través de la resistencia, pata corta a GND
El LED azul se ve muy débilA 3,3 V el azul está casi en su voltaje umbralUsa una resistencia menor (47–68 Ω) o manéjalo desde 5 V con un transistor
La sirena da un solo tono o zumbaSe usó un buzzer activoCambia a un buzzer pasivo
Una pulsación salta dos patronesRebote del botónAumenta los 200 ms dentro de pressed()
Con la sirena falla el PWM de los pines 3 u 11tone() usa el Timer2Pasa las salidas PWM a los pines 5, 6, 9 o 10
La WS2812B muestra colores al azarSin GND común, sin resistencia de datos o fuente débilUne las GND y agrega 330 Ω y 1000 µF
Usar luces rojas y azules intermitentes o una sirena en un vehículo real está prohibido en México, en el resto de Latinoamérica, en España y en la mayoría de los países. Este proyecto es para juguetes, maquetas, escenografías y demostraciones educativas; no apuntes los LED brillantes a los ojos de nadie.

Las luces de policía juntan en un solo proyecto divertido los LED, las resistencias, los tiempos y la generación de sonido, y la lógica de listas de pasos que aprendiste aquí te servirá en muchos otros, desde semáforos hasta shows de luces. En la app BlueGrays encontrarás proyectos de luces de policía con Arduino, ESP32, Raspberry Pi Pico y WS2812B con diagramas y código paso a paso, además de proyectos con buzzer para mejorar el sonido de la sirena.

Preguntas frecuentes

¿Qué materiales necesito para hacer luces de policía con Arduino?

Para la versión más sencilla bastan un Arduino Uno, un LED rojo, un LED azul, dos resistencias de 220 Ω, una protoboard y cables dupont. Para la sirena agrega un buzzer pasivo y, para la torreta, una tira WS2812B de 8 LED.

¿Qué resistencia uso para el LED rojo y el azul?

Con los 5 V del Arduino Uno, 220 Ω es un buen punto de partida para ambos y deja pasar entre 9 y 14 mA. En el ESP32 y la Pico, que trabajan a 3,3 V, conviene usar 150 Ω para el rojo y 47–68 Ω para el azul. También puedes calcularla con R = (V - VLED) / I.

¿Por qué usar millis en lugar de delay para las luces?

Mientras corre delay() el Arduino no hace nada más: no lee botones y la sirena se corta. Con millis() mides el tiempo de cada tarea por separado, así luces, sirena y botones funcionan a la vez. Además, cambiar de patrón es mucho más fácil.

¿Cómo hago el sonido de sirena con un buzzer?

Con un buzzer pasivo y la función tone(), cambiando la frecuencia todo el tiempo. Si la haces subir y bajar entre 600 y 1400 Hz en unos 4 segundos obtienes la sirena wail, y en 0,3 segundos la yelp. Para la de dos tonos basta con alternar 440 y 587 Hz cada medio segundo.

¿Cuántos LED necesito para una torreta con WS2812B?

Con una barra de 8 LED, 4 rojos a la izquierda y 4 azules a la derecha, logras una torreta realista. Para tiras más largas usa el mismo código aumentando NUM_LEDS; a partir de unos 30 LED necesitas una fuente de 5 V aparte.

¿Es legal poner luces de policía en un carro?

No. Las torretas rojo-azul y las sirenas están reservadas a los vehículos de emergencia autorizados, y en un auto particular se sancionan con multas en casi todos los países. Este proyecto es solo para juguetes, maquetas y fines educativos.

Ver todos los proyectos
Luces de policía LED
AR-4Principiante

Luces de policía LED

Como las luces de un coche de policía: el LED rojo destella tres veces muy rápido, después el azul destella otras tres, y la secuencia se repite sin parar.

4.7(105)
283
Raspberry Pi Pico Efecto Luces Policía (Rojo + Azul Estroboscopio)
PI-5Principiante

Raspberry Pi Pico Efecto Luces Policía (Rojo + Azul Estroboscopio)

¡Simulamos la barra de luces de un coche de policía con una Raspberry Pi Pico en su forma más sencilla! Los LED rojo y azul se turnan (flip-flop): mientras el rojo está encendido el azul está apagado, y cada 0,3 segundos se intercambian, sin fin. El código escribe los dos pasos directamente en un único bucle while True; la velocidad se ajusta con la constante WAIT_MS.

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

Uso del zumbador

¿Alguna vez te has preguntado cómo suena un timbre o una alarma? El Arduino hace pitar un pequeño zumbador a intervalos cortos: pip, silencio, pip, silencio.

4.7(92)
171
Ajuste de frecuencia con zumbador
AR-14Intermedio

Ajuste de frecuencia con zumbador

Controlas el sonido de un zumbador con cuatro botones: uno lo enciende, otro lo calla y los otros dos lo hacen más agudo o más grave.

4.6(69)
120
Luces de policía con WS2812B
AR-70Intermedio
Premium

Luces de policía con WS2812B

Traes a tu escritorio las luces roja y azul del techo de un coche de policía. Una mitad de una tira WS2812B de diez LED destella en rojo tres veces muy rápido, la otra mitad destella en azul tres…

4.8(67)
86
ESP32 Efecto de Luz Estroboscópica Policial
ES-7Principiante
Premium

ESP32 Efecto de Luz Estroboscópica Policial

Simula las luces estroboscópicas de un coche de policía haciendo parpadear rápidamente grupos de LEDs rojos y azules. Con 2 LEDs en cada grupo el efecto es más espectacular. Un ejemplo clásico de patrón de alternancia rápida y control por grupos.

4.6(21)
36
Raspberry Pi Pico Flip-Flop Policía 3 Ráfaga (2 LED)
PI-6Principiante

Raspberry Pi Pico Flip-Flop Policía 3 Ráfaga (2 LED)

Variación rítmica del proyecto luces policía — flip-flop 3 ráfaga! Mismo circuito de 2 LEDs, pero patrón diferente: LED rojo parpadea 3 veces rápidamente, luego azul 3 veces, indefinidamente.

5.0(1)
16
Uso de la tira LED WS2812B
AR-69Intermedio
Premium

Uso de la tira LED WS2812B

Conoces una tira LED inteligente en la que puedes dar color a cada luz por separado.

4.8(54)
70