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.

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 cycle | Flashs par seconde |
|---|---|---|---|
| Double flash | 60 ms allumé, 60 ms éteint, 60 ms allumé, 180 ms éteint | 720 ms | Environ 5,6 |
| Triple flash | 3 × (50 ms allumé, 50 ms éteint), pause finale de 170 ms | 840 ms | Environ 7,1 |
| Alterné (wig-wag) | 250 ms rouge, 250 ms bleu | 500 ms | 4 |
| Rampe WS2812B | Double flash gauche et droite, puis 4 × 150 ms d'alternance extérieur-intérieur | 1320 ms | Selon le motif |
Matériel et câblage
| Composant | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| LED rouge (avec résistance) | D9 | GPIO 26 | GP11 |
| LED bleue (avec résistance) | D10 | GPIO 27 | GP12 |
| Buzzer passif | D8 | GPIO 25 | GP15 |
| Bouton de motif (vers GND) | D2 | - | - |
| Bouton de sirène (vers GND) | D3 | - | - |
| DIN de la WS2812B (via 330 Ω) | D6 | - | - |
| Masse commune | GND | GND | GND |
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.
Premier essai : double flash avec 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}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.
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ène | Fréquence | Cycle | Caractère |
|---|---|---|---|
| Wail (long) | 600 → 1400 → 600 Hz | Environ 4 s | Le son classique qui monte et descend lentement, répandu sur le continent américain |
| Yelp (rapide) | 600 → 1400 → 600 Hz | Environ 0,3 s | Le hululement rapide utilisé aux carrefours et en urgence |
| Hi-lo (deux-tons) | 440 Hz et 587 Hz | 0,5 s par ton | Proche du deux-tons des véhicules d'urgence en France et en Europe |
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.

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.
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.
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.
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ôme | Cause probable | Solution |
|---|---|---|
| La LED ne s'allume pas | LED montée à l'envers | Patte longue vers la broche via la résistance, patte courte à GND |
| LED bleue très faible | En 3,3 V la LED bleue est presque à sa tension de seuil | Prendre 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ésille | Buzzer actif utilisé | Passer à un buzzer passif |
| Un appui saute deux motifs | Rebonds du bouton | Augmenter les 200 ms dans pressed() |
| Le PWM des broches 3 ou 11 déraille avec la sirène | tone() utilise le Timer2 | Déplacer les sorties PWM sur les broches 5, 6, 9 ou 10 |
| La WS2812B affiche des couleurs aléatoires | Pas de masse commune, pas de résistance de données ou alimentation faible | Relier les masses, ajouter 330 Ω et 1000 µF |
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.
Projets à réaliser après cet article
Voir tous les projets
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.

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.

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.

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.

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…

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.

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.

Utilisation du ruban LED WS2812B
Tu découvres un ruban LED intelligent dont chaque lumière peut prendre sa propre couleur.
Autres articles
Application BlueGrays
Réalise ce montage pas à pas sur ton téléphone
Schéma, code et liste des composants sur un seul écran. Plus de 500 projets Arduino, ESP32 et Pico à réaliser.
Scanne avec ton téléphone
Pointe l’appareil photo vers le code : la boutique d’applications de ton téléphone s’ouvre.
ou ouvre la boutique

