Projets · 01
Alarme anti-intrusion
Surveille une porte avec une ligne invisible. Quand la porte s’ouvre, le faisceau infrarouge est coupé et un buzzer sonne. Elle fonctionne sur piles, donc tu peux la poser n’importe où. Ensuite, si tu veux, ajoute une alerte sur ton téléphone ou soude-la dans un boîtier permanent.
Fais ces leçons d’abord
- Tension, courant, résistancedisponiblepourquoi la résistance, comment on mesure une tension (U).
- Ton premier circuitdisponiblequels trous de la plaque d’essai sont reliés, comment repérer un court-circuit.
- Les DEL et la bonne résistancedisponibledans quel sens brancher la DEL, pourquoi 220 Ω devant elle.
- Ton premier programme : connecter ton ESP32 et y envoyer du codedisponibleinstaller l’IDE Arduino, connecter la carte, téléverser un programme.
- Entrées, sorties et sidisponiblelire un bouton, commander un buzzer, laisser le code décider.
Tu peux commencer sans elles : les encadrés « Rappel » donnent l’idée en deux lignes.
- Niveau
- Niveau 1la mission la plus facile
- Durée
- Un après-midi2–3 h (montage de base). Version permanente : ajoute 2–3 h · estimation
- Coût
- Environ 50–85 $ CAestimation
- Outils
- Facilesmontage de base : ni soudure, ni outil électrique. La version permanente demande un fer à souder.
- Demande de l’aide
- 3 étapesétapes 5, 6 et 7
- Leçon d’abord
- Tension, courant, résistancedisponible
Logique 3,3 V seulement. Le fil de sortie du récepteur va sur GPIO32 et est tiré vers le haut jusqu’à 3V3 seulement (le code active la résistance de rappel intégrée de la carte). L’ESP32 fonctionne en logique 3,3 V (maximum absolu 3,6 V) : ne relie jamais une broche de signal de l’ESP32 à 5 V. Seule exception : la broche d’alimentation 5V de la carte, qui reçoit le bloc de piles et rien d’autre.
La sécurité d’abord
Lis cet encadré avant de brancher quoi que ce soit.
- Piles
- Petites pièces
- Logique 3,3 V seulement. Le fil de sortie du récepteur va sur
GPIO32et est tiré vers le haut jusqu’à 3V3 seulement (le code active la résistance de rappel intégrée de la carte). L’ESP32 fonctionne en logique 3,3 V (maximum absolu 3,6 V) : ne relie jamais une broche de signal de l’ESP32 à 5 V. Seule exception : la broche d’alimentation5Vde la carte, qui reçoit le bloc de piles et rien d’autre. - Le rail rouge, c’est 3V3 seulement. Le bloc 4×AA va sur la rangée de la broche
5Vet sur le rail bleu (−). Ne mets jamais son fil + sur un rail rouge. - Les deux blocs de piles ne sont pas interchangeables. Le bloc 4×AA (jusqu’à 6,4 V) est réservé à l’ESP32. L’émetteur supporte 5,5 V au maximum : il prend le bloc 3×AA, jamais 4 piles. Mets une étiquette sur chacun : « ESP32 4×AA » et « ÉMETTEUR 3×AA ».
- Bloc OFF avant l’USB. La carte n’accepte qu’une seule source d’alimentation à la fois. Si le bloc est sur ON et que l’USB est branché, du courant peut remonter dans les piles. Mets le bloc sur OFF avant de brancher le câble USB, et avant de déplacer un fil.
- Piles : ne mélange jamais piles alcalines et rechargeables, vieilles et neuves, ni marques différentes dans un même support ; change toutes les piles en même temps. Respecte les marques + / − à l’intérieur du support. Ne laisse jamais les extrémités à nu d’un bloc se toucher ni toucher du métal. Ne recharge jamais des piles alcalines ; recharge les piles NiMH seulement dans un chargeur NiMH, hors du boîtier. Pas de pile 9 V, pas de support à 5 ou 6 piles, pas de LiPo pour cette mission. Sors les piles si l’alarme reste inutilisée un mois ; une croûte blanche sur une pile signale une fuite : mets des gants, nettoie et jette-la correctement. Dépose les piles usagées dans un point de collecte.
- Garde le faisceau à l’abri du soleil direct : la lumière du soleil contient de l’infrarouge et peut déclencher de fausses alarmes.
- Petites pièces et piles : garde les petites pièces, les fils et les piles loin des animaux et de toute personne qui pourrait les mettre en bouche.
Pièces
Montage de base, sur plaque d’essai sans soudure. Les pièces de la version permanente sont dans une liste séparée plus bas.
Voir les 13 pièces · Environ 50–85 $ CA
- 1
Carte ESP32×1
Le cerveau
Spécification exacte : ESP32-DevKitC V4 ou un clone : ESP32-WROOM-32, 38 broches, logique 3,3 V. Vérifie le régulateur avant d’acheter ou d’utiliser la carte (étape 2) : la puce à 3 pattes avec une grande languette près de la broche
5Vdoit porter la mention AMS1117. - 2
Barrière infrarouge 5 mm (émetteur + récepteur)1 paire
L’émetteur envoie un faisceau invisible, le récepteur le voit
Spécification exacte : Version à DEL 5 mm (type Adafruit 2168) : émetteur (2 fils, rouge et noir) + récepteur (3 fils : rouge +, noir −, blanc ou jaune OUT), sortie à collecteur ouvert, alimentation 3,3–5,5 V. Portée annoncée d’environ 50 cm à 5 V ; on en utilise 15–20, donc de la marge. Teste-la.
- 3
Support 4×AA avec interrupteur ON/OFF, couvercle et extrémités à broches×1
Alimente la carte ESP32
Spécification exacte : Support 4×AA à interrupteur, avec couvercle à clips et extrémités à broches de 0,1 po (2,54 mm) qui s’enfoncent directement dans la plaque d’essai (type Adafruit 830). Des piles alcalines neuves donnent environ 6,4 V, des piles à plat environ 4 V. La carte a besoin d’environ 4,4–6,5 V : en dessous, elle se comporte mal, alors change les piles avant d’en arriver là.
- 4
Support 3×AA avec interrupteur ON/OFF et couvercle×1
Alimente l’émetteur sur la porte
Spécification exacte : Support 3×AA à interrupteur, environ 4,5 V. Trois piles, jamais quatre : l’émetteur supporte 5,5 V au maximum.
- 5
Piles AA×7
4 pour le bloc de l’ESP32, 3 pour le bloc de l’émetteur
Spécification exacte : Piles AA alcalines (LR6), ou piles AA NiMH à faible autodécharge (celles vendues « prêtes à l’emploi »). Même type et même marque dans chaque support, jamais mélangés. 4 piles NiMH seulement si ton régulateur n’est pas un AMS1117 (étape 2).
- 6
Bornes à levier WAGO 221-412×2
Relient les fils de l’émetteur à son bloc, sans soudure
Spécification exacte : Bornes à levier 2 conducteurs, une pour le rouge et une pour le noir. Si un fil est très fin, dénude 11 mm et replie-le sur lui-même pour qu’il remplisse la borne. (Variante : si le bloc et l’émetteur ont tous deux des extrémités à broches, 2 cordons Dupont femelle-femelle.)
- 7
Résistance 220 Ω×1
Protège la DEL
Spécification exacte : 220 Ω, 1/4 W, traversante
- 8
DEL×1
Montre ce que fait l’alarme
Spécification exacte : DEL 5 mm, toute couleur, traversante
- 9
Module buzzer actif×1
Fait sonner l’alarme
Spécification exacte : Module buzzer actif (son intégré), 3 broches S / + / −, 3,3–5 V, sonne quand S est HIGH. Teste-le à l’étape 11 : certains modules fonctionnent à l’envers.
- 10
Bouton poussoir×1
Arme et désarme
Spécification exacte : Bouton tactile 6 mm, 4 pattes
- 11
Plaque d’essai×1
Relie les pièces sans soudure
Spécification exacte : Format complet 830 points (accueille un ESP32 38 broches)
- 12
Fils de connexion1 lot
Relient les pièces
Spécification exacte : Mâle-mâle, 10–20 cm environ, 20 fils ou plus. Seulement si ton support 4×AA a des fils nus au lieu de broches : 10 cm de fil rigide 22 AWG, un rouge et un noir.
- 13
Câble USB données×1
Envoyer le code
Spécification exacte : Câble données (pas charge seule), adapté au port de la carte. Pour la programmation seulement : l’alarme elle-même fonctionne sur piles.
Outils
Voir les 5 outils (2 en option)
Ordinateur avec Arduino IDE
Envoyer le code
Spécification exacte : Arduino IDE 2.x + « esp32 by Espressif » 3.3.x (téléchargement gratuit sur arduino.cc)
Ruban adhésif
Coller l’émetteur et son bloc sur le battant, et le récepteur sur le cadre
Spécification exacte : Ruban double face, ruban de masquage ou pâte adhésive (repositionnable)
Règle ou mètre rubanfacultatif
Vérifier l’écart de 15–20 cm
Spécification exacte : N’importe lequel
Étiquettes autocollantes et un stylo
Étiqueter les deux blocs de piles
Spécification exacte : N’importe lesquelles
Multimètrefacultatif
Vérifier fils, piles et tensions (nécessaire pour la version permanente)
Spécification exacte : Multimètre numérique de base
Comment ça marche
L’émetteur envoie une lumière infrarouge invisible vers le récepteur. Tant que le récepteur la voit, son fil de sortie est à un niveau ; quand la lumière disparaît, il passe à l’autre niveau. L’ESP32 n’a qu’à lire ce fil : libre ou coupé.
Pour une porte, l’émetteur est collé sur le battant et le récepteur sur le cadre ou le mur, face à face, à 15–20 cm l’un de l’autre quand la porte est fermée. Tu ouvres la porte : l’émetteur s’éloigne, le récepteur perd le faisceau, l’alarme se déclenche. L’émetteur a son propre bloc de piles sur la porte ; Adafruit précise que les deux moitiés n’ont pas besoin de partager l’alimentation ni la masse, car le signal voyage sous forme de lumière.
La sortie du récepteur est à collecteur ouvert : elle peut tirer le fil vers GND mais pas le pousser vers le haut, donc le fil a besoin d’une résistance de rappel (vers 3,3 V). L’ESP32 en a une intégrée, et le code l’active.
Toute l’alarme fonctionne sur piles AA. Pour qu’elles durent, la carte dort presque tout le temps et ne se réveille que si tu appuies sur le bouton ou si le faisceau est coupé. Armée et faisceau coupé : le buzzer sonne 30 secondes. Ensuite l’alarme attend que la porte se referme et se réarme toute seule. Ajouter une alerte sur téléphone et souder le circuit dans un boîtier sont des étapes en option.
Leçons liées : Tension, courant, résistance · Ton premier circuit · Les DEL et la bonne résistance · Ton premier programme : connecter ton ESP32 et y envoyer du code · Entrées, sorties et si
Câblage
Deux vues du même circuit : la plaque d’essai telle que tu vas la monter, et le schéma. Touche un schéma pour l’ouvrir en plein écran.
Voir les 16 fils et le tableau des broches
Liste des fils
| # | Couleur | De | Vers |
|---|---|---|---|
| 1 | rouge | ESP32 3V3 (trou j19) | rail 3V3 (rouge + à droite) |
| 2 | noir | ESP32 GND (trou j6) | rail GND (bleu − à droite) |
| 3 | rouge | bloc 4×AA rouge (+) | le trou à côté de la broche 5V de l’ESP32 (j1). Jamais un rail rouge. |
| 4 | noir | bloc 4×AA noir (−) | rail GND (bleu − à droite) |
| 5 | rouge | récepteur IR rouge (+) | rail 3V3 |
| 6 | noir | récepteur IR noir (−) | rail GND |
| 7 | jaune | récepteur IR OUT (blanc ou jaune) | GPIO32 (j13 ; rappel vers 3V3 par le code, jamais vers 5 V) |
| 8 | orange | ESP32 GPIO25 (j11) | buzzer S (j39) |
| 9 | rouge | rail 3V3 | buzzer + (j40) |
| 10 | noir | buzzer − (j41) | rail GND |
| 11 | vert | ESP32 GPIO26 (j10) | résistance 220 Ω, patte 1 (b26) |
| 12 | noir | patte courte de la DEL (−) | rail GND |
| 13 | bleu | ESP32 GPIO27 (j9) | bouton patte A (j44) |
| 14 | noir | bouton patte B (en diagonale) | rail GND |
| 15 | noir | rail bleu de gauche | rail bleu de droite (liaison de GND) |
| E | rouge / noir | fils de l’émetteur | fils du bloc 3×AA, par les deux bornes WAGO, sur la porte. Aucun fil vers l’ESP32. |
Les noms de trous (j19, j6…) supposent que les broches de la carte sont dans les colonnes a et i de la plaque, port USB à la rangée 1 (étape 3). La patte 2 de la résistance et la patte longue (+) de la DEL sont dans la même rangée de la plaque. Le rail rouge de droite, c’est 3V3 seulement ; le rail rouge de gauche reste inutilisé.
Broches de l’ESP32
| Broche | Reliée à | Rôle |
|---|---|---|
5V | + du bloc 4×AA (la seule chose qui va ici) | Entrée d’alimentation (environ 4,4–6,5 V ; en dessous, elle se comporte mal) |
3V3 | rail 3V3 : récepteur IR +, buzzer + | Sortie d’alimentation (3 |
GND | rail GND : − du bloc, récepteur IR −, buzzer −, DEL, bouton | Masse |
GPIO32 | OUT du récepteur IR | Entrée avec résistance de rappel interne (LOW = faisceau coupé). Réveille la carte du sommeil profond. |
GPIO25 | Buzzer S | Sortie |
GPIO26 | 220 Ω → DEL | Sortie |
GPIO27 | Bouton (autre patte à GND) | Entrée avec résistance de rappel interne. Réveille la carte du sommeil profond. |
L’ordre des broches peut différer sur les clones : suis toujours les inscriptions imprimées sur ta carte. Le tableau ci-dessus vaut pour la DevKitC V4 d’origine.
Étapes de montage
Fais une étape, vérifie, puis passe à la suivante.
Étape 1 · Sors tes pièces.
Vérifie : Toutes les pièces de la liste sont sur la table.
Étape 2 · Vérifie ta carte.
Regarde la petite puce à 3 pattes avec une grande languette plate, à côté de la broche
5V. Lis ce qui est écrit dessus. Si c’est AMS1117 (la carte d’origine en a une), 4 piles alcalines conviennent. Si elle est minuscule, a 5 pattes ou ne porte aucune marque, utilise 4 piles NiMH seulement (elles donnent une tension plus basse). Lis aussi les inscriptions imprimées sur la carte à côté des broches : sur les clones, l’ordre peut différer de cette fiche, et c’est ta carte qui a raison.Vérifie : Tu sais quelle puce régule ta carte, et tu as trouvé les broches
5V,GND,3V3,25,26,27et32grâce à leurs inscriptions.Étape 3 · Place l’ESP32.
Enfonce la carte à cheval sur la rainure centrale, pour que ses deux rangées de broches tombent dans les colonnes a et i, rangées 1 à 19. Port USB à la rangée 1, antenne vers la rangée 20. Laisse les rangées 20–23 vides : c’est là que se trouve l’antenne. Chaque broche côté j a maintenant un trou libre à côté d’elle (colonne j). Pas de câble pour l’instant.
Vérifie : La carte est à plat, aucune broche n’est tordue, et la broche
5Vest à la rangée 1, colonne i.Étape 4 · Les rails.
Relie la broche
3V3(trou j19) au rail rouge (+) de droite et la brocheGND(trou j6) au rail bleu (−) de droite. Puis relie le rail bleu de gauche au rail bleu de droite avec un fil. Le rail rouge de droite est maintenant 3V3 seulement.Vérifie : Fil rouge sur le rail rouge, fil noir sur le rail bleu, et rien d’autre ne touche encore le rail rouge.
Étape 5 · Câble le récepteur. Demande de l’aide
Étape 6 · Alimente l’ESP32 avec son bloc. Demande de l’aide
Mets 4 piles dans le support 4×AA, en suivant les marques + / −. Mets-le sur OFF. Étiquette-le « ESP32 4×AA ». Enfonce sa broche noire dans le rail bleu (−) de droite et sa broche rouge dans le trou à côté de la broche
5V(j1). Jamais dans un rail rouge. Laisse l’interrupteur sur OFF.Vérifie : Le rouge va dans la rangée de la broche
5V, le noir dans le rail bleu, l’interrupteur est sur OFF, et une personne expérimentée (ou toi, deux fois) a contrôlé.Étape 7 · Prépare le bloc de l’émetteur. Demande de l’aide
Mets 3 piles dans le support 3×AA, en suivant les marques. Mets-le sur OFF et étiquette-le « ÉMETTEUR 3×AA ». Ouvre le levier d’une borne WAGO, enfonce le fil rouge du bloc et le fil rouge de l’émetteur (dénudés sur environ 11 mm), referme le levier. Fais pareil avec une seconde WAGO pour les deux fils noirs. Tire doucement sur chaque fil : il doit tenir. Rouge avec rouge, noir avec noir. Aucun fil ne va vers l’ESP32.
Vérifie : Le rouge est relié au rouge, le noir au noir, l’interrupteur est sur OFF, et rien venant de l’émetteur ne touche la plaque ni l’ESP32.
Étape 8 · Envoie le code.
Les deux blocs sur OFF. Installe le paquet de carte, ouvre le croquis, branche le câble USB, choisis « ESP32 Dev Module », téléverse. Débranche le câble USB quand c’est fini.
Vérifie : « Done uploading » s’affiche.
Étape 9 · Teste le faisceau sur la table.
Émetteur et récepteur sur la table, à environ 15 cm l’un de l’autre, face à face. Mets le bloc de l’émetteur sur ON. Branche le câble USB et ouvre le moniteur série à 115200 bauds (le bloc de l’ESP32 reste sur OFF). La carte démarre en mode test, qui dure 90 secondes après la mise sous tension ou un redémarrage : le moniteur affiche « clear » ou « broken » à chaque changement du faisceau. Appuie sur EN (reset) pour relancer les 90 secondes quand tu veux. Tu dois voir « clear ». Passe la main entre les deux modules.
Vérifie : Le moniteur affiche « broken » quand ta main coupe le faisceau et « clear » sinon.
Étape 10 · Corrige l’inversion (seulement si besoin).
Si le moniteur affiche « broken » alors que rien ne coupe le faisceau, trouve
const int BROKEN = LOW;dans le code, remplaceLOWparHIGH, téléverse à nouveau.Vérifie : « clear » sans rien dans le passage, « broken » avec ta main.
Étape 11 · Ajoute le buzzer.
Tout sur OFF et débranché. Buzzer
SsurGPIO25,+au rail 3V3,−au rail GND (suis les inscriptions de ton module). Teste-le : à la fin du mode test de 90 s (appuie sur EN pour le relancer), le buzzer fait un court bip (0,2 s). Ce bip est le test du buzzer ; la vraie alarme, tu l’entends à l’étape 17. Si le buzzer reste muet au bip et sonne le reste du temps, ton module fonctionne à l’envers : changeBUZZER_ONdans le code.Vérifie : Le buzzer fait un seul court bip à la fin du mode test et se tait le reste du temps. Un buzzer qui sonne en permanence viderait les piles en une nuit.
Étape 14 · Colle l’émetteur, son bloc et le récepteur sur la porte.
Ferme la porte. Colle l’émetteur et son bloc 3×AA sur le battant, et le récepteur sur le cadre ou le mur à côté, à la même hauteur, face à face, à 15–20 cm l’un de l’autre (aide-toi de la règle), les deux lentilles bien dégagées de la moulure ou de l’encadrement de la porte. Garde l’interrupteur du bloc à portée de main. Aucun fil ne doit traverser l’espace de la porte. Garde le faisceau à l’abri du soleil direct. N’appuie pas encore définitivement sur le ruban.
Vérifie : Les deux modules se font face à la même hauteur, et les seuls fils sur le battant sont ceux de l’émetteur, reliés à son propre bloc.
Étape 15 · Aligne-le porte fermée.
Mets le bloc de l’émetteur sur ON. Branche l’ESP32 en USB (son bloc reste sur OFF) et ouvre le moniteur série. Le mode test dure 90 secondes, et la DEL est allumée tant que le faisceau est coupé (appuie sur EN pour relancer le test). Porte fermée, tu dois voir « clear ». Décale un peu l’émetteur ou le récepteur dans toutes les directions : ça doit rester « clear » avec un peu de marge. Ensuite appuie sur le ruban.
Vérifie : « clear » reste stable porte fermée, même si tu tapotes doucement la porte.
Étape 16 · Teste en ouvrant la porte.
Appuie sur EN pour relancer le mode test de 90 s. Ouvre la porte lentement, puis referme-la. Fais-le trois fois.
Vérifie : « broken » apparaît quand la porte s’ouvre, « clear » revient quand elle est fermée, à chaque fois.
Étape 17 · Teste comme un espion.
Débranche l’USB. Mets le bloc de l’ESP32 sur ON : le mode test de 90 s tourne, finit par un court bip, puis la DEL clignote deux fois (désarmée). Appuie sur le bouton : la DEL clignote une fois par seconde pendant 10 secondes, le temps de sortir et de fermer la porte derrière toi. Puis un long éclair : l’alarme est armée. Ouvre la porte : le buzzer sonne. Appuie sur le bouton pour le couper.
Vérifie : Le buzzer sonne quand la porte s’ouvre. Appuie sur le bouton : il s’arrête et l’alarme est désarmée (deux petits clignotements).
Ce que te dit la DEL (le sommeil profond, en mots simples)
Pour que les piles durent, la carte passe presque tout son temps en sommeil profond : presque éteinte, elle consomme très peu. Deux choses la réveillent aussitôt : le bouton, et le faisceau coupé. Quand elle est armée, elle se réveille aussi un instant toutes les 30 secondes pour dire qu’elle est toujours là : c’est pourquoi tu ne vois pas de lumière fixe.
Voir les 9 signaux de la DEL et l’autonomie
| Ce que tu vois | Ce que ça veut dire |
|---|---|
| Allumée tant que le faisceau est coupé (les 90 premières secondes) | Mode test, après la mise sous tension ou un appui sur EN. La DEL montre ce que voit le récepteur. Un court bip du buzzer le termine. |
| Deux petits clignotements | Carte qui vient d’être allumée, ou alarme désarmée. Rien ne surveille. |
| Un clignotement par seconde pendant 10 s | Armement en cours. Tu as 10 secondes pour sortir et fermer la porte. Rappuie sur le bouton pour annuler. |
| Un long éclair | Armée. Le faisceau était libre et l’alarme surveille. |
| Un minuscule éclair toutes les 30 s | Armée et endormie. Elle s’est réveillée un instant et s’est rendormie. |
| Clignotement rapide pendant 2 s, et elle reste désarmée | Le faisceau est déjà coupé quand tu appuies sur le bouton : vérifie l’émetteur (allumé ? visé ? porte fermée ?). |
| Un clignotement par seconde jusqu’à 60 s, puis clignotement rapide, et elle reste désarmée | La porte était encore ouverte à la fin du compte à rebours de 10 s. Elle attend jusqu’à 60 s que tu la fermes, puis elle abandonne. |
| Clignotement rapide et buzzer | Alarme ! Elle sonne 30 secondes. Appuie sur le bouton pour l’arrêter tout de suite. |
| Un minuscule éclair toutes les 5 s | Après une alarme, en attente de la fermeture de la porte : la carte vérifie toutes les 5 s si le faisceau est revenu. |
Au bout de 30 secondes, le buzzer s’arrête tout seul. L’alarme attend alors que le faisceau revienne (porte fermée) et se réarme toute seule. Si tu laisses la porte ouverte, elle continue d’attendre (elle vérifie toutes les 5 s) et ne sonne pas à nouveau.
Combien de temps les piles durent-elles ?
| Bloc | Autonomie | Remarques |
|---|---|---|
| Boîtier ESP32, 4×AA alcalines | environ 10–14 jours | Presque toute la consommation vient du régulateur et de la DEL d’alimentation de la carte, pas de ton code. 4 piles NiMH à faible autodécharge : environ 10 jours. Une porte laissée ouverte après une alarme coûte un peu plus (la carte vérifie toutes les 5 s). |
| Émetteur, 3×AA | environ 6 jours s’il reste allumé en permanence | 2–3 semaines si tu ne l’allumes que quand l’alarme est armée (8–10 heures par jour). L’émetteur est le premier bloc à s’épuiser : éteins-le quand tu n’utilises pas l’alarme. |
Ce sont des estimations tirées des fiches techniques, pas des mesures. À mesurer sur ton montage : mets un multimètre en série sur le fil rouge du bloc et lis le courant de veille (notre estimation : 7,5–9 mA). Le bonus d’alerte sur téléphone consomme un peu plus. Quand les piles faiblissent, l’alarme devient moins fiable avant de s’arrêter : change toutes les piles ensemble dès qu’elle se comporte bizarrement.
Le code pas à pas
Carte : ESP32 Dev Module (ESP32-DevKitC V4 ou clone, ESP32-WROOM-32, 38 broches). Le code ci-dessous compile dans notre intégration continue avec le paquet de cartes ESP32 3.3.12.
Rien à installer pour le croquis de base. Deux croquis : celui de base (01-intrusion-alarm, sans Wi-Fi) et celui du téléphone (01b-intrusion-alarm-phone, bonus).
Télécharger le fichier .ino Télécharger le dossier du croquis (.zip)
Bloc 1 En-tête et câblage
Des notes, le résumé du câblage et les bibliothèques utilisées. Lis l’en-tête : l’émetteur est une DEL infrarouge, pas un laser. À changer : rien
Voir le code (33 lignes)
// Tinker Mission — Mission 01: Intrusion alarm (battery version, no Wi-Fi) // Board: ESP32 Dev Module ("esp32 by Espressif" 3.3.x). No extra library needed. // // How it works: the emitter is stuck on the door leaf and the receiver on the frame, facing each // other about 15-20 cm apart when the door is closed. When the door opens, the beam is broken: // the buzzer sounds and the LED blinks fast. The emitter is an infrared LED, not a laser. // // Battery trick: "deep sleep". Most of the time the ESP32 is asleep and uses almost nothing. // It wakes up only when something happens: // - you press the button (to arm or disarm), // - the beam is broken while the alarm is armed, // - a small timer rings (a short "I'm alive" flash every 30 s while armed). // Each wake-up starts the sketch again from the top of setup(). loop() is never used. // // Test mode: for 90 s after you switch on (or press the EN button), the LED shows the beam, // so you can line up the emitter and the receiver. Then a short beep, and it is ready. // // Wiring (ESP32 DevKitC, 38 pins): // 4xAA pack red (+) -> 5V pin black (-) -> GND (5V pin ONLY, never a red rail: the rail is 3V3) // IR emitter red / black -> its own 3xAA pack (on the door, no wire to the ESP32) // IR receiver red -> 3V3 pin black -> GND white/yellow (OUT) -> GPIO32 // Buzzer module S -> GPIO25 + -> 3V3 - -> GND (active buzzer) // LED GPIO26 -> 220 ohm resistor -> LED long leg; LED short leg -> GND // Push button GPIO27 -> button -> GND // Switch the pack OFF before you plug in the USB cable: one power source at a time. // // IMPORTANT: the receiver output is "open collector": it can pull the wire down to GND, but it // cannot push it up. So the wire needs a pull-up resistor. We use the ESP32's built-in one, // which pulls up to 3.3 V. Never add a pull-up to 5 V: ESP32 pins use 3.3 V logic. #include "driver/rtc_io.h" // "RTC" pins: their pull-ups keep working while the ESP32 sleeps #include "driver/gpio.h" // gpio_hold_en(): freezes an output pin at its level during sleep #include "esp_sleep.h" // deep sleep and wake-up sourcesBloc 2 Broches, réglages et mémoire
Un nom pour chaque broche, le niveau qui veut dire « coupé » (
BROKEN), le niveau qui fait sonner le buzzer (BUZZER_ON), puis les nombres que tu peux changer : délai d’armement (10 s), durée de l’alarme (30 s), signal de vie (30 s), revérification de la porte (5 s), attente de la porte (60 s), mode test (90 s). Enfin, le seul mot dont la carte se souvient pendant le sommeil profond : désarmée, armée, ou en attente de la fermeture de la porte. À changer :BROKENseulement si l’étape 10 te l’a demandé ;BUZZER_ONseulement si l’étape 11 te l’a demandé ; les nombres si tu veuxVoir le code (27 lignes)
// ---------- Pins (these four can all wake the ESP32 or stay frozen during sleep) ---------- const gpio_num_t BEAM_PIN = GPIO_NUM_32; // IR receiver output const gpio_num_t BUZZER_PIN = GPIO_NUM_25; const gpio_num_t LED_PIN = GPIO_NUM_26; const gpio_num_t BUTTON_PIN = GPIO_NUM_27; // pressed = LOW (wired to GND) // ---------- Settings you may change ---------- // Most receivers pull OUT down to LOW when the beam is broken. Right after you switch on, the // LED lights while the beam is broken (90 s test mode). If it is the other way round, change LOW to HIGH. const int BROKEN = LOW; // Most buzzer modules beep when S is HIGH. A "low-level trigger" module beeps when S is LOW: // if yours beeps all the time while asleep, change HIGH to LOW. const int BUZZER_ON = HIGH; const int ARMING_S = 10; // seconds to leave and close the door after pressing the button const int ALARM_S = 30; // how long the buzzer sounds const int HEARTBEAT_S = 30; // short LED flash every 30 s while armed (0 = no flash, longer battery) const int RECHECK_S = 5; // door left open after an alarm: check again every 5 s const int DOOR_WAIT_S = 60; // after the arming delay, wait up to 60 s for the door to be closed const int TEST_S = 90; // test mode after switching on or EN: 90 s where the LED shows the beam // ---------- Memory that survives deep sleep ---------- // Normal variables are wiped at each wake-up. "RTC_DATA_ATTR" keeps this one in a tiny memory // that stays powered while the ESP32 sleeps. Switching off (or the EN button) resets it. const int DISARMED = 0; // sleeping, only the button can wake it const int ARMED = 1; // watching the beam const int WAIT_CLEAR = 2; // the alarm has rung: waiting for the door to be closed again RTC_DATA_ATTR int state = DISARMED;Bloc 3 Petits outils
Lire le faisceau, attendre le bouton, faire clignoter la DEL, désarmer. Tout ce qui suit s’en sert. À changer : rien
Voir le code (33 lignes)
// ---------- Small helpers ---------- bool beamBroken() { return digitalRead(BEAM_PIN) == BROKEN; } bool buttonPressed() { return digitalRead(BUTTON_PIN) == LOW; } void blink(int times, int onMs, int offMs) { for (int i = 0; i < times; i++) { digitalWrite(LED_PIN, HIGH); delay(onMs); digitalWrite(LED_PIN, LOW); delay(offMs); } } void waitButtonRelease() { while (buttonPressed()) delay(10); delay(50); // ignore button bounce } // Waits `ms` milliseconds, but stops early and returns true if the button is pressed. bool waitOrPress(int ms) { for (int t = 0; t < ms; t += 10) { if (buttonPressed()) return true; delay(10); } return false; } void disarm() { digitalWrite(BUZZER_PIN, !BUZZER_ON); // buzzer off blink(2, 150, 150); // 2 short blinks = disarmed state = DISARMED; Serial.println("Disarmed"); }Bloc 4 L’armement
Le bouton lance un compte à rebours de 10 s avec un clignotement à 1 Hz. À la fin, le faisceau doit être libre. Si la porte est encore ouverte, la DEL continue de clignoter une fois par seconde jusqu’à 60 s, le temps que tu la fermes, puis clignotement rapide et elle reste désarmée. Si le faisceau est déjà coupé quand tu appuies sur le bouton, tu as tout de suite le clignotement d’erreur. À changer : le délai d’armement (
ARMING_S) et l’attente de la porte (DOOR_WAIT_S)Voir le code (39 lignes)
// ---------- Arming: 10 s to leave, then the door must be closed ---------- void armAlarm() { waitButtonRelease(); if (beamBroken()) { // beam already broken: emitter off, or not facing the receiver Serial.println("Beam broken: check the emitter. Not armed."); blink(20, 50, 50); // fast blinking for 2 s = error state = DISARMED; return; } Serial.println("Arming..."); for (int i = 0; i < ARMING_S; i++) { // LED blinks once per second digitalWrite(LED_PIN, HIGH); bool pressed = waitOrPress(500); digitalWrite(LED_PIN, LOW); if (pressed || waitOrPress(500)) { // a press during the delay cancels waitButtonRelease(); disarm(); return; } } unsigned long start = millis(); while (beamBroken()) { // door still open: keep blinking and wait if (millis() - start > DOOR_WAIT_S * 1000UL) { Serial.println("Door never closed. Not armed."); blink(20, 50, 50); state = DISARMED; return; } digitalWrite(LED_PIN, (millis() / 500) % 2); if (waitOrPress(10)) { waitButtonRelease(); disarm(); return; } } state = ARMED; blink(1, 1000, 0); // one long flash = armed Serial.println("Armed"); }Bloc 5 Alarme, vérification du faisceau, réarmement
Sur un réveil par le faisceau, elle attend 50 ms et revérifie (ignore un parasite). Toujours coupé : buzzer et DEL rapide pendant 30 s, ou jusqu’au bouton. Ensuite elle attend que le faisceau revienne (porte fermée), deux lectures libres à 100 ms d’écart, et se réarme toute seule. À changer : la durée de l’alarme (
ALARM_S)Voir le code (32 lignes)
// ---------- The alarm: buzzer + fast LED for 30 s, the button stops it ---------- void runAlarm() { Serial.println("ALARM: the door was opened!"); digitalWrite(BUZZER_PIN, BUZZER_ON); unsigned long start = millis(); while (millis() - start < ALARM_S * 1000UL) { digitalWrite(LED_PIN, (millis() / 100) % 2); // fast blink if (waitOrPress(10)) { // button = silence and disarm disarm(); return; } } digitalWrite(BUZZER_PIN, !BUZZER_ON); digitalWrite(LED_PIN, LOW); state = WAIT_CLEAR; // re-arm only once the beam is back (door closed) } // Beam broken: check again 50 ms later, so a tiny flicker does not ring the alarm. void checkBeam() { delay(50); if (beamBroken()) runAlarm(); } // Door closed again after an alarm? Two "clear" readings 100 ms apart = re-armed. void tryRearm() { if (beamBroken()) return; delay(100); if (beamBroken()) return; state = ARMED; blink(1, 1000, 0); Serial.println("Beam back: armed again"); }Bloc 6 Le mode test
Pendant 90 s après la mise sous tension ou un appui sur EN, la carte reste éveillée : la DEL est allumée tant que le faisceau est coupé et le moniteur affiche clear ou broken. À la fin, le buzzer fait un court bip (0,2 s) : c’est le test du buzzer. À changer : la durée du mode test (
TEST_S)Voir le code (23 lignes)
// ---------- Test mode: 90 s after switching on or pressing EN ---------- // Use it to line up the emitter and the receiver. The LED is ON while the beam is broken, and // the Serial Monitor prints "clear" or "broken" each time it changes. At the end, a short beep // (0.2 s) tests the buzzer. Need more time? Press EN (reset): test mode starts again. void testMode() { Serial.println("Test mode (90 s): wave your hand through the beam"); unsigned long start = millis(); int last = -1; // -1 = nothing printed yet while (millis() - start < TEST_S * 1000UL) { bool broken = beamBroken(); digitalWrite(LED_PIN, broken); // LED on = beam broken if (broken != last) { // print only when it changes Serial.println(broken ? "broken" : "clear"); last = broken; } delay(50); } digitalWrite(LED_PIN, LOW); digitalWrite(BUZZER_PIN, BUZZER_ON); // buzzer test: a short beep = the buzzer works delay(200); digitalWrite(BUZZER_PIN, !BUZZER_ON); Serial.println("End of test mode"); }Bloc 7 S’endormir
Avant de dormir, elle éteint le buzzer et la DEL et les verrouille éteints, puis liste ce qui peut la réveiller : le bouton, le faisceau quand elle est armée, une minuterie de 30 s pour le signal de vie, et une minuterie de 5 s pendant qu’elle attend la fermeture de la porte. À changer : rien
Voir le code (42 lignes)
// ---------- Going to sleep ---------- void goToSleep() { waitButtonRelease(); // a button still pressed would wake us up at once if (state == ARMED && beamBroken()) { // the beam must be clear before sleeping armed checkBeam(); waitButtonRelease(); } // Freeze the buzzer OFF and the LED off during sleep (else the pins could float). digitalWrite(BUZZER_PIN, !BUZZER_ON); digitalWrite(LED_PIN, LOW); gpio_hold_en(BUZZER_PIN); gpio_hold_en(LED_PIN); gpio_deep_sleep_hold_en(); // Keep the "RTC" part powered so the pull-ups keep working (costs a few microamps). esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON); // Wake-up 1, always: the button. "ALL_LOW" with one pin = "the button is pressed". esp_sleep_enable_ext1_wakeup_io(1ULL << BUTTON_PIN, ESP_EXT1_WAKEUP_ALL_LOW); if (state == ARMED) { esp_sleep_enable_ext0_wakeup(BEAM_PIN, BROKEN); // wake-up 2: the beam is broken if (HEARTBEAT_S > 0) esp_sleep_enable_timer_wakeup(HEARTBEAT_S * 1000000ULL); // flash timer } // Door left open after an alarm: no beam wake-up (it would wake us again and again), // just a timer to check the beam every 5 s. if (state == WAIT_CLEAR) esp_sleep_enable_timer_wakeup(RECHECK_S * 1000000ULL); // Built-in pull-ups that stay on during sleep (the receiver needs one even if BROKEN is HIGH). rtc_gpio_init(BEAM_PIN); rtc_gpio_set_direction(BEAM_PIN, RTC_GPIO_MODE_INPUT_ONLY); rtc_gpio_pullup_en(BEAM_PIN); rtc_gpio_pulldown_dis(BEAM_PIN); rtc_gpio_init(BUTTON_PIN); rtc_gpio_set_direction(BUTTON_PIN, RTC_GPIO_MODE_INPUT_ONLY); rtc_gpio_pullup_en(BUTTON_PIN); rtc_gpio_pulldown_dis(BUTTON_PIN); Serial.println(state == ARMED ? "Sleeping (armed)" : state == WAIT_CLEAR ? "Sleeping (waiting for the door)" : "Sleeping (disarmed)"); Serial.flush(); esp_deep_sleep_start(); // the ESP32 stops here; the next wake-up starts setup() again }Bloc 8 setup() et loop()
S’exécute à chaque réveil. Elle demande ce qui a réveillé la carte (mise sous tension ou EN, bouton, faisceau, minuterie), agit en conséquence, puis se rendort.
loop()n’est jamais atteinte. À changer : rienVoir le code (40 lignes)
// ---------- setup(): runs at every wake-up ---------- void setup() { setCpuFrequencyMhz(80); // slower = less current while awake Serial.begin(115200); // Unfreeze the outputs, and give the two input pins back to normal code. gpio_hold_dis(BUZZER_PIN); gpio_hold_dis(LED_PIN); rtc_gpio_deinit(BEAM_PIN); rtc_gpio_deinit(BUTTON_PIN); pinMode(BUZZER_PIN, OUTPUT); digitalWrite(BUZZER_PIN, !BUZZER_ON); pinMode(LED_PIN, OUTPUT); pinMode(BEAM_PIN, INPUT_PULLUP); // built-in pull-up to 3.3 V (see IMPORTANT above) pinMode(BUTTON_PIN, INPUT_PULLUP); // pressed = LOW blink(1, 50, 0); // tiny flash at every wake-up, so you can see it working // Why did we wake up? esp_sleep_wakeup_cause_t cause = esp_sleep_get_wakeup_cause(); if (cause == ESP_SLEEP_WAKEUP_EXT1) { // the button if (state == DISARMED) armAlarm(); else disarm(); // armed or waiting: the button disarms } else if (cause == ESP_SLEEP_WAKEUP_EXT0) { // the beam if (state == ARMED) checkBeam(); } else if (cause == ESP_SLEEP_WAKEUP_TIMER) { // the timer if (state == ARMED && beamBroken()) checkBeam(); // rare: broken right at the flash if (state == WAIT_CLEAR) tryRearm(); } else { // switched on, or EN (reset) button: test mode first state = DISARMED; testMode(); blink(2, 150, 150); Serial.println("Ready: press the button to arm"); } goToSleep(); } void loop() { // Never reached: goToSleep() always ends setup(). }
Le croquis complet, d’un seul tenant
// Tinker Mission — Mission 01: Intrusion alarm (battery version, no Wi-Fi)
// Board: ESP32 Dev Module ("esp32 by Espressif" 3.3.x). No extra library needed.
//
// How it works: the emitter is stuck on the door leaf and the receiver on the frame, facing each
// other about 15-20 cm apart when the door is closed. When the door opens, the beam is broken:
// the buzzer sounds and the LED blinks fast. The emitter is an infrared LED, not a laser.
//
// Battery trick: "deep sleep". Most of the time the ESP32 is asleep and uses almost nothing.
// It wakes up only when something happens:
// - you press the button (to arm or disarm),
// - the beam is broken while the alarm is armed,
// - a small timer rings (a short "I'm alive" flash every 30 s while armed).
// Each wake-up starts the sketch again from the top of setup(). loop() is never used.
//
// Test mode: for 90 s after you switch on (or press the EN button), the LED shows the beam,
// so you can line up the emitter and the receiver. Then a short beep, and it is ready.
//
// Wiring (ESP32 DevKitC, 38 pins):
// 4xAA pack red (+) -> 5V pin black (-) -> GND (5V pin ONLY, never a red rail: the rail is 3V3)
// IR emitter red / black -> its own 3xAA pack (on the door, no wire to the ESP32)
// IR receiver red -> 3V3 pin black -> GND white/yellow (OUT) -> GPIO32
// Buzzer module S -> GPIO25 + -> 3V3 - -> GND (active buzzer)
// LED GPIO26 -> 220 ohm resistor -> LED long leg; LED short leg -> GND
// Push button GPIO27 -> button -> GND
// Switch the pack OFF before you plug in the USB cable: one power source at a time.
//
// IMPORTANT: the receiver output is "open collector": it can pull the wire down to GND, but it
// cannot push it up. So the wire needs a pull-up resistor. We use the ESP32's built-in one,
// which pulls up to 3.3 V. Never add a pull-up to 5 V: ESP32 pins use 3.3 V logic.
#include "driver/rtc_io.h" // "RTC" pins: their pull-ups keep working while the ESP32 sleeps
#include "driver/gpio.h" // gpio_hold_en(): freezes an output pin at its level during sleep
#include "esp_sleep.h" // deep sleep and wake-up sources
// ---------- Pins (these four can all wake the ESP32 or stay frozen during sleep) ----------
const gpio_num_t BEAM_PIN = GPIO_NUM_32; // IR receiver output
const gpio_num_t BUZZER_PIN = GPIO_NUM_25;
const gpio_num_t LED_PIN = GPIO_NUM_26;
const gpio_num_t BUTTON_PIN = GPIO_NUM_27; // pressed = LOW (wired to GND)
// ---------- Settings you may change ----------
// Most receivers pull OUT down to LOW when the beam is broken. Right after you switch on, the
// LED lights while the beam is broken (90 s test mode). If it is the other way round, change LOW to HIGH.
const int BROKEN = LOW;
// Most buzzer modules beep when S is HIGH. A "low-level trigger" module beeps when S is LOW:
// if yours beeps all the time while asleep, change HIGH to LOW.
const int BUZZER_ON = HIGH;
const int ARMING_S = 10; // seconds to leave and close the door after pressing the button
const int ALARM_S = 30; // how long the buzzer sounds
const int HEARTBEAT_S = 30; // short LED flash every 30 s while armed (0 = no flash, longer battery)
const int RECHECK_S = 5; // door left open after an alarm: check again every 5 s
const int DOOR_WAIT_S = 60; // after the arming delay, wait up to 60 s for the door to be closed
const int TEST_S = 90; // test mode after switching on or EN: 90 s where the LED shows the beam
// ---------- Memory that survives deep sleep ----------
// Normal variables are wiped at each wake-up. "RTC_DATA_ATTR" keeps this one in a tiny memory
// that stays powered while the ESP32 sleeps. Switching off (or the EN button) resets it.
const int DISARMED = 0; // sleeping, only the button can wake it
const int ARMED = 1; // watching the beam
const int WAIT_CLEAR = 2; // the alarm has rung: waiting for the door to be closed again
RTC_DATA_ATTR int state = DISARMED;
// ---------- Small helpers ----------
bool beamBroken() { return digitalRead(BEAM_PIN) == BROKEN; }
bool buttonPressed() { return digitalRead(BUTTON_PIN) == LOW; }
void blink(int times, int onMs, int offMs) {
for (int i = 0; i < times; i++) {
digitalWrite(LED_PIN, HIGH);
delay(onMs);
digitalWrite(LED_PIN, LOW);
delay(offMs);
}
}
void waitButtonRelease() {
while (buttonPressed()) delay(10);
delay(50); // ignore button bounce
}
// Waits `ms` milliseconds, but stops early and returns true if the button is pressed.
bool waitOrPress(int ms) {
for (int t = 0; t < ms; t += 10) {
if (buttonPressed()) return true;
delay(10);
}
return false;
}
void disarm() {
digitalWrite(BUZZER_PIN, !BUZZER_ON); // buzzer off
blink(2, 150, 150); // 2 short blinks = disarmed
state = DISARMED;
Serial.println("Disarmed");
}
// ---------- Arming: 10 s to leave, then the door must be closed ----------
void armAlarm() {
waitButtonRelease();
if (beamBroken()) { // beam already broken: emitter off, or not facing the receiver
Serial.println("Beam broken: check the emitter. Not armed.");
blink(20, 50, 50); // fast blinking for 2 s = error
state = DISARMED;
return;
}
Serial.println("Arming...");
for (int i = 0; i < ARMING_S; i++) { // LED blinks once per second
digitalWrite(LED_PIN, HIGH);
bool pressed = waitOrPress(500);
digitalWrite(LED_PIN, LOW);
if (pressed || waitOrPress(500)) { // a press during the delay cancels
waitButtonRelease();
disarm();
return;
}
}
unsigned long start = millis();
while (beamBroken()) { // door still open: keep blinking and wait
if (millis() - start > DOOR_WAIT_S * 1000UL) {
Serial.println("Door never closed. Not armed.");
blink(20, 50, 50);
state = DISARMED;
return;
}
digitalWrite(LED_PIN, (millis() / 500) % 2);
if (waitOrPress(10)) {
waitButtonRelease();
disarm();
return;
}
}
state = ARMED;
blink(1, 1000, 0); // one long flash = armed
Serial.println("Armed");
}
// ---------- The alarm: buzzer + fast LED for 30 s, the button stops it ----------
void runAlarm() {
Serial.println("ALARM: the door was opened!");
digitalWrite(BUZZER_PIN, BUZZER_ON);
unsigned long start = millis();
while (millis() - start < ALARM_S * 1000UL) {
digitalWrite(LED_PIN, (millis() / 100) % 2); // fast blink
if (waitOrPress(10)) { // button = silence and disarm
disarm();
return;
}
}
digitalWrite(BUZZER_PIN, !BUZZER_ON);
digitalWrite(LED_PIN, LOW);
state = WAIT_CLEAR; // re-arm only once the beam is back (door closed)
}
// Beam broken: check again 50 ms later, so a tiny flicker does not ring the alarm.
void checkBeam() {
delay(50);
if (beamBroken()) runAlarm();
}
// Door closed again after an alarm? Two "clear" readings 100 ms apart = re-armed.
void tryRearm() {
if (beamBroken()) return;
delay(100);
if (beamBroken()) return;
state = ARMED;
blink(1, 1000, 0);
Serial.println("Beam back: armed again");
}
// ---------- Test mode: 90 s after switching on or pressing EN ----------
// Use it to line up the emitter and the receiver. The LED is ON while the beam is broken, and
// the Serial Monitor prints "clear" or "broken" each time it changes. At the end, a short beep
// (0.2 s) tests the buzzer. Need more time? Press EN (reset): test mode starts again.
void testMode() {
Serial.println("Test mode (90 s): wave your hand through the beam");
unsigned long start = millis();
int last = -1; // -1 = nothing printed yet
while (millis() - start < TEST_S * 1000UL) {
bool broken = beamBroken();
digitalWrite(LED_PIN, broken); // LED on = beam broken
if (broken != last) { // print only when it changes
Serial.println(broken ? "broken" : "clear");
last = broken;
}
delay(50);
}
digitalWrite(LED_PIN, LOW);
digitalWrite(BUZZER_PIN, BUZZER_ON); // buzzer test: a short beep = the buzzer works
delay(200);
digitalWrite(BUZZER_PIN, !BUZZER_ON);
Serial.println("End of test mode");
}
// ---------- Going to sleep ----------
void goToSleep() {
waitButtonRelease(); // a button still pressed would wake us up at once
if (state == ARMED && beamBroken()) { // the beam must be clear before sleeping armed
checkBeam();
waitButtonRelease();
}
// Freeze the buzzer OFF and the LED off during sleep (else the pins could float).
digitalWrite(BUZZER_PIN, !BUZZER_ON);
digitalWrite(LED_PIN, LOW);
gpio_hold_en(BUZZER_PIN);
gpio_hold_en(LED_PIN);
gpio_deep_sleep_hold_en();
// Keep the "RTC" part powered so the pull-ups keep working (costs a few microamps).
esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
// Wake-up 1, always: the button. "ALL_LOW" with one pin = "the button is pressed".
esp_sleep_enable_ext1_wakeup_io(1ULL << BUTTON_PIN, ESP_EXT1_WAKEUP_ALL_LOW);
if (state == ARMED) {
esp_sleep_enable_ext0_wakeup(BEAM_PIN, BROKEN); // wake-up 2: the beam is broken
if (HEARTBEAT_S > 0) esp_sleep_enable_timer_wakeup(HEARTBEAT_S * 1000000ULL); // flash timer
}
// Door left open after an alarm: no beam wake-up (it would wake us again and again),
// just a timer to check the beam every 5 s.
if (state == WAIT_CLEAR) esp_sleep_enable_timer_wakeup(RECHECK_S * 1000000ULL);
// Built-in pull-ups that stay on during sleep (the receiver needs one even if BROKEN is HIGH).
rtc_gpio_init(BEAM_PIN);
rtc_gpio_set_direction(BEAM_PIN, RTC_GPIO_MODE_INPUT_ONLY);
rtc_gpio_pullup_en(BEAM_PIN);
rtc_gpio_pulldown_dis(BEAM_PIN);
rtc_gpio_init(BUTTON_PIN);
rtc_gpio_set_direction(BUTTON_PIN, RTC_GPIO_MODE_INPUT_ONLY);
rtc_gpio_pullup_en(BUTTON_PIN);
rtc_gpio_pulldown_dis(BUTTON_PIN);
Serial.println(state == ARMED ? "Sleeping (armed)" : state == WAIT_CLEAR ? "Sleeping (waiting for the door)" : "Sleeping (disarmed)");
Serial.flush();
esp_deep_sleep_start(); // the ESP32 stops here; the next wake-up starts setup() again
}
// ---------- setup(): runs at every wake-up ----------
void setup() {
setCpuFrequencyMhz(80); // slower = less current while awake
Serial.begin(115200);
// Unfreeze the outputs, and give the two input pins back to normal code.
gpio_hold_dis(BUZZER_PIN);
gpio_hold_dis(LED_PIN);
rtc_gpio_deinit(BEAM_PIN);
rtc_gpio_deinit(BUTTON_PIN);
pinMode(BUZZER_PIN, OUTPUT);
digitalWrite(BUZZER_PIN, !BUZZER_ON);
pinMode(LED_PIN, OUTPUT);
pinMode(BEAM_PIN, INPUT_PULLUP); // built-in pull-up to 3.3 V (see IMPORTANT above)
pinMode(BUTTON_PIN, INPUT_PULLUP); // pressed = LOW
blink(1, 50, 0); // tiny flash at every wake-up, so you can see it working
// Why did we wake up?
esp_sleep_wakeup_cause_t cause = esp_sleep_get_wakeup_cause();
if (cause == ESP_SLEEP_WAKEUP_EXT1) { // the button
if (state == DISARMED) armAlarm();
else disarm(); // armed or waiting: the button disarms
} else if (cause == ESP_SLEEP_WAKEUP_EXT0) { // the beam
if (state == ARMED) checkBeam();
} else if (cause == ESP_SLEEP_WAKEUP_TIMER) { // the timer
if (state == ARMED && beamBroken()) checkBeam(); // rare: broken right at the flash
if (state == WAIT_CLEAR) tryRearm();
} else { // switched on, or EN (reset) button: test mode first
state = DISARMED;
testMode();
blink(2, 150, 150);
Serial.println("Ready: press the button to arm");
}
goToSleep();
}
void loop() {
// Never reached: goToSleep() always ends setup().
}
Le code est-il testé ?
Le code est compilé automatiquement à chaque modification, il devrait donc se construire sans erreur. Un test sur le vrai matériel aura lieu quand nous monterons ce projet ; d’ici là, la fiche reste « À tester » et certains détails (coût, durée de vie des piles, durée, portée sur une vraie porte) peuvent changer. Le code suppose que la sortie du récepteur passe à LOW quand le faisceau est coupé. Vérifie-le sur ton module (étape 9) et change la constante BROKEN si c’est l’inverse.
Liste de contrôle
- Le moniteur série affiche « broken » quand ta main coupe le faisceau, « clear » sinon
- Porte fermée, « clear » reste stable
- Bloc sur ON : 90 s de mode test, un bip, puis deux petits clignotements. Bouton : 10 s de clignotement, puis un long éclair
- Ouvrir la porte fait sonner le buzzer pendant 30 secondes
- Un appui sur le bouton coupe le son et désarme tout
- Après l’alarme, refermer la porte réarme l’alarme
- Les deux blocs sont étiquetés, et le rail + affiche 0 V avec le bloc sur ON et l’ESP32 retiré (version permanente)
Dépannage
Rien ne se passe quand j’allume le bloc
5V (pas un rail) et que l’interrupteur est sur ON. Mesure le bloc au multimètre : 4×AA doit afficher environ 4,4–6,5 V ; en dessous, la carte se comporte mal : change les piles.La DEL rouge d’alimentation est allumée mais la DEL ne clignote pas
Bloqué sur « broken » porte fermée
L’émetteur s’éteint au bout de quelques jours
Le buzzer sonne tout le temps (ou jamais)
BUZZER_ON dans le code (étape 11).L’alarme se déclenche toute seule
La carte ne se réveille pas quand j’ouvre la porte
GPIO32) et que l’alarme est armée (un long éclair après le compte à rebours).Pas d’alerte sur le téléphone (bonus)
Pour aller plus loin 1 : l’alerte sur téléphone
Même montage, aucun nouveau fil. Ajoute le Wi-Fi pour que ton téléphone vibre quand l’alarme se déclenche. Le buzzer sonne toujours en premier et sonne ses 30 secondes quoi que fasse le Wi-Fi.
3 étapes bonus · 1 morceau de code · Wi-Fi nécessaire
Étape B1 · Prépare le téléphone.
Installe l’appli gratuite ntfy et abonne-toi à un sujet que tu inventes (lettres et chiffres au hasard, pas de noms). Quiconque le devine peut le lire.
Vérifie : Le sujet apparaît dans l’appli.
Étape B2 · Charge le croquis d’alerte et complète-le.
Ouvre le croquis « 01b-intrusion-alarm-phone ». Écris le nom de ton Wi-Fi, son mot de passe et le même sujet. L’ESP32 ne rejoint que le Wi-Fi 2,4 GHz (pas le 5 GHz). Téléverse (les deux blocs sur OFF, puis l’USB, comme avant).
Vérifie : Le sujet du code est identique à celui de l’appli.
Étape B3 · Teste.
Arme l’alarme et ouvre la porte.
Vérifie : Le buzzer sonne et, quelques secondes plus tard, l’alerte arrive sur ton téléphone. Une seule alerte par alarme.
Le Wi-Fi n’est allumé que pendant une alarme (il attend 10 s au maximum pour se connecter), donc les piles durent toujours environ 10–14 jours. Quand les piles faiblissent, l’alerte sur téléphone est la première à cesser de marcher : remplace-les. Si la carte redémarre pendant une alerte (piles faibles), elle revient désarmée (deux clignotements) : change les piles. Le bouton n’est pas lu pendant l’envoi de l’alerte (environ 10 s).
Bloc bonus L’alerte sur téléphone
Seulement dans le croquis téléphone. Allume le Wi-Fi seulement pendant une alarme (10 s au maximum pour se connecter), envoie un court message à ntfy, puis éteint le Wi-Fi.
setInsecure()saute les vérifications de certificat pour rester simple. À changer : nom du Wi-Fi, mot de passe, sujet, le texte du messageVoir le code (34 lignes)
// ---------- The phone alert ---------- // Sends one short message to the ntfy service (Wi-Fi must be connected). void sendPhoneAlert() { WiFiClientSecure client; client.setInsecure(); // skips certificate checks to keep it simple HTTPClient http; http.setConnectTimeout(5000); // never wait more than 5 s for the server http.setTimeout(5000); http.begin(client, String("https://ntfy.sh/") + NTFY_TOPIC); int code = http.POST("Alarm: the door was opened (infrared beam broken)."); Serial.printf("Phone alert sent (answer %d)\n", code); http.end(); } // Wi-Fi on, one alert, Wi-Fi off. The LED keeps blinking fast meanwhile. // Returns true if the button was pressed while we waited for Wi-Fi. bool phoneAlert() { WiFi.mode(WIFI_STA); WiFi.begin(WIFI_NAME, WIFI_PASS); bool pressed = false; unsigned long start = millis(); while (WiFi.status() != WL_CONNECTED && millis() - start < WIFI_TIMEOUT_S * 1000UL) { digitalWrite(LED_PIN, (millis() / 100) % 2); if (waitOrPress(10)) { pressed = true; break; } } if (!pressed && WiFi.status() == WL_CONNECTED) sendPhoneAlert(); else if (!pressed) Serial.println("No Wi-Fi: no phone alert (check name, password, 2.4 GHz)"); WiFi.disconnect(true); // Wi-Fi off again: it is the biggest battery user WiFi.mode(WIFI_OFF); return pressed; }
Rends-la permanente
Sur une plaque d’essai, un choc peut arracher un fil. Ici, tu soudes le même circuit sur une plaque perforée, tu enfiches l’ESP32 dans des supports (pour pouvoir le retirer), et tu mets le tout dans un boîtier imprimé en 3D. Le plan copie la plaque d’essai trou par trou, donc tout ce que tu as appris reste valable. Il faut être prêt à souder : c’est un bon savoir-faire et ce n’est pas difficile, mais le fer est très chaud.
Sécurité pour souder
- Soudure sans plomb avec flux intégré (le 0,8 mm est facile à utiliser).
- Fer avec support et réglage de température, à 325–375 °C. Baisse-la si la soudure fume.
- Ventilation : ouvre une fenêtre, ou utilise un petit ventilateur avec filtre qui éloigne la fumée de ton visage.
- Lunettes de protection : les bouts de fils coupés et la soudure peuvent gicler.
- Le fer reste dans son support dès que tu ne t’en sers pas. Ne touche jamais la panne ni la tige métallique. Travaille sur un tapis résistant à la chaleur. Débranche le fer quand tu arrêtes. En cas de brûlure : eau froide courante pendant au moins 10 minutes.
- Tiens la plaque avec une pince (« troisième main »), pas avec les doigts.
- Rien sous tension pendant que tu soudes : piles sorties du support, ESP32 retiré de ses supports, USB débranché.
- Lave-toi les mains ensuite, et garde la nourriture loin de l’établi.
- Demande à une personne qui a déjà soudé de regarder tes cinq premières soudures.
14 étapes · +2–3 h · fer à souder · demande de l’aide
Pièces pour la version permanente
Les pièces du montage de base (ESP32, récepteur, buzzer, DEL, résistance, bouton, blocs de piles, bornes WAGO) passent sur la nouvelle plaque. Tu ajoutes :
Voir les 6 pièces
- 1
Plaque perforée à motif de plaque d’essai, format complet×1
Remplace la plaque d’essai
Spécification exacte : Format complet, mêmes rangées, mêmes bandes de 5 trous et mêmes rails que la plaque d’essai (type Adafruit Perma-Proto Full-sized 1606 : 157 × 51 mm, 3 trous de fixation). Format complet, pas demi, pour que le plan se copie 1 pour 1.
- 2
Barrette femelle, 2,54 mm2 barrettes : 1×40 + 1×20
L’ESP32 et le buzzer s’y enfichent et restent amovibles
Spécification exacte : Simple rangée, pas de 2,54 mm, broches longues. La 1×40 donne les deux rangées de 19 trous pour l’ESP32, la 1×20 donne la rangée de 3 trous du buzzer (H3). Coupe à la pince coupante ; tu perds un trou à chaque coupe.
- 3
Borniers à vis, pas de 5,0 / 5,08 mm1 × 2 pôles, 1 × 3 pôles
Le bloc de piles et le récepteur se branchent sans souder leurs fils
Spécification exacte : Pour circuit imprimé, entrée de fil vers l’extérieur (type KF301 / DG301).
- 4
Fil de câblage rigide, 22 AWG, plusieurs couleurs1 lot
Relier les trous de la plaque
Spécification exacte : Isolé, rouge, noir, jaune, orange, vert, bleu.
- 5
Soudure sans plomb, avec flux1 bobine
Assemble les pièces
Spécification exacte : 0,8 mm, par exemple Sn99,3/Cu0,7 ou SAC305.
- 6
Vis M36 à tête fraisée M3 × 10, 3 à tête cylindrique M3 × 6–8
Fermer le boîtier et y fixer la plaque
Spécification exacte : Tête fraisée : 4 pour le couvercle, 2 pour la trappe des piles. Tête cylindrique : 3 pour tenir la plaque sur ses entretoises imprimées (du M2,5 convient aussi).
Outils pour la version permanente
Voir les 6 outils (1 en option)
Fer à souder avec support et réglage de température
Souder les points
Spécification exacte : Réglable, 325–375 °C
Multimètre
Contrôler les soudures avant la mise sous tension (obligatoire ici)
Spécification exacte : Testeur de continuité, tension continue, test de diode
Lunettes de protection
Protéger les yeux des bouts coupés qui giclent
Spécification exacte : N’importe quelle paire transparente
Troisième main ou support de plaque
Tenir la plaque pendant la soudure
Spécification exacte : N’importe lequel
Pince coupante et pince à dénuder
Couper les barrettes et les fils
Spécification exacte : N’importe lesquelles
Petit ventilateur avec filtre (ou fenêtre ouverte)facultatif
Éloigner la fumée de soudure
Spécification exacte : N’importe lequel
La rangée 1 est au bord USB de la plaque perforée. Les rangées suivent le grand côté. Les colonnes a–e et f–j sont de part et d’autre de la rainure centrale, comme sur la plaque d’essai. Soude par en dessous ; les pièces sont posées dessus.
Étapes de soudure
Étape P1 · Installe un établi sûr. Demande de l’aide
Lis la liste de sécurité pour souder. Fenêtre ouverte ou ventilateur allumé, lunettes sur le nez, fer dans son support sur un tapis résistant à la chaleur, plaque dans la pince. Demande à une personne qui a déjà soudé d’être là pour tes cinq premières soudures.
Vérifie : Une personne expérimentée est avec toi, et le fer n’est chaud que quand tu en as besoin.
Étape P2 · Pose les supports de l’ESP32.
Enfonce les deux barrettes femelles 1×19 sur les broches de l’ESP32 (elles restent bien alignées). Pose la carte et les barrettes sur la plaque perforée : une barrette en colonne a, rangées 1–19, l’autre en colonne i, rangées 1–19, côté USB à la rangée 1. Retourne le tout et soude une broche à chaque bout de chaque barrette. Vérifie que ça tient à plat et droit, puis soude les autres broches. Retire l’ESP32 et mets-le de côté.
Vérifie : Les supports sont droits, et chaque broche est un petit cône brillant de soudure, pas une boule.
Étape P3 · Soude les borniers et le support du buzzer.
J1 (2 pôles) : + en h25, − en h27. J2 (3 pôles, pour le récepteur) : + en h31, − en h33, OUT en h35. Toutes les ouvertures sont tournées vers le bord droit. H3 (barrette femelle 1×3, pour le buzzer) : h39 = S, h40 = +, h41 = − (respecte l’ordre imprimé sur ton module).
Vérifie : Chaque bornier est à plat sur la plaque, ouvertures tournées vers le bord droit.
Étape P4 · Soude la résistance, la DEL et le bouton.
R1 (220 Ω), couchée à plat : de d26 à d30. D1 (DEL) : patte longue (+) en b30, patte courte (−) en b31. Laisse a30, a31, c30 et c31 vides. SW1 (bouton) : à cheval sur la rainure centrale, pattes en e44, f44, e46, f46. Coupe l’excédent des pattes après la soudure.
Vérifie : La patte longue de la DEL est en b30, et le bouton est à plat.
Étape P5 · Soude les fils d’alimentation (W1 à W4).
Fil isolé 22 AWG, à plat sur le dessus, soudé par en dessous. W1 rouge : f1 → f25 (la broche
5Vvers J1 +). W2 noir : j27 → rail − de droite (J1 − vers GND). W3 rouge : j19 → rail + de droite (rail 3V3). W4 noir : j6 → rail − de droite (rail GND). Les fils peuvent se croiser : ils sont isolés.Vérifie : W1 va vers J1 + et jamais près du rail +.
Étape P8 · Soude les fils de la DEL et du bouton (W11 à W15).
W11 vert : g10 → b26 (
GPIO26vers la rangée 26, la bande de R1). W12 noir : d31 → rail − de gauche, vers la rangée 34 (− de la DEL). W13 bleu : f9 → h44 (GPIO27vers le bouton, patte diagonale f44). W14 noir : a46 → rail − de gauche (autre patte diagonale du bouton, e46). W15 noir : rail − de gauche → rail − de droite, vers la rangée 52.Vérifie : Les 15 fils sont en place. Garde un cercle de 6 mm autour de chaque trou de fixation libre de fils et de pièces, et les rangées 20–23 libres.
Étape P9 · Regarde le dessous.
En bonne lumière, cherche une boule de soudure qui relie deux bandes, ou une bande et un rail. Enlève toute boule avec le fer (et de la tresse à dessouder si tu en as).
Vérifie : Aucun pont entre des soudures voisines.
Étape P10 · Contrôles au multimètre, blocs sur OFF et ESP32 non enfiché. Demande de l’aide
Mode continuité (bip). Ne doit PAS biper : rail + de droite vers rail − de droite ; support i1 (5V) vers le rail + ; support i1 vers le rail − ; supports voisins de i1 à i19 entre eux (seul i6 peut biper vers les éléments de GND). Doit biper : J1 + vers support i1 ; J1 − vers support i6 et vers a19 ; support i19 vers le rail + ; i13 vers OUT de J2 ; i11 vers S de H3 ; i10 vers R1 (rangée 26). Le bouton : support i9 vers le rail − bipe seulement quand on appuie (s’il bipe tout le temps, cherche un pont de soudure sur les rangées 44–46). DEL : test de diode, sonde rouge sur la rangée 30, noire sur le rail − : elle luit faiblement, et une DEL rouge affiche environ 1,6–2,0 V (bleue ou blanche 2,6–3,2 V, ou OL).
Vérifie : Chaque « pas de bip » est silencieux et chaque « bip » bipe.
Étape P11 · Contrôle les blocs, puis le test clé. Demande de l’aide
Mets les piles dans le support de l’ESP32, passe sur ON et lis la tension continue sur ses fils : +5,6 à +6,5 V (alcalines) ou +5,0 à +5,6 V (NiMH). Un signe moins veut dire que les fils sont inversés. Remets sur OFF et visse les fils dans J1 (rouge = +). Maintenant le test clé, l’ESP32 toujours retiré : mets le bloc sur ON, puis mesure le support i1 contre GND : tu lis la tension du bloc. Mesure le rail + contre GND : il doit afficher 0 V.
Vérifie : Le rail + affiche 0 V. S’il affiche la tension du bloc : STOP. La ligne 5V touche le rail 3V3, et cela détruirait l’ESP32. Mets sur OFF, trouve le pont, corrige.
Étape P12 · Enfiche l’ESP32.
Bloc sur OFF. Enfiche l’ESP32 dans ses supports, côté USB à la rangée 1, broche
5Vdans le support i1. Mets le bloc sur ON : la DEL rouge d’alimentation de la carte s’allume, et le rail + affiche 3,2–3,4 V. Contrôle aussi le bloc de l’émetteur : 4,0–4,8 V, avant de le relier à l’émetteur.Vérifie : DEL d’alimentation allumée, rail 3V3 à environ 3,3 V.
Étape P13 · Refais les tests.
Reprends les étapes 9 à 17 du montage de base (faisceau, buzzer, DEL, bouton, porte) avec ta carte soudée.
Vérifie : Elle se comporte exactement comme la version sur plaque d’essai.
Étape P14 · Mets-la dans le boîtier.
Imprime le boîtier pour plaque perforée, son couvercle, la trappe des piles, le long poussoir du bouton et le support de l’émetteur (fichiers : voir « Fichiers 3D » plus bas). Réglages dans Bambu Studio : Bambu Lab X1 Carbon buse 0,4 mm, Bambu PLA Basic, 0,20 mm Standard, 4 parois, gyroïde 15 %, sans supports, sans bordure ; chaque fichier s’ouvre sur un plateau. Durée estimée : environ 9 heures en tout (boîtier 5 h 20, couvercle 1 h 40, support de l’émetteur 1 h 05, trappe 40 min, poussoir 8 min), calculée avec un autre logiciel de tranchage ; les pièces ne sont pas encore imprimées en test. La plaque repose sur 3 entretoises imprimées (3 vis à tête cylindrique), le couvercle prend 4 vis M3 × 10 à tête fraisée et la trappe des piles 2 autres, pour changer les piles sans ouvrir le couvercle. Le bloc 4×AA est dans son propre compartiment, son interrupteur accessible par une fenêtre de la trappe (mesure d’abord ton support : les tailles varient de quelques mm). Le boîtier a aussi une fente pour le port micro-USB, avec « PACK OFF » en relief à côté (bloc sur OFF d’abord), une fenêtre et un tube de lumière pour la DEL, le long poussoir sur SW1, des trous pour le son du buzzer, et une sortie de câble pour les fils du récepteur. Il n’est pas étanche à l’air : laisse les fentes d’aération ouvertes. L’émetteur va dans son propre support imprimé sur la porte : il s’y clipse, et le bloc 3×AA repose dans un berceau tenu par une sangle auto-agrippante (20 mm de large, environ 25 cm). Si tu restes sur la plaque d’essai, il existe aussi un boîtier pour la plaque 830.
Vérifie : L’interrupteur du bloc (par la fenêtre de la trappe), le bouton et le port USB sont accessibles, et les fentes d’aération sont ouvertes.
Fichiers 3D
Un fichier 3MF par pièce (s’ouvre dans Bambu Studio, PrusaSlicer ou OrcaSlicer, le texte prêt pour une deuxième couleur) et la même pièce en STL (une couleur, n’importe quel trancheur).
Modèle rév. 3d : contrôles d’ajustement, de porte-à-faux et de couches réussis ; pas encore imprimé pour test.
Mesure d’abord
Avant d’imprimer, mesure tes propres pièces avec une règle ou un pied à coulisse : les deux blocs de piles (taille et position de l’interrupteur), la plaque d’essai ou la plaque perforée, la prise USB et le buzzer. Les modèles varient de quelques millimètres. Si une mesure diffère, change-la dans le fichier OpenSCAD, ou imprime d’abord un petit coin de test. Trop serré : jeu de 0,4 mm ; trop lâche : 0,2 mm.
Voir les 8 pièces à imprimer
- Boîtier pour plaque d’essai (version sans soudure, 830 points)côté ouvert en haut ; logement 4×AA, fente USBTaille imprimée : 216 × 130 × 32 mmDurée d’impression · filament : ~4 h 25 · ~123 g 3MF 63 Ko STL 1 Mo
- Couvercle du boîtier pour plaque d’essaiface du logo en bas ; trous pour la DEL, le bouton et le buzzer ; 6 vis M3 × 10 à tête fraiséeTaille imprimée : 216 × 60 mmDurée d’impression · filament : ~1 h 15 · ~35 g 3MF 123 Ko STL 1,4 Mo
- Poussoir du bouton (boîtier pour plaque d’essai)collerette en bas ; détache le disque rond après l’impressionTaille imprimée : Ø6 × 4,7 mmDurée d’impression · filament : 2 min 3MF 7 Ko STL 97 Ko
- Boîtier pour plaque perforée (version permanente)côté ouvert en haut ; logement 4×AA, fente USB, trous pour le son, fentes d’aération, 3 plotsTaille imprimée : 188 × 144 × 38 mmDurée d’impression · filament : 5 h 20 · 144 g 3MF 84 Ko STL 1,3 Mo
- Couvercle du boîtier pour plaque perforéeface du logo en bas ; tube de lumière pour la DEL ; 6 vis M3 × 10 à tête fraiséeTaille imprimée : 188 × 75 mmDurée d’impression · filament : 1 h 40 · 38 g 3MF 122 Ko STL 1,4 Mo
- Long poussoir du bouton (boîtier pour plaque perforée)se place au-dessus de SW1 ; imprimes-en 2 côte à côte (tige haute et fine)Taille imprimée : Ø4 × 27,9 mmDurée d’impression · filament : 8 min (×2) 3MF 7 Ko STL 97 Ko
- Trappe des piles (les deux boîtiers)face de l’étiquette en bas ; fenêtre pour l’interrupteur du bloc, 2 vis M3 × 10 à tête fraiséeTaille imprimée : 86 × 69 × 2 mmDurée d’impression · filament : 37 min · 12 g 3MF 71 Ko STL 688 Ko
- Support de l’émetteur pour la portebase en bas ; l’émetteur s’y clipse, berceau 3×AA tenu par une sangle auto-agrippanteTaille imprimée : 119 × 55 × 18,6 mmDurée d’impression · filament : 1 h 05 · 25 g 3MF 63 Ko STL 970 Ko
Réglages Bambu Studio
Bambu Lab X1 Carbon buse 0,4 · Bambu PLA Basic · 0,20 mm Standard · 4 parois · remplissage gyroïde 15 % · supports désactivés · sans bordure. Imprime chaque pièce dans l’orientation du fichier. Deux couleurs : si le texte se charge fusionné avec la pièce, clic droit, Séparer, En parties, puis donne le filament 2 à la partie texte.
- Source OpenSCAD (pour changer les tailles) 38 Ko
- Toutes les notes : vis, assemblage, sources des dimensions (en anglais) 17 Ko
Conditions d’utilisation : Nos propres modèles, partagés sous licence CC BY-NC 4.0 : crédite « Tinker Mission », pas d’usage commercial. Texte de la licence (en anglais)
Pour aller plus loin 2 (bientôt)
Voir les idées
- Des mois sur piles : remplace la carte par une carte basse consommation, qui dort en consommant presque rien, pour que les mêmes piles durent beaucoup plus longtemps.
- La version à aimant : au lieu d’un faisceau infrarouge, un petit aimant et un contact à lame souple (reed). Elle consomme presque rien, donc elle peut tourner très longtemps.
Bientôt disponible. Tu pourras réutiliser ton buzzer, ta DEL, ton bouton et tes blocs de piles.
Pour aller plus loin
Envie d’aller plus loin ? Voici l’amélioration de cette mission :
- un faisceau visible : un point rouge que tu peux viser et voir ;
- une lecture analogique : au lieu de « libre / coupé », l’ESP32 lit un nombre de 0 à 4095 ;
- le réglage du seuil : tu choisis toi-même le nombre limite.
Tu peux réutiliser l’ESP32, le buzzer, la DEL et le bouton de ce montage.
Liste d’achats
Faite à partir des listes de pièces et d’outils ci-dessus, avec les quantités. Chaque ligne ouvre une recherche Amazon.fr ; Amazon n’a pas de lien de panier multiple sans codes produits exacts, donc tu ajoutes les articles un par un. Copie la liste pour la garder.
Chaque lien ouvre une simple recherche Amazon.fr faite à partir des mots-clés (pas un lien d’affiliation). Choisis une offre qui correspond à la spécification exacte de la liste des pièces.
Voir les 30 articles
- ×1Carte ESP32Amazon.fr
- 1 paireBarrière infrarouge 5 mm (émetteur + récepteur)Amazon.fr
- ×1Support 4×AA avec interrupteur ON/OFF, couvercle et extrémités à brochesAmazon.fr
- ×1Support 3×AA avec interrupteur ON/OFF et couvercleAmazon.fr
- ×7Piles AAAmazon.fr
- ×2Bornes à levier WAGO 221-412Amazon.fr
- ×1Résistance 220 ΩAmazon.fr
- ×1DELAmazon.fr
- ×1Module buzzer actifAmazon.fr
- ×1Bouton poussoirAmazon.fr
- ×1Plaque d’essaiAmazon.fr
- 1 lotFils de connexionAmazon.fr
- ×1Câble USB donnéesAmazon.fr
- ×1Ordinateur avec Arduino IDE—
- ×1Ruban adhésifAmazon.fr
- ×1Règle ou mètre ruban (facultatif)Amazon.fr
- ×1Étiquettes autocollantes et un styloAmazon.fr
- ×1Multimètre (facultatif)Amazon.fr
- ×1Plaque perforée à motif de plaque d’essai, format complet (Rends-la permanente)Amazon.fr
- 2 barrettes : 1×40 + 1×20Barrette femelle, 2,54 mm (Rends-la permanente)Amazon.fr
- 1 × 2 pôles, 1 × 3 pôlesBorniers à vis, pas de 5,0 / 5,08 mm (Rends-la permanente)Amazon.fr
- 1 lotFil de câblage rigide, 22 AWG, plusieurs couleurs (Rends-la permanente)Amazon.fr
- 1 bobineSoudure sans plomb, avec flux (Rends-la permanente)Amazon.fr
- 6 à tête fraisée M3 × 10, 3 à tête cylindrique M3 × 6–8Vis M3 (Rends-la permanente)Amazon.fr
- ×1Fer à souder avec support et réglage de température (Rends-la permanente)Amazon.fr
- ×1Multimètre (Rends-la permanente)Amazon.fr
- ×1Lunettes de protection (Rends-la permanente)Amazon.fr
- ×1Troisième main ou support de plaque (Rends-la permanente)Amazon.fr
- ×1Pince coupante et pince à dénuder (Rends-la permanente)Amazon.fr
- ×1Petit ventilateur avec filtre (ou fenêtre ouverte) (Rends-la permanente) (facultatif)Amazon.fr
Alarme anti-intrusion 1 × Carte ESP32 — ESP32-DevKitC V4 ou un clone : ESP32-WROOM-32, 38 broches, logique 3,3 V. Vérifie le régulateur avant d’acheter ou d’utiliser la carte (étape 2) : la puce à 3 pattes avec une grande languette près de la broche 5V doit porter la mention AMS1117. https://www.amazon.fr/s?k=carte+ESP32+DevKitC+38+broches+WROOM-32+AMS1117 1 paire × Barrière infrarouge 5 mm (émetteur + récepteur) — Version à DEL 5 mm (type Adafruit 2168) : émetteur (2 fils, rouge et noir) + récepteur (3 fils : rouge +, noir −, blanc ou jaune OUT), sortie à collecteur ouvert, alimentation 3,3–5,5 V. Portée annoncée d’environ 50 cm à 5 V ; on en utilise 15–20, donc de la marge. Teste-la. https://www.amazon.fr/s?k=barri%C3%A8re+infrarouge+5mm+%C3%A9metteur+r%C3%A9cepteur+3+fils 1 × Support 4×AA avec interrupteur ON/OFF, couvercle et extrémités à broches — Support 4×AA à interrupteur, avec couvercle à clips et extrémités à broches de 0,1 po (2,54 mm) qui s’enfoncent directement dans la plaque d’essai (type Adafruit 830). Des piles alcalines neuves donnent environ 6,4 V, des piles à plat environ 4 V. La carte a besoin d’environ 4,4–6,5 V : en dessous, elle se comporte mal, alors change les piles avant d’en arriver là. https://www.amazon.fr/s?k=support+4+piles+AA+interrupteur+couvercle+broches+platine 1 × Support 3×AA avec interrupteur ON/OFF et couvercle — Support 3×AA à interrupteur, environ 4,5 V. Trois piles, jamais quatre : l’émetteur supporte 5,5 V au maximum. https://www.amazon.fr/s?k=support+3+piles+AA+interrupteur+couvercle 7 × Piles AA — Piles AA alcalines (LR6), ou piles AA NiMH à faible autodécharge (celles vendues « prêtes à l’emploi »). Même type et même marque dans chaque support, jamais mélangés. 4 piles NiMH seulement si ton régulateur n’est pas un AMS1117 (étape 2). https://www.amazon.fr/s?k=piles+AA+alcalines+lot+de+8 2 × Bornes à levier WAGO 221-412 — Bornes à levier 2 conducteurs, une pour le rouge et une pour le noir. Si un fil est très fin, dénude 11 mm et replie-le sur lui-même pour qu’il remplisse la borne. (Variante : si le bloc et l’émetteur ont tous deux des extrémités à broches, 2 cordons Dupont femelle-femelle.) https://www.amazon.fr/s?k=WAGO+221-412+borne+%C3%A0+levier+2+conducteurs 1 × Résistance 220 Ω — 220 Ω, 1/4 W, traversante https://www.amazon.fr/s?k=r%C3%A9sistance+220+ohm+1%2F4W 1 × DEL — DEL 5 mm, toute couleur, traversante https://www.amazon.fr/s?k=LED+5mm+assortiment 1 × Module buzzer actif — Module buzzer actif (son intégré), 3 broches S / + / −, 3,3–5 V, sonne quand S est HIGH. Teste-le à l’étape 11 : certains modules fonctionnent à l’envers. https://www.amazon.fr/s?k=module+buzzer+actif+3+broches 1 × Bouton poussoir — Bouton tactile 6 mm, 4 pattes https://www.amazon.fr/s?k=bouton+poussoir+tactile+6mm 1 × Plaque d’essai — Format complet 830 points (accueille un ESP32 38 broches) https://www.amazon.fr/s?k=platine+d%E2%80%99essai+830+points 1 lot × Fils de connexion — Mâle-mâle, 10–20 cm environ, 20 fils ou plus. Seulement si ton support 4×AA a des fils nus au lieu de broches : 10 cm de fil rigide 22 AWG, un rouge et un noir. https://www.amazon.fr/s?k=c%C3%A2bles+dupont+m%C3%A2le+m%C3%A2le 1 × Câble USB données — Câble données (pas charge seule), adapté au port de la carte. Pour la programmation seulement : l’alarme elle-même fonctionne sur piles. https://www.amazon.fr/s?k=c%C3%A2ble+USB+data+micro+USB 1 × Ordinateur avec Arduino IDE — Arduino IDE 2.x + « esp32 by Espressif » 3.3.x (téléchargement gratuit sur arduino.cc) 1 × Ruban adhésif — Ruban double face, ruban de masquage ou pâte adhésive (repositionnable) https://www.amazon.fr/s?k=ruban+double+face+repositionnable 1 × Règle ou mètre ruban (facultatif) — N’importe lequel https://www.amazon.fr/s?k=m%C3%A8tre+ruban 1 × Étiquettes autocollantes et un stylo — N’importe lesquelles https://www.amazon.fr/s?k=%C3%A9tiquettes+autocollantes 1 × Multimètre (facultatif) — Multimètre numérique de base https://www.amazon.fr/s?k=multim%C3%A8tre+num%C3%A9rique 1 × Plaque perforée à motif de plaque d’essai, format complet (Rends-la permanente) — Format complet, mêmes rangées, mêmes bandes de 5 trous et mêmes rails que la plaque d’essai (type Adafruit Perma-Proto Full-sized 1606 : 157 × 51 mm, 3 trous de fixation). Format complet, pas demi, pour que le plan se copie 1 pour 1. https://www.amazon.fr/s?k=platine+Perma-Proto+format+complet 2 barrettes : 1×40 + 1×20 × Barrette femelle, 2,54 mm (Rends-la permanente) — Simple rangée, pas de 2,54 mm, broches longues. La 1×40 donne les deux rangées de 19 trous pour l’ESP32, la 1×20 donne la rangée de 3 trous du buzzer (H3). Coupe à la pince coupante ; tu perds un trou à chaque coupe. https://www.amazon.fr/s?k=barrette+femelle+1x40+2.54mm 1 × 2 pôles, 1 × 3 pôles × Borniers à vis, pas de 5,0 / 5,08 mm (Rends-la permanente) — Pour circuit imprimé, entrée de fil vers l’extérieur (type KF301 / DG301). https://www.amazon.fr/s?k=bornier+%C3%A0+vis+5.08mm+2+broches+3+broches 1 lot × Fil de câblage rigide, 22 AWG, plusieurs couleurs (Rends-la permanente) — Isolé, rouge, noir, jaune, orange, vert, bleu. https://www.amazon.fr/s?k=fil+rigide+22+AWG+kit+couleurs 1 bobine × Soudure sans plomb, avec flux (Rends-la permanente) — 0,8 mm, par exemple Sn99,3/Cu0,7 ou SAC305. https://www.amazon.fr/s?k=soudure+sans+plomb+flux+0.8mm 6 à tête fraisée M3 × 10, 3 à tête cylindrique M3 × 6–8 × Vis M3 (Rends-la permanente) — Tête fraisée : 4 pour le couvercle, 2 pour la trappe des piles. Tête cylindrique : 3 pour tenir la plaque sur ses entretoises imprimées (du M2,5 convient aussi). https://www.amazon.fr/s?k=vis+M3+entretoises+assortiment 1 × Fer à souder avec support et réglage de température (Rends-la permanente) — Réglable, 325–375 °C https://www.amazon.fr/s?k=fer+%C3%A0+souder+r%C3%A9glable+temp%C3%A9rature+support 1 × Multimètre (Rends-la permanente) — Testeur de continuité, tension continue, test de diode https://www.amazon.fr/s?k=multim%C3%A8tre+num%C3%A9rique+continuit%C3%A9 1 × Lunettes de protection (Rends-la permanente) — N’importe quelle paire transparente https://www.amazon.fr/s?k=lunettes+de+protection+transparentes 1 × Troisième main ou support de plaque (Rends-la permanente) — N’importe lequel https://www.amazon.fr/s?k=troisi%C3%A8me+main+support+circuit+imprim%C3%A9 1 × Pince coupante et pince à dénuder (Rends-la permanente) — N’importe lesquelles https://www.amazon.fr/s?k=pince+coupante+pince+%C3%A0+d%C3%A9nuder 1 × Petit ventilateur avec filtre (ou fenêtre ouverte) (Rends-la permanente) (facultatif) — N’importe lequel https://www.amazon.fr/s?k=extracteur+de+fum%C3%A9e+soudure+ventilateur
Sources
Voir les 14 sources
- Adafruit, IR Break Beam Sensors guide (wiring, power, sunlight, no shared power or ground between the halves)
- Adafruit product 2168, IR break-beam sensor, 5 mm LEDs (3.3–5.5 V, emitter 10 mA at 3.3 V and 20 mA at 5 V, open-collector receiver)
- Adafruit product 830, 4×AA holder with on/off switch (voltages, dimensions, pin ends)
- Adafruit product 1606, Perma-Proto full-sized breadboard PCB (157 × 51 mm, mounting holes)
- Espressif, ESP32-DevKitC V4 schematic (regulator AMS1117-3.3, 22 µF / 10 V input capacitor, power LED)
- Espressif, ESP32-DevKitC V4 user guide (power options: only one at a time)
- Espressif, ESP32-DevKitC V4 dimensions
- Espressif, ESP32 datasheet (3.6 V maximum, 3.0 V minimum, deep-sleep and Wi-Fi currents, pull-up)
- ESP-IDF, Sleep modes (wake-up sources, RTC pull-ups)
- Arduino-ESP32, Deep sleep API
- SparkFun, How to Solder: Through-Hole Soldering (temperature, glasses, helping hands)
- Adafruit, Guide to Excellent Soldering (ventilation)
- Arduino docs, digitalRead()
- Arduino docs, pinMode() and INPUT_PULLUP
Pas encore sourcé : Estimations, non sourcées : durée de vie des piles et capacités des AA, la limite basse de 4,4 V, la section de fil de la WAGO 221-412, la position des trous de la Perma-Proto. À mesurer sur ton montage.
Imprimer la fiche Imprimer la fiche bilan du projet
Une version prête à imprimer : liste des pièces à cocher, tableau et schéma de câblage, chaque étape avec son image.
Tu l’as construit ?
Je l’ai construit
Bientôt : un simple compteur anonyme de montages. Rien n’est collecté pour l’instant.