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.

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.
| Muster | Schritte für eine Seite | Zykluszeit | Blitze pro Sekunde |
|---|---|---|---|
| Doppelblitz | 60 ms an, 60 ms aus, 60 ms an, 180 ms aus | 720 ms | Etwa 5,6 |
| Dreifachblitz | 3 × (50 ms an, 50 ms aus), Schlusspause 170 ms | 840 ms | Etwa 7,1 |
| Wechselblinken (Wig-Wag) | 250 ms rot, 250 ms blau | 500 ms | 4 |
| WS2812B-Leiste | Doppelblitz links und rechts, dann 4 × 150 ms Wechsel außen-innen | 1320 ms | Je nach Muster |
Bauteile und Anschluss
| Bauteil | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| Rote LED (mit Vorwiderstand) | D9 | GPIO 26 | GP11 |
| Blaue LED (mit Vorwiderstand) | D10 | GPIO 27 | GP12 |
| Passiver Buzzer | D8 | GPIO 25 | GP15 |
| Taster für Muster (gegen GND) | D2 | - | - |
| Taster für Sirene (gegen GND) | D3 | - | - |
| WS2812B DIN (über 330 Ω) | D6 | - | - |
| Gemeinsame Masse | GND | GND | GND |
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.
Erster Versuch: Doppelblitz mit 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}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.
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
| Sirenentyp | Frequenz | Zyklus | Charakter |
|---|---|---|---|
| Wail (lang) | 600 → 1400 → 600 Hz | Etwa 4 s | Der klassische, langsam an- und abschwellende Ton, verbreitet in Nord- und Südamerika |
| Yelp (schnell) | 600 → 1400 → 600 Hz | Etwa 0,3 s | Das schnelle Jaulen an Kreuzungen und im Notfall |
| Hi-Lo (Zweiklang) | 440 Hz und 587 Hz | 0,5 s je Ton | Erinnert an das Martinshorn und andere europäische Sirenen |
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.

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.
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.
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.
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
| Symptom | Mögliche Ursache | Lösung |
|---|---|---|
| LED leuchtet nicht | LED falsch herum eingesteckt | Langes Bein über den Vorwiderstand an den Pin, kurzes Bein an GND |
| Blaue LED sehr schwach | Bei 3,3 V liegt die blaue LED knapp an ihrer Flussspannung | Kleineren Widerstand (47–68 Ω) nehmen oder über Transistor aus 5 V speisen |
| Sirene gibt nur einen Ton oder brummt | Aktiver Buzzer verwendet | Passiven Buzzer einsetzen |
| Ein Druck überspringt zwei Muster | Prellen des Tasters | Die 200 ms in pressed() erhöhen |
| PWM an Pin 3 oder 11 spinnt bei laufender Sirene | tone() belegt Timer2 | PWM-Ausgänge auf die Pins 5, 6, 9 oder 10 legen |
| WS2812B zeigt zufällige Farben | Keine gemeinsame Masse, kein Datenwiderstand oder schwaches Netzteil | Massen verbinden, 330 Ω und 1000 µF ergänzen |
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.
Projekte, die du danach bauen kannst
Alle Projekte ansehen
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.

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.

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.

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.

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

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.

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.

WS2812B-LED-Streifen verwenden
Du lernst einen smarten LED-Streifen kennen, bei dem du jedes einzelne Licht für sich einfärben kannst.
Weitere Artikel
BlueGrays-App
Diese Schaltung Schritt für Schritt auf dem Handy nachbauen
Schaltplan, Code und Teileliste auf einem Bildschirm. Über 500 Arduino-, ESP32- und Pico-Projekte zum Nachbauen.
Mit dem Handy scannen
Richte die Kamera auf den Code, dann öffnet sich der App-Store deines Handys.
oder im Store öffnen

