Ratgeber · 7 Min. Lesezeit

Blaulicht mit Arduino: Blitzmuster, WS2812B-Leiste und Sirene

Blaulicht mit Arduino bauen: Doppel- und Dreifachblitz mit LEDs, millis-Code ohne delay, WS2812B-Lichtleiste, Sirene mit Buzzer sowie Code für ESP32 und Pico.

Ein Blaulicht mit Arduino gehört zu den unterhaltsamsten Einsteigerprojekten: LEDs blinken in einem genauen Takt und ahmen die Lichtleiste eines Polizeiautos nach. Du startest mit zwei LEDs, zwei Vorwiderständen und ein paar Zeilen Code; mit einer WS2812B-Leiste wird daraus eine echte Lichtleiste, mit einem passiven Buzzer kommt die Sirene dazu. Wir verwenden hier das amerikanische Rot-Blau-Muster; für ein deutsches Blaulicht setzt du einfach zwei blaue LEDs ein. Ideal für Spielzeugautos, Modellbahnen, Dioramen und Schulprojekte.

In diesem Artikel siehst du die Doppel- und Dreifachblitzmuster echter Lichtleisten millisekundengenau in einer Tabelle. Zuerst baust du die einfachste Version mit delay, danach schreibst du Code mit millis(), der Licht und Sirene gleichzeitig laufen lässt, ohne dass eines auf das andere wartet. Anschließend baust du eine Lichtleiste aus acht WS2812B-LEDs an einem einzigen Pin und überträgst das Projekt zum Schluss auf den ESP32 und den Raspberry Pi Pico mit MicroPython.

Rote und blaue 5-mm-LEDs
5-mm-LEDs: Das lange Bein ist die Anode (+), das kurze die Kathode (-). Für das Blaulicht genügen eine rote und eine blaue LED, für die deutsche Variante zwei blaue.

Wie funktioniert ein Blaulicht? Blitzmuster und Timing

Echte Lichtleisten leuchten nicht lange am Stück, sondern blitzen sehr kurz und schnell hintereinander, weil das Auge kurze, helle Lichtimpulse viel leichter wahrnimmt. Ein Blitz dauert meist 50–60 ms; dieselbe Farbe blitzt zwei- oder dreimal, dann folgt eine kurze Pause, und die andere Seite macht dasselbe. Deshalb besteht jedes Muster im Code aus Schritten, die die Frage beantworten: "Welche LED ist an, und wie lange?" Die Zeiten in der Tabelle sind genau die Werte, die die Sketches in diesem Artikel verwenden; spiel ruhig mit den Zahlen und entwirf dein eigenes Muster.

MusterSchritte für eine SeiteZykluszeitBlitze pro Sekunde
Doppelblitz60 ms an, 60 ms aus, 60 ms an, 180 ms aus720 msEtwa 5,6
Dreifachblitz3 × (50 ms an, 50 ms aus), Schlusspause 170 ms840 msEtwa 7,1
Wechselblinken (Wig-Wag)250 ms rot, 250 ms blau500 ms4
WS2812B-LeisteDoppelblitz links und rechts, dann 4 × 150 ms Wechsel außen-innen1320 msJe nach Muster

Bauteile und Anschluss

BauteilArduino UnoESP32Raspberry Pi Pico
Rote LED (mit Vorwiderstand)D9GPIO 26GP11
Blaue LED (mit Vorwiderstand)D10GPIO 27GP12
Passiver BuzzerD8GPIO 25GP15
Taster für Muster (gegen GND)D2--
Taster für Sirene (gegen GND)D3--
WS2812B DIN (über 330 Ω)D6--
Gemeinsame MasseGNDGNDGND

Auf dem Steckbrett geht das lange Bein jeder LED über den Vorwiderstand zum Pin, das kurze Bein an GND. Den Widerstand berechnest du mit R = (UVersorgung - ULED) / I. Eine rote LED braucht etwa 2,0 V, eine blaue 3,0–3,2 V. Am 5-V-Ausgang des Uno lässt ein 220-Ω-Widerstand (5 - 2) / 220 ≈ 13,6 mA durch die rote und etwa 8,6 mA durch die blaue LED fließen, und beide sind gut zu sehen. ESP32 und Pico liefern 3,3 V, damit bleibt für die blaue LED kaum Spielraum: 150 Ω für Rot und 47–68 Ω für Blau funktionieren besser. Eigene Werte berechnest du mit dem LED-Vorwiderstandsrechner oder dem Artikel LED-Vorwiderstand berechnen. Die Taster werden mit INPUT_PULLUP gelesen, ein Bein kommt also an den Pin, das andere direkt an GND.

Ein Arduino-Pin ist für höchstens etwa 20 mA Dauerstrom ausgelegt. Willst du mehrere LEDs pro Farbe betreiben, schließ sie nicht direkt an den Pin an, sondern nimm einen NPN-Transistor wie BC547 oder 2N2222 (Basiswiderstand 1 kΩ) oder einen ULN2003-Treiber. Wie das Schalten mit Transistor funktioniert, steht im Artikel Was ist ein Transistor.

Erster Versuch: Doppelblitz mit 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}

Die Funktion flash() schaltet den Pin zweimal für 60 ms ein und aus und wartet danach weitere 120 ms; so dauert jede Seite 360 ms, genau wie in der Tabelle. Der Code ist kurz und leicht verständlich, hat aber einen großen Haken: Solange delay() läuft, kann der Arduino nichts anderes tun. Taster reagieren verzögert, die Sirene stottert, und zwei Lichtgruppen mit unterschiedlichem Tempo lassen sich nicht gemeinsam steuern. Deshalb wechseln wir im nächsten Schritt zu einer Struktur, die die Zeit mit millis() misst und nie wartet. Die Grundlagen dazu findest du im Artikel millis statt delay.

Blaulicht ohne delay mit millis und Sirene

Beim nicht blockierenden Ansatz ist jedes Muster eine Liste von Schritten: Jeder Schritt speichert den Zustand der roten und der blauen LED und wie viele Millisekunden er dauert. loop() fragt bei jedem Durchlauf nur: "Ist der aktuelle Schritt vorbei?" Wenn ja, geht es zum nächsten Schritt und die LEDs werden aktualisiert. In derselben loop() ändert die Sirene alle 10 ms ihre Frequenz und die Taster werden gelesen. So laufen alle drei Aufgaben parallel, und keine bremst die anderen aus.

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}

Das Array PATTERNS enthält die drei Muster nacheinander; jeder Druck auf den Taster an D2 schaltet zum nächsten Muster und setzt den Schrittzähler zurück. Der Taster an D3 schaltet die Sirene ein und aus. Die Funktion pressed() zählt nur den Moment, in dem der Taster von HIGH auf LOW wechselt, und verlangt 200 ms zwischen zwei Drücken; so wird das Prellen nicht als mehrere Tastendrücke erkannt. Für einen anderen Sirenentyp setzt du die Konstante SIREN auf WAIL, YELP oder HILO. Ergänzt du diese Struktur um einen Zustandsautomaten, kannst du Modi wie "Streife", "Verfolgung" und "Parken" entwerfen.

Sirenenton: Wail, Yelp und Zweiklang

SirenentypFrequenzZyklusCharakter
Wail (lang)600 → 1400 → 600 HzEtwa 4 sDer klassische, langsam an- und abschwellende Ton, verbreitet in Nord- und Südamerika
Yelp (schnell)600 → 1400 → 600 HzEtwa 0,3 sDas schnelle Jaulen an Kreuzungen und im Notfall
Hi-Lo (Zweiklang)440 Hz und 587 Hz0,5 s je TonErinnert an das Martinshorn und andere europäische Sirenen
Für die Sirene brauchst du einen passiven Buzzer; ein aktiver Buzzer piept immer mit seiner festen Frequenz und kann keine Tonhöhe durchfahren. Den Unterschied und Melodiebeispiele findest du im Artikel Was ist ein Buzzer. Am Uno nutzt tone() den Timer2; während die Sirene läuft, funktioniert analogWrite an den Pins 3 und 11 nicht richtig. Brauchst du PWM, nimm die Pins 5, 6, 9 oder 10.

Blaulicht-Lichtleiste mit WS2812B an einem Pin

Am nächsten an eine echte Lichtleiste kommst du mit adressierbaren LEDs. Auf einer WS2812B-Leiste mit acht LEDs leuchten die vier linken rot und die vier rechten blau, alle gesteuert über einen einzigen Datenpin. Jeder Schritt im Code besteht aus einer Maske und einer Dauer: Jedes Bit der Maske steht für eine LED. 0x0F schaltet zum Beispiel die vier linken LEDs ein, 0xF0 die vier rechten und 0xC3 die äußeren LEDs (0, 1, 6, 7). Installiere über den Bibliotheksverwalter die Bibliothek Adafruit NeoPixel; für ein deutsches Blaulicht ersetzt du in showMask() einfach Rot durch Blau.

Adressierbare RGB-LED WS2812B NeoPixel
Jede WS2812B-LED hat ihren eigenen Treiber eingebaut, deshalb bekommt über eine einzige Datenleitung jede LED ihre eigene Farbe.
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}

Die Funktion showMask() geht die acht LEDs durch, schaltet die LEDs mit Bit 1 in der Farbe ihrer Seite ein, alle anderen aus, und schickt am Ende mit bar.show() alles in einem Rutsch an den Streifen. Mit zusätzlichen Schritten am Ende des Musters entwirfst du ganz leicht eigene Effekte, die sich von der Mitte ausbreiten, rotieren oder die ganze Leiste blitzen lassen. Bei einem längeren Streifen änderst du NUM_LEDS und erweiterst die Masken auf einen 16- oder 32-Bit-Typ.

Setz einen 330-Ω-Widerstand in die Datenleitung und einen 1000-µF-Kondensator zwischen 5 V und GND, und verbinde immer die Masse von Arduino und Streifen. Eine WS2812B, die eine Farbe mit voller Helligkeit zeigt, zieht etwa 20 mA; für 8 LEDs reicht USB, ab etwa 30 LEDs brauchst du ein eigenes 5-V-Netzteil. Die Zeile setBrightness(80) senkt sowohl den Strom als auch die Blendung.

Blaulicht mit dem ESP32

Am ESP32 funktionieren die LEDs mit derselben digitalWrite-Logik; anders ist nur die Tonerzeugung. Die Sirene kommt aus der Funktion ledcWriteTone des LEDC-Controllers. Im ESP32-Arduino-Core 3.x wird der Pin direkt mit ledcAttach(Pin, Frequenz, Auflösung) verbunden, unter 2.x richtest du zuerst mit ledcSetup einen Kanal ein und verbindest ihn dann mit ledcAttachPin. Der folgende Code trennt beides mit #if und kompiliert deshalb mit beiden Versionen. Weil der ESP32 mit 3,3 V arbeitet, denk an den kleineren Vorwiderstand für die blaue LED. Mit WLAN kannst du das Blaulicht sogar per Handy schalten; für den Einstieg lies Was ist der 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}

Blaulicht mit dem Raspberry Pi Pico (MicroPython)

Auf dem Pico passt dieselbe Idee in wenige Zeilen MicroPython. Die Schritte sind eine Liste aus Tripeln (rot, blau, Dauer); die Zeit wird mit time.ticks_ms() und time.ticks_diff() gemessen, der Buzzer läuft über machine.PWM. Die rote LED hängt an GP11, die blaue an GP12 und der passive Buzzer an GP15. Möchtest du WS2812B-LEDs nutzen, setzt du dieselbe Maskenlogik mit dem neopixel-Modul um, das MicroPython bereits mitbringt. Falls du MicroPython noch nicht auf den Pico gespielt hast, beginne mit Was ist der Raspberry Pi Pico und MicroPython-Grundlagen.

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)

Projektideen mit Blaulicht

  • Spielzeug-Streifenwagen: Montiere das Blaulicht auf das Fahrgestell eines Roboterautos und lass die Sirene beim Fahren laufen.
  • Modellbahn und Diorama: Steuere den Streifenwagen mit demselben Arduino wie eine Ampel und die Straßenbeleuchtung.
  • Feuerwehr und Rettungswagen: Baue weitere Fahrzeuge mit Blau-Weiß-Muster und Zweiklangsirene.
  • Alarmanlage: Lass Blaulicht und Sirene anspringen, sobald ein PIR-Sensor eine Bewegung erkennt.
  • Ferngesteuertes Blaulicht: Wechsle die Muster mit einer IR-Fernbedienung und starte die Sirene aus der Entfernung.
  • Sammlung von Lichteffekten: Kombiniere die Blaulichtmuster mit Knight-Rider- und Lauflicht-Effekten in einem Projekt.

Häufige Fehler und Lösungen

SymptomMögliche UrsacheLösung
LED leuchtet nichtLED falsch herum eingestecktLanges Bein über den Vorwiderstand an den Pin, kurzes Bein an GND
Blaue LED sehr schwachBei 3,3 V liegt die blaue LED knapp an ihrer FlussspannungKleineren Widerstand (47–68 Ω) nehmen oder über Transistor aus 5 V speisen
Sirene gibt nur einen Ton oder brummtAktiver Buzzer verwendetPassiven Buzzer einsetzen
Ein Druck überspringt zwei MusterPrellen des TastersDie 200 ms in pressed() erhöhen
PWM an Pin 3 oder 11 spinnt bei laufender Sirenetone() belegt Timer2PWM-Ausgänge auf die Pins 5, 6, 9 oder 10 legen
WS2812B zeigt zufällige FarbenKeine gemeinsame Masse, kein Datenwiderstand oder schwaches NetzteilMassen verbinden, 330 Ω und 1000 µF ergänzen
Blaues Blinklicht und Martinshorn sind in Deutschland nach der StVZO Einsatzfahrzeugen vorbehalten; an einem privaten Fahrzeug im Straßenverkehr sind sie verboten, und Rot-Blau-Leuchten erst recht. Dieses Projekt ist für Spielzeug, Modellbau, Bühnendeko und Lernzwecke gedacht; richte helle LEDs nie auf die Augen anderer.

Ein Blaulicht verbindet LEDs, Widerstände, Timing und Tonerzeugung in einem einzigen unterhaltsamen Projekt, und die Logik mit Schrittlisten, die du hier gelernt hast, hilft dir bei vielen weiteren Projekten von der Ampel bis zur Lichtshow. In der BlueGrays-App findest du Polizeilicht-Projekte für Arduino, ESP32, Raspberry Pi Pico und WS2812B mit Schritt-für-Schritt-Schaltplänen und Code sowie Buzzer-Projekte, mit denen du die Sirene weiter verfeinern kannst.

Häufige Fragen

Was brauche ich für ein Blaulicht mit Arduino?

Für die einfachste Version genügen ein Arduino Uno, zwei LEDs (rot und blau oder zweimal blau), zwei 220-Ω-Widerstände, ein Steckbrett und Jumperkabel. Für die Sirene kommt ein passiver Buzzer dazu, für die Lichtleiste ein WS2812B-Streifen mit 8 LEDs.

Welchen Vorwiderstand brauche ich für rote und blaue LEDs?

Am 5-V-Ausgang des Arduino Uno sind 220 Ω für beide Farben ein guter Startwert und ergeben 9–14 mA. An ESP32 und Pico mit 3,3 V leuchten 150 Ω für Rot und 47–68 Ω für Blau heller. Du kannst den Wert auch selbst mit R = (U - ULED) / I berechnen.

Warum millis statt delay für ein Blaulicht?

Während delay() läuft, macht der Arduino nichts anderes: Taster werden nicht gelesen und die Sirene setzt aus. Mit millis() misst du die Zeit jeder Aufgabe getrennt, sodass Licht, Sirene und Taster gleichzeitig funktionieren. Außerdem lassen sich Muster so viel leichter wechseln.

Wie erzeuge ich mit dem Arduino einen Sirenenton?

Mit einem passiven Buzzer, dessen Frequenz du mit tone() ständig änderst. Fährst du in etwa 4 Sekunden zwischen 600 und 1400 Hz hin und her, entsteht die Wail-Sirene, in 0,3 Sekunden die Yelp-Sirene. Für einen Zweiklang wie beim Martinshorn wechselst du jede halbe Sekunde zwischen zwei Tönen, etwa 440 und 587 Hz.

Wie viele WS2812B-LEDs brauche ich für eine Lichtleiste?

Eine Leiste mit 8 LEDs, je 4 pro Seite, wirkt bereits wie eine echte Lichtleiste. Für längere Streifen nutzt du denselben Code mit größerem NUM_LEDS; ab etwa 30 LEDs brauchst du ein separates 5-V-Netzteil.

Darf ich ein selbstgebautes Blaulicht im Auto benutzen?

Nein. Blaues Blinklicht und Martinshorn sind nach der StVZO Einsatzfahrzeugen vorbehalten; wer sie an einem Privatfahrzeug im Straßenverkehr nutzt, begeht eine Ordnungswidrigkeit. Das Projekt ist ausschließlich für Spielzeug, Modellbau und Lernzwecke gedacht.

Alle Projekte ansehen
LED-Polizeilicht
AR-4Anfänger

LED-Polizeilicht

Wie das Blaulicht am Polizeiauto: Die rote LED blitzt dreimal schnell hintereinander, dann blitzt die blaue dreimal, und das Ganze wiederholt sich ohne Pause.

4.7(105)
283
Raspberry Pi Pico Polizeilicht-Effekt (Rot + Blau Strobe)
PI-5Anfänger

Raspberry Pi Pico Polizeilicht-Effekt (Rot + Blau Strobe)

Wir simulieren das Blaulicht eines Polizeiautos mit einem Raspberry Pi Pico in seiner einfachsten Form! Die rote und die blaue LED leuchten abwechselnd (Flip-Flop): Leuchtet Rot, ist Blau aus, alle 0,3 Sekunden tauschen sie, endlos. Der Code schreibt die zwei Schritte direkt in eine einzige while True-Schleife; die Geschwindigkeit legt die Konstante WAIT_MS fest.

4.7(3)
10
Verwendung des Summers
AR-13Anfänger

Verwendung des Summers

Hast du dich mal gefragt, wie eine Türklingel oder ein Alarm seinen Ton erzeugt? Der Arduino lässt einen kleinen Summer in kurzen Abständen piepen: piep, Pause, piep, Pause.

4.7(92)
171
Frequenzeinstellung mit Buzzer
AR-14Mittel

Frequenzeinstellung mit Buzzer

Mit vier Knöpfen steuerst du den Ton eines Summers: Einer startet den Ton, einer macht ihn stumm, die anderen beiden machen ihn höher oder tiefer.

4.6(69)
120
Polizeilicht mit WS2812B
AR-70Mittel
Premium

Polizeilicht mit WS2812B

Du holst dir das rot-blaue Blaulicht vom Dach eines Polizeiautos auf den Schreibtisch.

4.8(67)
86
ESP32 Polizei-Blinklicht-Effekt
ES-7Anfänger
Premium

ESP32 Polizei-Blinklicht-Effekt

Simuliere die Blinklichter eines Polizeiautos, indem du rote und blaue LED-Gruppen schnell aufblinken lässt. Mit jeweils 2 LEDs in einer Gruppe wird der Effekt noch dramatischer. Ein klassisches Beispiel für schnelle Toggle-Muster und Gruppensteuerung.

4.6(21)
36
Raspberry Pi Pico 3-Burst Polizei Flip-Flop (2 LEDs)
PI-6Anfänger

Raspberry Pi Pico 3-Burst Polizei Flip-Flop (2 LEDs)

Rhythmische Variation des Polizei-Strobe-Projekts — 3-Burst Flip-Flop! Gleiche 2-LED-Schaltung, aber anderes Muster: rote LED blitzt 3-mal schnell, dann blaue 3-mal, für immer.

5.0(1)
16
WS2812B-LED-Streifen verwenden
AR-69Mittel
Premium

WS2812B-LED-Streifen verwenden

Du lernst einen smarten LED-Streifen kennen, bei dem du jedes einzelne Licht für sich einfärben kannst.

4.8(54)
70