Capteur PIR HC-SR505 : mini PIR avec Arduino, ESP32, Pico, AM312
Capteur PIR HC-SR505 : différences avec le HC-SR501 et l'AM312, durée fixe de 8 s, usage en 3,3 V, calcul d'autonomie et code Arduino, ESP32 et Pico.
Le capteur PIR HC-SR505 est un mini détecteur de mouvement PIR (infrarouge passif) d'environ 1 cm de diamètre et 2,5 cm de haut, sans potentiomètre ni cavalier de réglage. Il fait le même travail que le classique HC-SR501, c'est-à-dire qu'il détecte une personne ou un animal qui bouge dans son champ de vision et passe sa sortie à HIGH, mais dans un boîtier bien plus petit. Il est idéal pour les sonnettes, l'éclairage de placard, les petits boîtiers d'alarme et les capteurs sur pile. L'AM312, de même taille, fonctionne dès 2,7 V et constitue souvent le meilleur choix pour l'ESP32, le Raspberry Pi Pico et les projets sur batterie.
Dans cet article, tu verras comment fonctionne le HC-SR505, ce qui le distingue du HC-SR501 et de l'AM312 dans un tableau comparatif, comment composer avec sa durée fixe de 8 secondes, les limites d'une alimentation en 3,3 V et un vrai calcul d'autonomie. Ensuite, nous écrirons un code Arduino qui compte les mouvements et mesure la durée de sortie, un code qui réveille un ESP32 du deep sleep au moindre mouvement et attend endormi que le mouvement cesse, et un code MicroPython à interruption pour le Raspberry Pi Pico.

Qu'est-ce que le HC-SR505 et comment fonctionne-t-il ?
Au cœur de tout capteur PIR se trouve un élément pyroélectrique composé de deux moitiés. Quand rien ne bouge, les deux moitiés reçoivent la même quantité de rayonnement infrarouge et leurs signaux s'annulent. Quand quelqu'un qui dégage de la chaleur traverse le champ de vision, une moitié puis l'autre reçoit davantage de rayonnement, et le capteur interprète cette différence comme un mouvement. La petite lentille de Fresnel placée devant découpe le champ de vision en zones et amplifie cette différence. Sur le HC-SR505, le circuit de traitement du signal, le régulateur et la lentille tiennent sur une minuscule carte, et la durée de sortie comme la sensibilité sont fixées en usine. Lorsqu'un mouvement est détecté, la sortie reste à HIGH environ 8 secondes, et si un nouveau mouvement survient pendant ce temps, le compte repart à zéro (redéclenchement).
| Caractéristique | HC-SR505 |
|---|---|
| Tension d'alimentation | 4,5–20 V (régulateur 3,3 V sur la carte) |
| Courant de veille | Moins de 60 µA |
| Sortie | Numérique : 3,3 V en cas de mouvement, 0 V sinon |
| Portée de détection | Jusqu'à 3 mètres |
| Angle de détection | Un cône de moins de 100° |
| Durée de sortie | Environ 8 secondes (±30 %), non réglable |
| Mode de déclenchement | Redéclenchable : la sortie reste à HIGH tant que le mouvement continue |
| Taille | Environ 10 mm de diamètre, 23–25 mm de haut |
| Température de fonctionnement | −20 à +80 °C |
HC-SR501, HC-SR505 et AM312 comparés
| Caractéristique | HC-SR501 | HC-SR505 | AM312 |
|---|---|---|---|
| Taille | Carte de 32 × 24 mm, grand dôme | Environ 10 mm de diamètre | Environ 10 mm, proche du HC-SR505 |
| Alimentation | 4,5–20 V | 4,5–20 V | 2,7–12 V |
| Courant de veille | Environ 50 µA | Moins de 60 µA | Moins de 0,1 mA |
| Niveau de sortie | 3,3 V | 3,3 V | Environ 3 V |
| Portée | 3–7 m, réglable | Jusqu'à 3 m | 3–5 m |
| Angle | Environ 110° | Moins de 100° | Moins de 100° |
| Durée de sortie | 3 s – 5 min, par potentiomètre | Fixe, environ 8 s | Fixe, environ 2 s |
| Mode de déclenchement | Cavalier H (redéclenchable) ou L (unique) | Redéclenchable uniquement | Redéclenchable uniquement |
| Quand le choisir ? | Pièces et couloirs, longue portée | Petits boîtiers, systèmes en 5 V | 3,3 V, batterie, ESP32 et Pico |
En résumé : si tu surveilles une grande pièce ou un long couloir et que tu veux régler la durée au tournevis, le HC-SR501 reste l'option la plus souple. Si ton boîtier est petit et que ton système fonctionne déjà en 5 V, le HC-SR505 fait l'affaire. Si tu utilises une carte en 3,3 V comme l'ESP32 ou le Pico, ou si tu alimentes le capteur directement par une cellule lithium, choisis l'AM312 : il est officiellement prévu pour une basse tension et sa courte durée de sortie de 2 secondes garde le microcontrôleur éveillé moins longtemps. Les trois ont une sortie d'environ 3 V, aucun n'a donc besoin d'un pont diviseur pour se brancher sur un ESP32.
Le HC-SR505 fonctionne-t-il en 3,3 V ?
Officiellement, non : le HC-SR505 a sur sa carte un petit régulateur avec une sortie de 3,3 V, et le minimum annoncé pour le module est de 4,5 V. Si tu envoies 3,3 V à l'entrée du régulateur, le circuit interne voit environ 3,1–3,2 V. Beaucoup de capteurs fonctionnent quand même, mais la sensibilité peut baisser et les faux déclenchements augmenter ; mieux vaut ne pas concevoir un produit en comptant là-dessus. Cette limite détermine aussi le choix des piles : 3 piles AA donnent 4,5 V neuves mais passent vite en dessous ; 4 piles AA ou NiMH sont plus sûres pour le HC-SR505. Sur une seule cellule Li-ion de 3,7 V, le HC-SR505 est sous sa limite, alors que l'AM312 continue de fonctionner jusqu'à 2,7 V.
Câblage : Arduino Uno, ESP32 et Pico
| Broche du capteur | Arduino Uno | ESP32 | Raspberry Pi Pico |
|---|---|---|---|
| VCC (+), HC-SR505 | 5V | VIN (5V) | VBUS (5V) |
| VCC (+), AM312 | 5V ou 3.3V | 3V3 | 3V3 (OUT) |
| OUT | D2 | GPIO 33 | GP16 |
| GND (−) | GND | GND | GND |
Code Arduino : compter les mouvements et mesurer la durée de sortie
Le code ci-dessous attend d'abord 30 secondes que le capteur chauffe, puis incrémente un compteur à chaque début de mouvement et, quand la sortie repasse à LOW, affiche combien de secondes elle est restée à HIGH. La LED intégrée suit aussi la sortie. Ce petit test est le moyen le plus simple de savoir si ton capteur est un HC-SR505 ou un AM312 et de voir comment fonctionne le redéclenchement. Ouvre le moniteur série à 115200 bauds :
1// HC-SR505 / AM312 testi: hareketi say, çıkışın HIGH kalma süresini ölç / count motion, measure how long OUT stays HIGH
2const int PIR_PIN = 2;
3const int LED_PIN = 13; // dahili LED / built-in LED
4
5bool lastState = LOW;
6unsigned long riseTime = 0;
7unsigned int events = 0;
8
9void setup() {
10 pinMode(PIR_PIN, INPUT);
11 pinMode(LED_PIN, OUTPUT);
12 Serial.begin(115200);
13 Serial.println(F("Isinma 30 sn / warming up 30 s"));
14 delay(30000); // açılıştaki yanlış tetiklemeleri atla / skip false triggers at power-up
15 Serial.println(F("Hazir / ready"));
16}
17
18void loop() {
19 bool state = digitalRead(PIR_PIN);
20 digitalWrite(LED_PIN, state); // LED çıkışı takip eder / LED follows the output
21 if (state == HIGH && lastState == LOW) { // yükselen kenar: hareket başladı / rising edge: motion started
22 riseTime = millis();
23 events++;
24 Serial.print(F("Hareket / motion #"));
25 Serial.println(events);
26 }
27 if (state == LOW && lastState == HIGH) { // düşen kenar: tutma süresi bitti / falling edge: hold time over
28 float seconds = (millis() - riseTime) / 1000.0;
29 Serial.print(F("OUT HIGH kaldi / stayed HIGH: "));
30 Serial.print(seconds, 1);
31 Serial.println(F(" s"));
32 }
33 lastState = state;
34}Si tu agites la main une fois puis la retires, tu verras environ 8 secondes avec un HC-SR505 (entre 5,6 et 10,4 secondes selon l'exemplaire) et environ 2 secondes avec un AM312. Si tu continues de bouger devant le capteur, le compte repart à chaque nouveau mouvement et tu liras une valeur bien plus longue ; c'est ça, le redéclenchement. Si tu veux que la lumière reste allumée 20 secondes ou 2 minutes après le dernier mouvement, gère la durée dans le code plutôt que dans le capteur ; nous montrons comment faire avec millis() dans détecteur de mouvement PIR.
Composer avec une durée et une sensibilité fixes
La grande différence du HC-SR505, c'est qu'il ne se règle pas. Tu peux allonger la durée dans le code autant que tu veux, mais pas descendre sous 8 secondes ; pour un jeu ou un compteur qui doit réagir vite, l'AM312 et ses 2 secondes convient mieux. La sensibilité est fixe elle aussi : tu façonnes donc la zone de détection physiquement plutôt que par logiciel. Sur le papier, un cône de 100° couvre à 3 mètres une zone d'environ 7 mètres de large ; en réalité, la détection faiblit vers les bords. Ces astuces aident à réduire la zone et les fausses alertes :
- Masque une partie de la lentille avec du ruban : Si tu couvres la moitié basse de la lentille avec un ruban opaque, le capteur verra moins les animaux au sol et les variations de température près du sol.
- Ajoute un tube en papier ou en plastique : Un tube de 2 à 3 cm devant le capteur réduit sa vue à un cône étroit, idéal pour une porte ou un seul couloir.
- Bonne hauteur et bonne orientation : Fixe le capteur à 1,5–2 mètres de haut ; un PIR détecte mieux un mouvement qui traverse son champ de côté et repère plus tard quelqu'un qui marche droit vers lui.
- Éloigne-le des sources de chaleur : Radiateurs, bouches de climatisation, fenêtres ensoleillées et lampes chaudes déclenchent le capteur par des variations brusques de température.
- Ne le mets pas derrière une vitre : Le verre ordinaire bloque le rayonnement infrarouge émis par la chaleur du corps ; un PIR derrière une fenêtre ne voit pas les mouvements dehors.
Faible consommation et projets sur batterie
En veille, les mini PIR consomment moins de 60 à 100 µA : à lui seul, le capteur ne peut pas vider une cellule 18650 avant des années. Ce qui détermine vraiment l'autonomie, c'est la carte à laquelle il est relié. Un Arduino Uno consomme environ 45 à 50 mA même sans rien faire et vide une batterie de 2000 mAh en moins de deux jours. C'est pourquoi, dans un détecteur de mouvement sur batterie, le microcontrôleur doit passer presque tout son temps à dormir et ne se réveiller que lorsque la sortie du PIR passe à HIGH. Le tableau donne des valeurs approximatives pour une cellule 18650 de 2000 mAh et 50 mouvements par jour :
| Montage | Courant en veille | Consommation par jour | Autonomie approximative |
|---|---|---|---|
| ESP32 DevKit (AMS1117, LED d'alimentation, puce USB) + HC-SR505 | Environ 6 mA | Environ 145 mAh | 2 semaines |
| Module ESP32 nu + LDO MCP1700 + mini PIR, sans Wi-Fi | Environ 75 µA | Environ 2,5 mAh | Plus de 2 ans en théorie |
| Même montage, notification Wi-Fi à chaque mouvement | Environ 75 µA | Environ 6,5 mAh | Environ 10 mois |
La première ligne n'a rien de surprenant : le régulateur AMS1117 des cartes de développement consomme à lui seul environ 5 mA. Pour une longue autonomie, alimente le module ESP32 par un LDO comme le MCP1700, dont le courant de repos n'est que de quelques µA. Dans la deuxième ligne, la batterie dure si longtemps que la vraie limite devient son autodécharge. Tu peux faire le calcul pour ton propre montage avec l'outil Autonomie de batterie, en apprendre plus sur les mAh dans capacité d'une batterie et sur l'utilisation sûre des cellules 18650 dans batterie Li-ion 18650.
ESP32 en deep sleep : réveil par HC-SR505 ou AM312
Avec le réveil ext0, l'ESP32 peut surveiller le niveau d'une seule broche GPIO RTC même en deep sleep. Il y a ici un piège que la plupart des exemples ignorent : si la carte se réveille quand la sortie du PIR passe à HIGH, fait son travail et se rendort aussitôt, la sortie est toujours à HIGH et elle se réveille immédiatement. Pendant les 8 secondes de sortie du HC-SR505, la carte s'allume et s'éteint des dizaines de fois et gaspille la batterie. Le code ci-dessous règle le problème : réveillé par un mouvement, il incrémente le compteur et allume la LED, puis, si la sortie est encore à HIGH, il se rendort avec une minuterie de 2 secondes. Une fois la sortie revenue à LOW, il réarme le réveil ext0. Le compteur est conservé dans la mémoire RTC_DATA_ATTR, qui survit au deep sleep.
1// ESP32 derin uyku + HC-SR505 / AM312: hareketle uyan, çıkış sakinleşene kadar uyuyarak bekle / ESP32 deep sleep: wake on motion, wait asleep until the output settles
2#include "driver/rtc_io.h"
3
4const gpio_num_t PIR_PIN = GPIO_NUM_33; // RTC GPIO olmalı / must be an RTC GPIO
5const int LED_PIN = 2; // çoğu DevKit'te dahili LED / onboard LED on most DevKits
6const uint64_t RECHECK_US = 2ULL * 1000000ULL; // OUT HIGH ise 2 sn sonra yeniden bak / recheck in 2 s while OUT is HIGH
7RTC_DATA_ATTR int motionCount = 0; // derin uykuda silinmez / survives deep sleep
8
9void sleepUntilMotion() {
10 rtc_gpio_pullup_dis(PIR_PIN);
11 rtc_gpio_pulldown_en(PIR_PIN); // boşta LOW kalsın / keep LOW when idle
12 esp_sleep_enable_ext0_wakeup(PIR_PIN, 1); // OUT HIGH olunca uyan / wake when OUT goes HIGH
13 esp_deep_sleep_start();
14}
15
16void sleepAndRecheck() {
17 esp_sleep_enable_timer_wakeup(RECHECK_US); // hareket sürüyor: uyuyarak bekle / motion goes on: wait asleep
18 esp_deep_sleep_start();
19}
20
21void setup() {
22 Serial.begin(115200);
23 pinMode(LED_PIN, OUTPUT);
24 esp_sleep_wakeup_cause_t cause = esp_sleep_get_wakeup_cause();
25
26 if (cause == ESP_SLEEP_WAKEUP_EXT0) { // yeni hareket / new motion
27 motionCount++;
28 Serial.printf("Hareket / motion #%d\n", motionCount);
29 digitalWrite(LED_PIN, HIGH); // bildirim kodu buraya / notification code goes here
30 delay(200);
31 digitalWrite(LED_PIN, LOW);
32 } else if (cause != ESP_SLEEP_WAKEUP_TIMER) { // ilk açılış ya da reset / first boot or reset
33 Serial.println("Sensor isiniyor 30 sn / sensor warming up 30 s");
34 delay(30000);
35 }
36
37 rtc_gpio_deinit(PIR_PIN); // pini normal girişe çevir / turn the pin back into a normal input
38 pinMode(PIR_PIN, INPUT);
39 if (digitalRead(PIR_PIN) == HIGH) sleepAndRecheck(); // hâlâ HIGH: hemen uyanmamak için bekle / still HIGH: avoid an instant re-wake
40 sleepUntilMotion();
41}
42
43void loop() {
44}Mini PIR avec le Raspberry Pi Pico (MicroPython)
Sur le Pico, une interruption (IRQ) est plus propre que de lire le capteur en boucle : la fonction s'exécute d'elle-même à chaque changement de la sortie, et la boucle principale reste disponible pour d'autres tâches. Le code ci-dessous incrémente le compteur et allume la LED sur le front montant, puis affiche sur le front descendant combien de temps la sortie est restée à HIGH. Alimente l'AM312 par la broche 3V3 (OUT) et le HC-SR505 par VBUS ; dans les deux cas, OUT va sur GP16 :
1# HC-SR505 / AM312 ile Raspberry Pi Pico: kesmeyle hareket sayacı / motion counter with an interrupt
2from machine import Pin
3import time
4
5pir = Pin(16, Pin.IN, Pin.PULL_DOWN) # GP16; boştayken LOW kalsın / stays LOW when idle
6led = Pin(25, Pin.OUT) # dahili LED; Pico W'de Pin("LED") / onboard LED; Pin("LED") on Pico W
7count = 0
8rise_ms = 0
9
10def on_change(pin):
11 global count, rise_ms
12 if pin.value(): # hareket başladı / motion started
13 count += 1
14 rise_ms = time.ticks_ms()
15 led.on()
16 print("Hareket / motion #", count)
17 else: # tutma süresi bitti / hold time over
18 led.off()
19 held = time.ticks_diff(time.ticks_ms(), rise_ms) / 1000
20 print("HIGH kaldi / stayed HIGH: {:.1f} s".format(held))
21
22time.sleep(30) # ısınma süresi / warm-up time
23pir.irq(trigger=Pin.IRQ_RISING | Pin.IRQ_FALLING, handler=on_change)
24
25while True:
26 time.sleep(1)Même dans ses modes de veille sous MicroPython, le Pico ne descend pas aussi bas que l'ESP32 en deep sleep. Pour un projet posé sur le bureau ou branché sur secteur, cela ne change rien, mais pour un détecteur de mouvement qui doit tenir des mois sur batterie, un ESP32 ou un Arduino Pro Mini, dont le courant de veille tombe à quelques microampères une fois la LED d'alimentation et le régulateur retirés, est un meilleur choix.
Faux déclenchements et solutions
| Symptôme | Cause probable | Solution |
|---|---|---|
| Se déclenche tout seul plusieurs fois à la mise sous tension | Le capteur chauffe et apprend son environnement | Attends 30 secondes après la mise sous tension ou ignore les premiers déclenchements |
| Se déclenche quand le Wi-Fi de l'ESP32 démarre | Le mini PIR capte les ondes radio de l'antenne | Éloigne le capteur d'au moins 10 cm de l'antenne et ajoute 100 nF et 10 µF entre VCC et GND |
| Ne se déclenche jamais | HC-SR505 alimenté sous 4,5 V ou capteur derrière une vitre | Alimente-le en 5 V ou passe à un AM312 ; retire la vitre |
| La sortie ne repasse jamais à LOW | Mouvement ou variations de température permanents dans le champ de vision | Éloigne le capteur des radiateurs, de la climatisation et des rideaux qui bougent, masque une partie de la lentille |
| Déclenchements aléatoires quand la batterie faiblit | L'alimentation du capteur devient instable quand la tension baisse | Alimente le capteur par une ligne régulée et recharge la batterie à temps |
| L'ESP32 se réveille sans arrêt | Mise en veille avec réveil ext0 alors que la sortie est à HIGH | Attends avec une minuterie que la sortie soit à LOW, comme le fait le code de cet article |
Idées de projets avec le HC-SR505
- Éclairage de placard et de tiroir : Une petite bande de LED s'allume quand la porte s'ouvre et qu'une main entre, puis s'éteint seule 8 secondes plus tard.
- Alarme de mouvement sur batterie : Un ESP32 attend en deep sleep et prévient sur Telegram dès qu'il détecte un mouvement.
- Carillon d'entrée : Un buzzer joue une courte mélodie quand quelqu'un s'approche de la porte.
- Déclencheur pour piège photo : Un mouvement dans le jardin déclenche une photo avec un ESP32-CAM.
- Système d'alarme intelligent : Combine plusieurs mini PIR avec des capteurs de porte et de fenêtre pour construire un système d'alarme Arduino.
- Détection à travers un boîtier : Si le capteur doit voir à travers une boîte en plastique, essaie le capteur radar RCWL-0516 à la place d'un PIR.
Le HC-SR505 et l'AM312 sont la façon la plus pratique de détecter un mouvement partout où un gros module PIR ne rentre pas : trois fils, aucun réglage et une consommation de quelques microampères. Le choix entre les deux dépend de la tension de ton système et de la durée de sortie voulue. Dans l'application BlueGrays, tu peux suivre pas à pas, avec schémas et code prêt à l'emploi, les projets de sonnette et lumière à détecteur de mouvement, d'éclairage automatique avec ESP32 et PIR et d'alarme de mouvement ESP32 avec notifications Telegram.
Questions fréquentes
Quelle différence entre le HC-SR505 et le HC-SR501 ?
Le HC-SR505 est un PIR minuscule, d'environ 1 cm de diamètre et sans réglage : sa durée de sortie est fixée à environ 8 secondes et sa portée à environ 3 mètres. Le HC-SR501 est plus grand et possède deux potentiomètres pour régler une portée de 3 à 7 mètres et une durée de 3 secondes à 5 minutes. Les deux s'alimentent en 4,5–20 V et fournissent une sortie de 3,3 V.
Le capteur PIR HC-SR505 fonctionne-t-il en 3,3 V ?
Le minimum officiel est de 4,5 V, car la carte embarque un régulateur 3,3 V. Beaucoup d'exemplaires fonctionnent en 3,3 V, mais la sensibilité peut baisser et les faux déclenchements augmenter. Pour les systèmes en 3,3 V et les batteries lithium à une cellule, l'AM312, qui fonctionne dès 2,7 V, est plus sûr.
Peut-on régler la temporisation du HC-SR505 ?
Non, il n'a ni potentiomètre ni cavalier ; la sortie reste à HIGH environ 8 secondes après chaque mouvement, et plus longtemps tant que le mouvement continue. Dans le code, tu peux allonger la durée à volonté, mais pas descendre sous 8 secondes. Si tu as besoin d'une réaction plus rapide, prends l'AM312, dont la durée est d'environ 2 secondes.
Quelle est la portée du capteur PIR HC-SR505 ?
Il détecte les mouvements jusqu'à environ 3 mètres dans un cône de moins de 100°. La détection est meilleure quand le mouvement traverse son champ de vision de côté. Pour une plus grande portée, utilise le HC-SR501, réglable jusqu'à environ 7 mètres.
Faut-il choisir un AM312 ou un HC-SR505 ?
Si ton système fonctionne en 5 V et qu'une durée de 8 secondes te convient, le HC-SR505 suffit. Sur les cartes en 3,3 V comme l'ESP32 ou le Pico, dans les projets sur batterie et quand il faut une réaction rapide, l'AM312, alimenté de 2,7 à 12 V avec 2 secondes de sortie, est un meilleur choix.
Un mini PIR peut-il réveiller un ESP32 du deep sleep ?
Oui. Relie la broche OUT à une GPIO RTC comme la GPIO 33 et configure le réveil ext0 sur le niveau HIGH : l'ESP32 se réveillera au moindre mouvement. Avant de rendormir la carte, attends que la sortie repasse à LOW, sinon elle se réveillera aussitôt. Le code de cet article passe cette attente endormi grâce à une minuterie.
Projets à réaliser après cet article
Voir tous les projets
Détecteur de mouvement avec capteur de mouvement
Un gardien tout simple qui te prévient quand quelqu'un entre dans la pièce. Le détecteur de mouvement repère la chaleur dégagée par le corps humain ; l'Arduino garde la LED allumée tant qu'il y a du…

Sonnette et lumière avec détecteur de mouvement
Quand quelqu'un approche de ta porte, tu le sais avant même qu'il sonne. Dès que le détecteur de mouvement repère quelqu'un, la LED s'allume et le buzzer joue un carillon de trois notes, de l'aigu au…

Éclairage automatique avec le capteur de mouvement PIR ESP32
Un capteur de mouvement PIR HC-SR501 détecte la personne qui entre dans la pièce et allume une LED automatiquement. millis() suit la durée d'allumage : chaque lecture HIGH remet à jour l'heure du dernier mouvement, et la LED s'éteint au moins 10 secondes après le dernier HIGH. Le code attend aussi 50 ms avec delay(50) à chaque boucle, qui n'est donc pas totalement non bloquante. Idéal pour un escalier, un couloir ou un placard.

Éclairage Intelligent ESP32 (PIR + LDR + Relais + OLED)
Avec un ESP32, un capteur de mouvement PIR, un capteur de lumière LDR et un module relais, on transforme ton couloir, tes toilettes ou ton cellier en éclairage intelligent. Si la pièce est déjà claire, la lumière reste éteinte malgré le mouvement : pas de gaspillage d'énergie en journée. La lumière reste allumée 30 secondes et la durée se prolonge automatiquement tant que le mouvement continue.

Système d'Alarme de Mouvement ESP32 (PIR + Buzzer + LED + Telegram)
Une alarme de sécurité intelligente : quand le capteur PIR détecte un mouvement, le buzzer sonne, la LED s'allume et le propriétaire reçoit aussitôt une notification Telegram. Un délai de 30 secondes (cooldown) limite la répétition des alarmes ; il n'élimine pas les fausses détections du capteur PIR. À utiliser à la maison, au garage, dans une réserve ou un bureau.

Mode veille profonde de l'ESP32 — Économie de batterie (OLED + compteur RAM RTC)
Le mode Deep Sleep de l'ESP32 coupe le CPU et la plupart des périphériques et réduit la consommation à environ 10µA, un point clé pour les objets IoT sur batterie. Ce projet utilise trois sources de réveil : un minuteur (15 s), une broche externe (EXT0, le bouton sur GPIO 33) et une broche tactile (T0/GPIO 4). Les compteurs marqués RTC_DATA_ATTR sont conservés pendant le deep sleep.

Éclairage intelligent des escaliers et des couloirs
Pose le pied dans l'escalier ou le couloir et les lumières s'allument marche après marche dans ton sens de passage.
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

