Guides · 8 min de lecture

Gyrophare Arduino : motifs de flash, ruban WS2812B et sirène

Fabrique un gyrophare Arduino : double et triple flash avec LED rouge et bleue, code sans delay avec millis, rampe WS2812B, sirène au buzzer, ESP32 et Pico.

Un gyrophare Arduino est l'un des premiers projets les plus amusants pour débuter : des LED rouge et bleue clignotent avec un rythme précis pour imiter la rampe lumineuse d'une voiture de police. Tu commences avec deux LED, deux résistances et quelques lignes de code ; avec une barrette WS2812B, tu obtiens une vraie rampe, et avec un buzzer passif, la sirène en plus. Nous utilisons ici le motif rouge-bleu à l'américaine ; pour un gyrophare à la française, mets simplement deux LED bleues. Parfait pour les voitures miniatures, les maquettes, les dioramas et les exposés scolaires.

Dans ce guide, tu verras dans un tableau, à la milliseconde près, les motifs de double et triple flash utilisés par les rampes. Tu feras d'abord la version la plus simple avec delay, puis tu écriras un code avec millis() qui fait tourner les lumières et la sirène en même temps, sans que l'une bloque l'autre. Ensuite, tu monteras une rampe de huit LED WS2812B pilotée par une seule broche et, pour finir, tu porteras le projet sur l'ESP32 et sur la Raspberry Pi Pico en MicroPython.

LED rouge et bleue de 5 mm
LED de 5 mm : la patte longue est l'anode (+), la courte la cathode (-). Une LED rouge et une bleue suffisent pour le gyrophare, deux bleues pour la version française.

Comment fonctionne un gyrophare ? Motifs de flash et timing

Les vraies rampes ne restent pas allumées longtemps : elles enchaînent des flashs très courts, car l'œil repère bien mieux les éclairs brefs et intenses. Chaque flash dure en général 50 à 60 ms ; une couleur flashe deux ou trois fois, il y a une courte pause, puis l'autre couleur fait de même. C'est pourquoi chaque motif du code se compose d'étapes qui répondent à la question "quelle LED est allumée, et combien de temps". Les durées du tableau sont exactement celles des programmes de ce guide ; amuse-toi à modifier les chiffres pour créer ton propre motif.

MotifÉtapes pour un côtéDurée du cycleFlashs par seconde
Double flash60 ms allumé, 60 ms éteint, 60 ms allumé, 180 ms éteint720 msEnviron 5,6
Triple flash3 × (50 ms allumé, 50 ms éteint), pause finale de 170 ms840 msEnviron 7,1
Alterné (wig-wag)250 ms rouge, 250 ms bleu500 ms4
Rampe WS2812BDouble flash gauche et droite, puis 4 × 150 ms d'alternance extérieur-intérieur1320 msSelon le motif

Matériel et câblage

ComposantArduino UnoESP32Raspberry Pi Pico
LED rouge (avec résistance)D9GPIO 26GP11
LED bleue (avec résistance)D10GPIO 27GP12
Buzzer passifD8GPIO 25GP15
Bouton de motif (vers GND)D2--
Bouton de sirène (vers GND)D3--
DIN de la WS2812B (via 330 Ω)D6--
Masse communeGNDGNDGND

Sur la plaque d'essai, la patte longue de chaque LED va à la broche à travers la résistance et la patte courte à GND. La valeur de la résistance se calcule avec R = (Valim - VLED) / I. Une LED rouge demande environ 2,0 V et une LED bleue 3,0 à 3,2 V. Sur la sortie 5 V de l'Uno, une résistance de 220 Ω laisse passer (5 - 2) / 220 ≈ 13,6 mA dans la LED rouge et environ 8,6 mA dans la bleue, et les deux se voient bien. L'ESP32 et la Pico fournissent 3,3 V, ce qui laisse très peu de marge à la LED bleue : 150 Ω pour le rouge et 47 à 68 Ω pour le bleu donnent un meilleur résultat. Pour calculer tes propres valeurs, utilise le calculateur de résistance pour LED ou le guide calculer la résistance d'une LED. Les boutons sont lus en INPUT_PULLUP : une patte va à la broche, l'autre directement à GND.

Une broche d'Arduino est prévue pour environ 20 mA en continu au maximum. Si tu veux plusieurs LED par couleur, ne les branche pas directement sur la broche : utilise un transistor NPN comme le BC547 ou le 2N2222 (résistance de base de 1 kΩ) ou un pilote ULN2003. La commutation par transistor est expliquée dans qu'est-ce qu'un transistor.

Premier essai : double flash avec 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 fonction flash() allume et éteint la broche deux fois pendant 60 ms, puis attend encore 120 ms ; chaque côté dure ainsi 360 ms, comme dans le tableau. Le code est court et facile à comprendre, mais il a un gros défaut : pendant que delay() s'exécute, l'Arduino ne peut rien faire d'autre. Les boutons réagissent en retard, la sirène est hachée et tu ne peux pas gérer deux groupes de lumières à des rythmes différents. C'est pourquoi l'étape suivante passe à une structure qui mesure le temps avec millis() et n'attend jamais. Pour les bases, lis le guide millis ou delay.

Gyrophare sans delay avec millis et sirène

Dans la méthode non bloquante, chaque motif est une liste d'étapes : chaque étape mémorise l'état des LED rouge et bleue et sa durée en millisecondes. À chaque tour, loop() se demande seulement "l'étape en cours est-elle terminée ?" ; si oui, elle passe à la suivante et met à jour les LED. Dans la même loop(), la sirène change de fréquence toutes les 10 ms et les boutons sont lus. Les trois tâches avancent ainsi en parallèle sans se gêner.

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}

Le tableau PATTERNS contient les trois motifs dans l'ordre ; chaque appui sur le bouton de D2 passe au motif suivant et remet le compteur d'étapes à zéro. Le bouton de D3 active ou coupe la sirène. La fonction pressed() ne compte que le moment où le bouton passe de HIGH à LOW et exige 200 ms entre deux appuis, ce qui évite que les rebonds soient lus comme plusieurs appuis. Pour changer de type de sirène, il suffit de régler la constante SIREN sur WAIL, YELP ou HILO. Ajoute une machine à états à cette structure et tu pourras créer des modes comme "patrouille", "poursuite" ou "stationné".

Son de sirène : wail, yelp et deux-tons

Type de sirèneFréquenceCycleCaractère
Wail (long)600 → 1400 → 600 HzEnviron 4 sLe son classique qui monte et descend lentement, répandu sur le continent américain
Yelp (rapide)600 → 1400 → 600 HzEnviron 0,3 sLe hululement rapide utilisé aux carrefours et en urgence
Hi-lo (deux-tons)440 Hz et 587 Hz0,5 s par tonProche du deux-tons des véhicules d'urgence en France et en Europe
La sirène demande un buzzer passif ; un buzzer actif sonne toujours sur sa propre fréquence fixe et ne peut pas faire de balayage. La différence et des exemples de mélodies se trouvent dans qu'est-ce qu'un buzzer. Sur l'Uno, tone() utilise le Timer2 : pendant que la sirène sonne, analogWrite fonctionne mal sur les broches 3 et 11, choisis donc les broches 5, 6, 9 ou 10 si tu as besoin de PWM.

Rampe de gyrophare WS2812B sur une seule broche

Le résultat le plus proche d'une vraie rampe s'obtient avec des LED adressables. Sur une barrette WS2812B de huit LED, les quatre de gauche s'allument en rouge et les quatre de droite en bleu, toutes commandées par une seule broche de données. Chaque étape du code se compose d'un masque et d'une durée : chaque bit du masque représente une LED. Par exemple, 0x0F allume les quatre LED de gauche, 0xF0 les quatre de droite et 0xC3 celles des extrémités (0, 1, 6, 7). Installe la bibliothèque Adafruit NeoPixel depuis le gestionnaire de bibliothèques.

LED RGB adressable WS2812B NeoPixel
Chaque LED WS2812B contient son propre pilote : une seule ligne de données suffit pour donner une couleur différente à chacune.
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 fonction showMask() parcourt les huit LED, allume dans la couleur de leur côté celles dont le bit vaut 1, éteint les autres et envoie le tout au ruban en une fois avec bar.show(). En ajoutant des étapes à la fin du motif, tu crées facilement tes propres effets : ouverture depuis le centre, rotation ou flash de toute la rampe. Avec un ruban plus long, modifie NUM_LEDS et passe les masques sur un type 16 ou 32 bits.

Place une résistance série de 330 Ω sur la ligne de données et un condensateur de 1000 µF entre 5 V et GND, et relie toujours les masses de l'Arduino et du ruban. Une WS2812B affichant une seule couleur à pleine luminosité consomme environ 20 mA ; l'USB suffit pour 8 LED, mais à partir d'une trentaine de LED il faut une alimentation 5 V séparée. La ligne setBrightness(80) réduit à la fois le courant et l'éblouissement.

Gyrophare avec un ESP32

Sur l'ESP32, les LED fonctionnent avec la même logique digitalWrite ; c'est la production du son qui change. La sirène sort de la fonction ledcWriteTone du contrôleur LEDC. Avec la version 3.x du cœur Arduino pour ESP32, la broche est attachée directement avec ledcAttach(broche, fréquence, résolution) ; en 2.x, on configure d'abord un canal avec ledcSetup puis on le relie à la broche avec ledcAttachPin. Le code ci-dessous sépare les deux cas avec #if et se compile donc sur les deux versions. Comme l'ESP32 fonctionne en 3,3 V, pense à la petite résistance pour la LED bleue. En ajoutant le Wi-Fi, tu peux même allumer le gyrophare depuis ton téléphone ; pour commencer, lis qu'est-ce que l'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}

Gyrophare avec une Raspberry Pi Pico (MicroPython)

Sur la Pico, la même idée tient en quelques lignes de MicroPython. Les étapes forment une liste de triplets (rouge, bleu, durée) ; le temps se mesure avec time.ticks_ms() et time.ticks_diff(), et le buzzer est piloté par machine.PWM. La LED rouge va sur GP11, la bleue sur GP12 et le buzzer passif sur GP15. Pour utiliser des WS2812B, applique la même logique de masques avec le module neopixel fourni avec MicroPython. Si tu n'as pas encore installé MicroPython sur la Pico, commence par qu'est-ce que la Raspberry Pi Pico et les bases 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)

Idées de projets avec un gyrophare

  • Voiture de police miniature : monte le gyrophare sur le châssis d'une voiture robot et fais sonner la sirène pendant qu'elle roule.
  • Ville en maquette : pilote la voiture de police avec le même Arduino qu'un feu tricolore et l'éclairage public.
  • Pompiers et ambulance : crée d'autres véhicules avec un motif bleu-blanc et une sirène deux-tons.
  • Système d'alarme : déclenche gyrophare et sirène dès qu'un capteur PIR détecte un mouvement.
  • Gyrophare télécommandé : change de motif avec une télécommande IR et lance la sirène à distance.
  • Collection d'effets lumineux : réunis les motifs de police et les effets K2000 et chenillard dans un même projet.

Erreurs fréquentes et solutions

SymptômeCause probableSolution
La LED ne s'allume pasLED montée à l'enversPatte longue vers la broche via la résistance, patte courte à GND
LED bleue très faibleEn 3,3 V la LED bleue est presque à sa tension de seuilPrendre une résistance plus faible (47–68 Ω) ou l'alimenter en 5 V via un transistor
La sirène ne donne qu'un ton ou grésilleBuzzer actif utiliséPasser à un buzzer passif
Un appui saute deux motifsRebonds du boutonAugmenter les 200 ms dans pressed()
Le PWM des broches 3 ou 11 déraille avec la sirènetone() utilise le Timer2Déplacer les sorties PWM sur les broches 5, 6, 9 ou 10
La WS2812B affiche des couleurs aléatoiresPas de masse commune, pas de résistance de données ou alimentation faibleRelier les masses, ajouter 330 Ω et 1000 µF
En France, comme dans la plupart des pays, les feux bleus clignotants et le deux-tons sont réservés aux véhicules d'intérêt général prioritaires ; les installer sur un véhicule particulier est interdit. Ce projet est destiné aux jouets, aux maquettes, aux décors de scène et aux démonstrations pédagogiques ; ne dirige jamais des LED puissantes vers les yeux de quelqu'un.

Le gyrophare réunit LED, résistances, timing et production de son dans un seul projet amusant, et la logique de listes d'étapes que tu as apprise ici te servira dans bien d'autres, du feu tricolore au spectacle lumineux. Dans l'application BlueGrays, tu trouveras des projets de gyrophare pour Arduino, ESP32, Raspberry Pi Pico et WS2812B avec schémas et code pas à pas, ainsi que des projets de buzzer pour peaufiner ta sirène.

Questions fréquentes

Quel matériel faut-il pour un gyrophare Arduino ?

Pour la version la plus simple, il suffit d'un Arduino Uno, d'une LED rouge et d'une LED bleue, de deux résistances de 220 Ω, d'une plaque d'essai et de câbles. Ajoute un buzzer passif pour la sirène et une barrette WS2812B de 8 LED pour la rampe.

Quelle résistance choisir pour une LED rouge et une LED bleue ?

Sur la sortie 5 V de l'Arduino Uno, 220 Ω est un bon point de départ pour les deux couleurs et donne 9 à 14 mA. Sur l'ESP32 et la Pico en 3,3 V, 150 Ω pour le rouge et 47 à 68 Ω pour le bleu éclairent davantage. Tu peux aussi la calculer avec R = (V - VLED) / I.

Pourquoi utiliser millis plutôt que delay pour faire clignoter des LED ?

Pendant delay(), l'Arduino ne fait rien d'autre : les boutons ne sont pas lus et la sirène se coupe. Avec millis(), tu chronomètres chaque tâche séparément, si bien que lumières, sirène et boutons fonctionnent en même temps. Changer de motif devient aussi beaucoup plus simple.

Comment faire un son de sirène avec un buzzer Arduino ?

Avec un buzzer passif dont tu modifies sans cesse la fréquence grâce à tone(). Un balayage de 600 à 1400 Hz en environ 4 secondes donne la sirène wail, en 0,3 seconde la sirène yelp. Pour un deux-tons, alterne simplement 440 et 587 Hz toutes les demi-secondes.

Combien de LED WS2812B pour une rampe de gyrophare ?

Une barrette de 8 LED, 4 rouges à gauche et 4 bleues à droite, donne déjà une rampe réaliste. Pour des rubans plus longs, garde le même code en augmentant NUM_LEDS ; au-delà d'une trentaine de LED, une alimentation 5 V séparée est nécessaire.

Peut-on installer un gyrophare fait maison sur sa voiture ?

Non. Les feux bleus et le deux-tons sont réservés aux véhicules prioritaires autorisés, et leur usage sur une voiture particulière est sanctionné. Ce projet est uniquement destiné aux jouets, aux maquettes et à l'apprentissage.

Voir tous les projets
Gyrophare de police à LED
AR-4Débutant

Gyrophare de police à LED

Comme le gyrophare d'une voiture de police : la LED rouge flashe trois fois très vite, puis la bleue flashe trois fois à son tour, et la séquence se répète sans fin.

4.7(105)
283
Raspberry Pi Pico Effet Gyrophare Police (Rouge + Bleu Stroboscope)
PI-5Débutant

Raspberry Pi Pico Effet Gyrophare Police (Rouge + Bleu Stroboscope)

Nous simulons la rampe lumineuse d'une voiture de police avec un Raspberry Pi Pico, dans sa version la plus simple ! Les LED rouge et bleue s'allument à tour de rôle (flip-flop) : quand la rouge est allumée, la bleue est éteinte, et elles s'échangent toutes les 0,3 seconde, sans fin. Le code écrit les deux étapes directement dans une seule boucle while True ; la vitesse se règle avec la constante WAIT_MS.

4.7(3)
10
Utilisation du buzzer
AR-13Débutant

Utilisation du buzzer

Tu t'es déjà demandé comment une sonnette ou une alarme produit son son ? L'Arduino fait biper un petit buzzer à intervalles courts : bip, silence, bip, silence.

4.7(92)
171
Réglage de la fréquence avec buzzer
AR-14Intermédiaire

Réglage de la fréquence avec buzzer

Tu contrôles le son d'un buzzer avec quatre boutons : l'un lance le son, l'autre le coupe, et les deux derniers le rendent plus aigu ou plus grave.

4.6(69)
120
Gyrophare de police avec WS2812B
AR-70Intermédiaire
Premium

Gyrophare de police avec WS2812B

Tu ramènes sur ton bureau le gyrophare rouge et bleu d'une voiture de police. Une moitié d'un ruban WS2812B de dix LED clignote trois fois très vite en rouge, l'autre moitié trois fois en bleu, et le…

4.8(67)
86
ESP32 Effet de Gyrophare de Police
ES-7Débutant
Premium

ESP32 Effet de Gyrophare de Police

Simule les gyrophares d'une voiture de police en faisant clignoter rapidement des groupes de LED rouges et bleues. Avec 2 LED dans chaque groupe, l'effet est plus spectaculaire. Un exemple classique de basculement rapide et de contrôle par groupes.

4.6(21)
36
Raspberry Pi Pico Flip-Flop Gyrophare 3 Burst (2 LED)
PI-6Débutant

Raspberry Pi Pico Flip-Flop Gyrophare 3 Burst (2 LED)

Variation rythmique du projet gyrophare police — flip-flop 3 burst ! Même circuit à 2 LEDs, mais motif différent : LED rouge clignote 3 fois rapidement, puis bleu 3 fois, à l'infini.

5.0(1)
16
Utilisation du ruban LED WS2812B
AR-69Intermédiaire
Premium

Utilisation du ruban LED WS2812B

Tu découvres un ruban LED intelligent dont chaque lumière peut prendre sa propre couleur.

4.8(54)
70