English

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.

À testerPas encore monté par nous : code compilé, circuit et sécurité vérifiés. Tu le montes à tes risques ; les plus jeunes, avec un adulte.
Imprimer la fiche

Fais ces leçons d’abord

  1. Tension, courant, résistancedisponiblepourquoi la résistance, comment on mesure une tension (U).
  2. Ton premier circuitdisponiblequels trous de la plaque d’essai sont reliés, comment repérer un court-circuit.
  3. Les DEL et la bonne résistancedisponibledans quel sens brancher la DEL, pourquoi 220 Ω devant elle.
  4. Ton premier programme : connecter ton ESP32 et y envoyer du codedisponibleinstaller l’IDE Arduino, connecter la carte, téléverser un programme.
  5. 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 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.
  • Le rail rouge, c’est 3V3 seulement. Le bloc 4×AA va sur la rangée de la broche 5V et 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 5V doit 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.

La liste d’achats est en bas de la page.

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.

Comment marche le faisceau Deux rangées. En haut, faisceau libre : l'émetteur IR envoie un faisceau infrarouge invisible vers le récepteur IR. Dans le récepteur, l'interrupteur de sortie reste ouvert, le fil OUT est libre et la résistance de rappel de l'ESP32 maintient GPIO32 à 3,3 volts : la broche lit HIGH et le moniteur série affiche clear. En bas, faisceau coupé : une main bloque le faisceau. L'interrupteur de sortie du récepteur se ferme et tire OUT vers la masse : GPIO32 lit LOW, environ 0 volt, et le moniteur affiche broken. Si l'alarme est armée, le buzzer sonne. Dans le code, BROKEN vaut LOW ; si ton module fait l'inverse, mets HIGH. Garde les modules à l'abri du soleil direct : il contient de l'infrarouge et peut déclencher de fausses alarmes. FIG. 3 — COMMENT MARCHE LE FAISCEAUFaisceau libreémetteur IRrécepteur IRinfrarouge, invisibledans le récepteurouvert : OUT libreOUTESP323V3rappelGPIO32HIGHU ≈ 3,3 V"clear"Tout est calme.Faisceau coupéémetteur IRrécepteur IRdans le récepteurfermé : OUT → GNDOUTESP323V3rappelGPIO32LOWU ≈ 0 V"broken"Armée ? Le buzzer sonne.const int BROKEN = LOW;Inversé avec ton module ? Remplace LOW par HIGH (étape 10).Évite le soleil direct : il contient de l'infrarouge et peut déclencher de fausses alarmes.
Touche le schéma pour l’ouvrir en plein écran.

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.

Câblage mission 01, vue plaque d'essai (sur piles) Plaque d'essai complète vue de dessus, rangée 1 à gauche. Les broches de l'ESP32 sont dans les colonnes i et a, rangées 1 à 19, port USB en rangée 1 ; la colonne j reste libre : chaque broche côté j a un trou libre. Quinze fils numérotés comme dans la fiche. 1 rouge de 3V3 (j19) au rail rouge de droite, réservé au 3V3 ; 2 noir de GND (j6) au rail bleu de droite, le rail GND. L'ESP32 a son propre bloc 4×AA à interrupteur, étiqueté ESP32 4×AA : le fil 3, l'embout rouge du bloc, va en j1, le trou à côté de la broche 5V, jamais dans un rail rouge ; le fil 4, l'embout noir, dans le rail bleu de droite. Le récepteur IR : 5 rouge au rail 3V3, 6 noir au rail GND, 7 blanc ou jaune (OUT) en j13, à côté de GPIO32. 8 orange de GPIO25 (j11) à la broche S du buzzer (j39), 9 rouge du rail 3V3 au plus du buzzer (j40), 10 noir du moins du buzzer (j41) au rail GND. 11 vert de GPIO26 (j10) à la rangée 26 (b26), la bande de R1 : la résistance de 220 ohms R1 est couchée de d26 à d30 ; la patte longue de la DEL est en b30, la courte en b31 ; 12 noir de d31 au rail bleu de gauche, vers la rangée 34. 13 bleu de GPIO27 (j9) à j44 ; le bouton est à cheval sur la rainure en e44, f44, e46 et f46 ; 14 noir de a46 au rail bleu de gauche. 15 noir relie le rail bleu de gauche au rail bleu de droite. L'émetteur n'est pas sur la plaque : sur la porte, ses fils rouge et noir rejoignent les fils rouge et noir de son propre bloc 3×AA à interrupteur, étiqueté ÉMETTEUR 3×AA, par deux bornes à levier. Aucun fil ne va de l'émetteur à l'ESP32. FIG. 1 — VUE PLAQUE D'ESSAI (DE DESSUS)+−−+jihgfedcba+−−+jihgfedcba253035404555ESP325VCMDD3D213GND1214GPIO27GPIO26GPIO2533GPIO323534VNVPEN3V3USB · rangée 1S+−+AB++++ONOFFESP32 4×AA34j1 = 5VIROUT+−756Récepteur IRsur le cadre ou le mur, câbléfil OUT : blanc ou jauneÉmetteur : sur la porte,avec son propre bloc (cadre E).8GPIO25 → S du buzzer1113GPIO27 → bouton A12910121415module buzzerR1 220 ΩDELboutonRails de droite (en haut ici) : + rouge = 3V3 seulement · − bleu = GND.Rails de gauche (en bas ici) : − bleu = GND, relié par le fil 15 · + rouge inutilisé.DEL : patte longue (+) en b30, courte en b31.Rangée 1 vers toi, la colonne j est à droite.Liste des fils#COULEURDEVERS1rougeESP32 3V3 (j19)rail 3V3 (+), à droite2noirESP32 GND (j6)rail GND (−), à droite3rougebloc ESP32 4×AA rouge (+)j1 (5V) · pas un rail rouge4noirbloc ESP32 4×AA noir (−)rail GND (−), à droite5rougerécepteur rouge (+)rail 3V3 (+)6noirrécepteur noir (−)rail GND (−)7jaunerécepteur OUT (blanc/jaune)GPIO32 (j13)8orangeESP32 GPIO25 (j11)buzzer S (j39)9rougerail 3V3 (+)buzzer + (j40)10noirbuzzer − (j41)rail GND (−)11vertESP32 GPIO26 (j10)rangée 26 (b26), bande de R112noirrangée − de la DEL (d31)rail GND (−), à gauche13bleuESP32 GPIO27 (j9)bouton patte A (j44)14noirbouton patte B (a46)rail GND (−), à gauche15noirrail GND de gauche (−)rail GND de droite (−)Eémetteur rouge / noirÉMETTEUR 3×AA, 2 WAGO3–7 et E sont les fils des pièces. E ne va jamais à l'ESP32.ESur la porte : émetteur + son propre bloc+++ONOFFÉMETTEUR 3×AAIRémetteur IR2 WAGO : rouge-rouge, noir-noirAucun fil vers l'ESP32 · aucun à travers l'espace de la porte.Règles d'alimentationESP32 4×AA (3, 4) : rouge → j1, rangée du 5V.Jamais sur un rail rouge : c'est le 3V3.ÉMETTEUR 3×AA (E) : l'émetteur seulement.Jamais 4 piles sur l'émetteur (5,5 V max).OUT du récepteur (7) → GPIO32 seulement. Jamais 5 V.Bloc sur OFF avant l'USB et avant de bouger un fil.
Touche le schéma pour l’ouvrir en plein écran.
Câblage mission 01, schéma Schéma IEC, version sur piles. En haut à gauche : le bloc ESP32 4×AA, avec son interrupteur, alimente la broche 5V de l'ESP32 par le fil 3 ; son côté moins, le fil 4, va à la masse. Sur la carte ESP32, un régulateur (AMS1117 sur la carte d'origine) transforme la tension des piles en 3,3 volts pour la puce et la broche 3V3. La broche 3V3 alimente une ligne qui fournit le récepteur IR (fils 5 et 6) et le buzzer (fils 9 et 10). Dans l'ESP32, une résistance de rappel activée par le code (INPUT_PULLUP) relie GPIO32 à 3,3 volts. Le fil OUT 7 du récepteur va sur GPIO32 ; dans le récepteur, un transistor à collecteur ouvert peut seulement tirer ce fil vers la masse, quand le faisceau infrarouge est coupé. L'émetteur est un circuit à part, sur le battant de la porte : son propre bloc ÉMETTEUR 3×AA à interrupteur, environ 4,5 volts, alimente la DEL infrarouge par deux bornes à levier (E) ; aucun fil ne le relie à l'ESP32 ni ne traverse l'espace de la porte. GPIO25 commande la broche S du module buzzer (fil 8). GPIO26 passe par une résistance de 220 ohms vers la DEL, puis la masse (fils 11 et 12). GPIO27 va à un bouton poussoir dont l'autre côté est à la masse (fils 13 et 14), lui aussi avec le rappel interne. FIG. 2 — SCHÉMA (SYMBOLES IEC)+−bloc ESP32 4×AAON/OFF4.0–6.4 V34Dans la broche 5V seulement.Le régulateur de la carte fait le 3,3 V.Jamais sur la ligne 3V3 (3,6 V max).5V3.3 V REGAMS1117ESP32DevKit3V3GPIO32GPIO25GPIO26GPIO27GNDrappel interne(INPUT_PULLUP)3V3récepteur IROUT = collecteur ouvert+OUT−S+−3V3buzzer(actif)220 ΩDELboutonGPIO32 et GPIO27 utilisent le rappel interne : au repos = HIGH.espace de la porteseul le faisceau passe, aucun filcôté cadrecôté battant+−émetteur IRDEL IR−+≈4.5 VON/OFFWAGOÉMETTEUR 3×AA(son propre bloc, sur la porte)faisceau IR(lumière invisible)12567EE891011121314Le fil 15 (plaque seulement) relie les deux rails GND : une seule masse.
Touche le schéma pour l’ouvrir en plein écran.
Voir les 16 fils et le tableau des broches

Liste des fils

#CouleurDeVers
1 rougeESP32 3V3 (trou j19)rail 3V3 (rouge + à droite)
2 noirESP32 GND (trou j6)rail GND (bleu − à droite)
3 rougebloc 4×AA rouge (+)le trou à côté de la broche 5V de l’ESP32 (j1). Jamais un rail rouge.
4 noirbloc 4×AA noir (−)rail GND (bleu − à droite)
5 rougerécepteur IR rouge (+)rail 3V3
6 noirrécepteur IR noir (−)rail GND
7 jaunerécepteur IR OUT (blanc ou jaune)GPIO32 (j13 ; rappel vers 3V3 par le code, jamais vers 5 V)
8 orangeESP32 GPIO25 (j11)buzzer S (j39)
9 rougerail 3V3buzzer + (j40)
10 noirbuzzer − (j41)rail GND
11 vertESP32 GPIO26 (j10)résistance 220 Ω, patte 1 (b26)
12 noirpatte courte de la DEL (−)rail GND
13 bleuESP32 GPIO27 (j9)bouton patte A (j44)
14 noirbouton patte B (en diagonale)rail GND
15 noirrail bleu de gaucherail bleu de droite (liaison de GND)
E rouge / noirfils de l’émetteurfils 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

BrocheRelié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)
3V3rail 3V3 : récepteur IR +, buzzer +Sortie d’alimentation (3
GNDrail GND : − du bloc, récepteur IR −, buzzer −, DEL, boutonMasse
GPIO32OUT du récepteur IREntrée avec résistance de rappel interne (LOW = faisceau coupé). Réveille la carte du sommeil profond.
GPIO25Buzzer SSortie
GPIO26220 Ω → DELSortie
GPIO27Bouton (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.

  1. Étape 1 · Sors tes pièces.

    Vérifie : Toutes les pièces de la liste sont sur la table.

  2. É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.

    Étape 2 : vérifie ta carte Vue de dessus d'une carte ESP32 DevKitC, port USB à gauche. À côté de la broche 5V, près de l'USB, se trouve une petite puce noire avec trois pattes d'un côté et une grande languette plate de l'autre : le régulateur. Une loupe montre son marquage, AMS1117. Une deuxième flèche montre la broche 5V et l'inscription 5V imprimée à côté sur la carte. En dessous, deux cas : AMS1117, 4 piles alcalines ou 4 piles NiMH conviennent ; une puce minuscule à 5 pattes, ou sans marquage, 4 piles NiMH seulement. Suis toujours les inscriptions imprimées sur ta propre carte : l'ordre des broches peut changer sur les clones. 2×1USB5VGND272625323V3ESP32AMS11173.3régulateur : lis son marquagebroche 5V + son inscriptionAMS11174 piles alcalines ou 4 NiMHconviennent!minuscule, 5 pattes ou sans marquage4 piles NiMH seulement(tension plus basse)Clones : l'ordre des broches peut changer. Suis toujours les inscriptions de ta carte.

    Vérifie : Tu sais quelle puce régule ta carte, et tu as trouvé les broches 5V, GND, 3V3, 25, 26, 27 et 32 grâce à leurs inscriptions.

  3. É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.

    Étape 3 : place l'ESP32 L'ESP32 est enfoncé à cheval sur la rainure centrale, broches dans les colonnes a et i, rangées 1 à 19, port USB en rangée 1, antenne vers la rangée 20. La broche 5V arrive en i1. La colonne j reste libre : chaque broche côté j a un trou libre, surligné. Les rangées 20 à 23 sont hachurées : la zone de l'antenne, laisse-les vides. 3×1×1830+−5VCMD123j : librei : broches5V en i1 · USB en rangée 1rangées 20–23 : zone de l'antenne, vides

    Vérifie : La carte est à plat, aucune broche n’est tordue, et la broche 5V est à la rangée 1, colonne i.

  4. Étape 4 · Les rails.

    Relie la broche 3V3 (trou j19) au rail rouge (+) de droite et la broche GND (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.

    Étape 4 : les rails Trois fils. Le fil 1 rouge de la broche 3V3 (j19) au rail rouge de droite, qui devient le rail 3V3 : 3V3 seulement. Le fil 2 noir d'une broche GND (j6) au rail bleu de droite, le rail GND. Le fil 15 noir, vers la rangée 50, relie le rail bleu de gauche au rail bleu de droite : les deux rails bleus sont à la masse. 4×3+−1215rail rouge : 3V3 seulementrail GND (−)rail GND de gauche (−)

    Vérifie : Fil rouge sur le rail rouge, fil noir sur le rail bleu, et rien d’autre ne touche encore le rail rouge.

  5. Étape 5 · Câble le récepteur. Demande de l’aide

    Bloc et USB éteints. Fil rouge du récepteur au rail 3V3, fil noir au rail GND, fil blanc ou jaune (OUT) sur GPIO32 (trou j13). Pas de 5 V.

    Étape 5 : câble le récepteur (demande de l'aide) Bloc et USB débranchés. Le récepteur IR a trois fils. Le fil 5 rouge va dans le rail 3V3, le fil 6 noir dans le rail GND, le fil 7 blanc ou jaune (OUT) en j13, le trou à côté de GPIO32. Rien ne va au 5 V. 5×1OFFIR+−567GPIO32 · j13rail 3V3 (+)rail GND (−)récepteur IROUT → GPIO32 seulement · pas de 5 V

    Vérifie : Une personne expérimentée (ou toi, deux fois) a contrôlé que le rouge est sur 3V3 et OUT seulement sur GPIO32.

  6. É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.

    Étape 6 : alimente l'ESP32 par son bloc (demande de l'aide) Le bloc ESP32 4×AA est derrière le bout gauche de la plaque, interrupteur sur OFF. Le fil 3, son embout rouge, va en j1 : le trou à côté de la broche 5V, en rangée 1. Le fil 4, son embout noir, va dans le rail bleu de droite. Une croix rouge marque le rail rouge : le fil rouge du bloc n'y va jamais, c'est le 3V3. Une loupe montre j1 à côté de la broche 5V. 6×1OFF×4AA×1+++++−34jamais le rail rougeESP32 4×AAinterrupteur sur OFF5Vj1i1rouge → j1, à côté du 5V

    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é.

  7. É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.

    Étape 7 : prépare le bloc de l'émetteur (demande de l'aide) Le bloc ÉMETTEUR 3×AA, interrupteur sur OFF, étiqueté. Deux bornes à levier WAGO le relient à l'émetteur IR. Borne de gauche, levier ouvert : le fil rouge du bloc et le fil rouge de l'émetteur, dénudés sur environ 11 millimètres, sont enfoncés dans ses deux entrées, puis le levier est fermé. Borne de droite, levier fermé : les deux fils noirs, reliés de la même façon. Tire doucement sur chaque fil. Rouge avec rouge, noir avec noir. Aucun fil ne va à l'ESP32. 7×1OFF×3AA×2×1+++ONOFFÉMETTEUR 3×AAIRémetteur IRlevier ouvert : enfoncelevier fermé : tire doucementdénude environ 11 mmEEsur OFF · piles selon les +Rouge avec rouge, noir avec noir · aucun fil 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.

  8. É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.

  9. É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.

  10. É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, remplace LOW par HIGH, téléverse à nouveau.

    Vérifie : « clear » sans rien dans le passage, « broken » avec ta main.

  11. Étape 11 · Ajoute le buzzer.

    Tout sur OFF et débranché. Buzzer S sur GPIO25, + 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 : change BUZZER_ON dans le code.

    Étape 11 : ajoute le buzzer Tout éteint et débranché d'abord. Les trois broches du module buzzer vont en h39 (S), h40 (+) et h41 (−), selon les inscriptions du module. Le fil 8 orange va de GPIO25 (j11) à j39, le fil 9 rouge du rail 3V3 à j40, le fil 10 noir de j41 au rail GND. 11×1×3OFFIR+−8910S · h39+ · h40− · h41

    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.

  12. Étape 12 · Ajoute la DEL.
  13. Étape 13 · Ajoute le bouton.
  14. É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.

    Étape 14 : colle l'émetteur, son bloc et le récepteur sur la porte Vu de dessus, deux moments. Porte fermée : l'émetteur IR et son bloc ÉMETTEUR 3×AA sont collés sur le battant, côté poignée ; le récepteur IR est collé sur le mur ou le cadre juste à côté, à 15 à 20 centimètres, lentilles face à face et alignées. Le faisceau est intact et le moniteur série affiche clear. La porte s'ouvre : le battant tourne sur ses gonds, l'émetteur s'éloigne, le récepteur perd le faisceau : le moniteur affiche broken et, si l'alarme est armée, elle se déclenche. Seul le récepteur est câblé à l'ESP32 ; aucun fil ne traverse l'espace de la porte. Garde les modules à l'abri du soleil direct : il contient de l'infrarouge et peut déclencher de fausses alarmes. Le même principe marche pour un placard, un tiroir ou un couvercle de boîte. 14×15 mm×15 mm×1×1VU DE DESSUSPorte fermée : faisceau intactESP3215–20 cmbattantcadre / murPorte ouverte : faisceau perdu → alarmeESP32battantcadre / murÉMETTEUR 3×AAémetteurrécepteurgonds115200clearclear115200clearbrokenmême hauteur, scotchésÉvite le soleil direct : il contient de l'infrarouge et peut déclencher de fausses alarmes.Même principe pour un placard, un tiroir ou un couvercle de boîte.

    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.

  15. É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.

    Étape 15 : aligne-la porte fermée Pour l'alignement, l'ESP32 est alimenté par l'USB : un câble USB entre dans son port en rangée 1, depuis l'ordinateur, et le moniteur série est ouvert. Le bloc ESP32 4×AA reste branché mais sur OFF : jamais bloc allumé et USB en même temps. Le bloc de l'émetteur, sur la porte, est allumé. 15×1données×1++++IR+−34ESP32 4×AA : OFFUSB branché → bloc ESP32 sur OFFÉMETTEUR 3×AA sur la porte : ON

    Vérifie : « clear » reste stable porte fermée, même si tu tapotes doucement la porte.

  16. É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.

  17. É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.

    Étape 17 : teste comme un espion Quatre moments, de gauche à droite. 1 : USB débranché, le bloc ESP32 est allumé : la DEL clignote deux fois. 2 : appuie sur le bouton : la DEL clignote une fois par seconde pendant 10 secondes, le temps de sortir et de fermer la porte. 3 : un long éclair : l'alarme est armée. 4 : la porte s'ouvre, vue de dessus : le récepteur perd le faisceau, le buzzer sonne, la DEL clignote vite. Appuie sur le bouton : l'alarme s'arrête et se désarme, deux clignotements courts. 17ON1bloc sur ON2appuie : 10 s pour sortir3long éclair : arméON10 s4la porte s'ouvre : alarmeESP32DEL rapide + buzzer, 30 sAppuie sur le bouton : ça s'arrête, deux clignotements = désarmé

    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 dit la DEL Carte de pictogrammes, neuf lignes. Chaque ligne montre une courte frise de la DEL, des blocs verts quand elle est allumée, et ce que cela veut dire. 1 : allumée quand le faisceau est coupé, pendant les 90 premières secondes après l'allumage ou un reset : le mode test ; un bip court du buzzer termine le test. 2 : deux clignotements courts : allumé, ou désarmé, rien ne surveille. 3 : un clignotement par seconde pendant 10 secondes : armement, 10 secondes pour sortir, appuie encore pour annuler. 4 : un long éclair : armé, le faisceau était libre. 5 : un petit éclair toutes les 30 secondes : armé et endormi, chaque réveil donne un petit éclair. 6 : clignotement rapide pendant 2 secondes : le faisceau est déjà coupé, il reste désarmé, vérifie l'émetteur. 7 : un clignotement par seconde pendant 60 secondes au plus, puis clignotement rapide : la porte était encore ouverte à la fin du décompte de 10 secondes ; il reste désarmé. 8 : clignotement rapide avec le buzzer : alarme, appuie sur le bouton pour l'arrêter. 9 : un petit éclair toutes les 5 secondes : après une alarme, il attend que la porte se ferme, puis se réarme. Hors mode test, pas de lumière fixe : la carte dort entre les éclairs pour économiser les piles. CE QUE DIT LA DELCe que dit la DEL190 sAllumée quand le faisceau est coupé90 premières s après allumage ou reset : test.Un bip court du buzzer termine le test.2Deux clignotements courtsAllumé, ou désarmé.Rien ne surveille.310 s1 clignotement par seconde, 10 sArmement : 10 s pour sortir.Appuie encore pour annuler.4Un long éclairArmé.Le faisceau était libre.530 sPetit éclair toutes les 30 sArmé et endormi.Chaque réveil = un petit éclair.62 sClignotement rapide, 2 sFaisceau déjà coupé : reste désarmé.Vérifie l'émetteur : ON ? visé ? porte fermée ?760 s1 clignotement par seconde, puis rapidePorte encore ouverte après les 10 s : attend 60 s.Puis clignotement rapide : reste désarmé.830 sClignotement rapide + buzzerAlarme !Appuie sur le bouton pour l'arrêter.95 sPetit éclair toutes les 5 sAprès une alarme : attend que la porte se ferme.Porte fermée, faisceau revenu : il se réarme.Hors test, pas de lumière fixe : la carte dort entre les éclairs pour économiser les piles.
Touche le schéma pour l’ouvrir en plein écran.
Ce que tu voisCe 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 clignotementsCarte qui vient d’être allumée, ou alarme désarmée. Rien ne surveille.
Un clignotement par seconde pendant 10 sArmement en cours. Tu as 10 secondes pour sortir et fermer la porte. Rappuie sur le bouton pour annuler.
Un long éclairArmée. Le faisceau était libre et l’alarme surveille.
Un minuscule éclair toutes les 30 sArmé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éeLe 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éeLa 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 buzzerAlarme ! Elle sonne 30 secondes. Appuie sur le bouton pour l’arrêter tout de suite.
Un minuscule éclair toutes les 5 sAprè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 ?

BlocAutonomieRemarques
Boîtier ESP32, 4×AA alcalinesenviron 10–14 joursPresque 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×AAenviron 6 jours s’il reste allumé en permanence2–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)

  1. 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 sources
  2. Bloc 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 : BROKEN seulement si l’étape 10 te l’a demandé ; BUZZER_ON seulement si l’étape 11 te l’a demandé ; les nombres si tu veux

    Voir 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;
  3. 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");
    }
  4. 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");
    }
  5. 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");
    }
  6. 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");
    }
  7. 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
    }
  8. 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 : rien

    Voir 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é ?

À tester

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
Vérifie les marques + / − des piles, que le fil rouge est dans la rangée 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
La carte est peut-être en sommeil profond : appuie sur le bouton. Vérifie que la patte longue de la DEL est du côté de la résistance.
Bloqué sur « broken » porte fermée
Rapproche les deux modules, vise à nouveau (le faisceau est étroit), dégage les lentilles de la moulure, et vérifie que le bloc de l’émetteur est sur ON avec des piles neuves et que le récepteur est à l’abri du soleil direct.
L’émetteur s’éteint au bout de quelques jours
Son bloc 3×AA est vide. Il dure environ 6 jours s’il reste allumé : éteins-le quand l’alarme n’est pas armée, et change les 3 piles ensemble.
Le buzzer sonne tout le temps (ou jamais)
Ton module buzzer fonctionne peut-être à l’envers : change BUZZER_ON dans le code (étape 11).
L’alarme se déclenche toute seule
Le soleil direct sur le récepteur peut déclencher de fausses alarmes : déplace-le ou mets-le à l’ombre.
La carte ne se réveille pas quand j’ouvre la porte
Vérifie le fil 7 (OUT vers 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)
Vérifie le nom et le mot de passe du Wi-Fi (réseau 2,4 GHz), et que le sujet du code est exactement celui de l’appli. Des piles faibles peuvent aussi la bloquer : remplace-les. Si la carte redémarre pendant une alerte, elle revient désarmée (deux clignotements) : change les piles.

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
  1. É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.

  2. É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.

  3. É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).

  1. 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 message

    Voir 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;
    }

Télécharger le croquis de l’alerte téléphone (.ino)

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.
Sécurité des piles Quatre pictogrammes de sécurité des piles. 1 : ne mélange jamais : une pile alcaline à côté d'une pile NiMH, barrées ; même type, même âge et même marque dans un boîtier, change toutes les piles en même temps. 2 : polarité : une pile entre dans le boîtier, son plus en face du repère plus. 3 : bloc sur OFF avant l'USB : l'interrupteur du boîtier sur OFF, puis la prise USB. 4 : étiquette les blocs : deux boîtiers avec des étiquettes, ESP32 4×AA et ÉMETTEUR 3×AA ; le bloc de 4 piles est pour l'ESP32 seulement, celui de 3 piles pour l'émetteur seulement. SÉCURITÉ DES PILES1Ne mélange jamaisMême type, âge et marque.Change toutes les piles ensemble.+ALK+NiMH+ALK+ALK2Suis les repèresLe + de la pile sur le repère +dans le boîtier.++++3OFF avant l'USBBloc sur OFF avant l'USBet avant de bouger un fil.ONOFF124Étiquette les deux blocs4×AA → ESP32 seulement.3×AA → émetteur seulement (5,5 V max).++++ONOFFESP32 4×AA+++ONOFFÉMETTEUR 3×AA
Touche le schéma pour l’ouvrir en plein écran.
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

Mission 01, version soudée : plan de la plaque à pastilles Vue de dessus d'une plaque à pastilles format plaque d'essai, pleine taille, 157 sur 51 millimètres, rangée 1 au bord USB à gauche, rails de droite en haut. Deux barrettes femelles de 19, H1 en a1 à a19 et H2 en i1 à i19, reçoivent l'ESP32, qui s'enfiche et reste amovible ; son contour est en pointillés. J1, bornier à vis 2 pôles pour le bloc ESP32 4×AA, plus en h25, moins en h27. J2, bornier à vis 3 pôles pour le récepteur IR, plus en h31, moins en h33, OUT en h35. Leurs ouvertures font face au bord droit. H3, barrette femelle de 3 pour le module buzzer, S en h39, plus en h40, moins en h41. R1, 220 ohms, couchée de d26 à d30. D1, la DEL, patte longue en b30, courte en b31. SW1, le bouton, à cheval sur la rainure en e44, f44, e46 et f46. Quinze fils isolés côté composants : W1 rouge f1 à f25 ; W2 noir j27 au rail moins de droite ; W3 rouge j19 au rail plus de droite ; W4 noir j6 au rail moins de droite ; W5 rouge j31 au rail plus ; W6 noir j33 au rail moins ; W7 jaune g13 à f35 ; W8 orange h11 à f39 ; W9 rouge j40 au rail plus ; W10 noir j41 au rail moins ; W11 vert g10 à la rangée 26 (b26), bande de R1 ; W12 noir d31 au rail moins de gauche vers la rangée 34 ; W13 bleu f9 à h44 ; W14 noir a46 au rail moins de gauche ; W15 noir relie le rail moins de gauche au rail moins de droite en rangée 52. Zones interdites, en pointillés : rangées 20 à 23 pour l'antenne, et un cercle de 6 millimètres autour de chacun des trois trous de fixation dans la rainure. FIG. 3 — PLAN DE LA PLAQUE, VUE DE DESSUS (VERSION SOUDÉE)++−−−−++jihgfedcba1102030405060W1W2W3W4W5W6W7W8W9W10W11W12W13W14W15H2H1J1J2H3R1D1SW1antenne : rangées 20–23 libresPointillés : l'ESP32 s'enfiche dans H1/H2, USB au bord de la rangée 1.Cercles orange en pointillés : 6 mm libres autour de chaque trou de fixation. Rangées 20–23 : antenne, à laisser libres.Pièces et fils sur le dessus, soudures par-dessous. Soude tous les fils avant d'enficher l'ESP32.PiècesH1, H22 × barrette femelle 1×19a1–a19 · i1–i19J1bornier 2 pôles, ESP32 4×AA+ h25 · − h27J2bornier 3 pôles, récepteur+ h31 · − h33 · OUT h35H3barrette femelle 1×3, buzzerS h39 · + h40 · − h41R1220 Ω, couchéed26 → d30D1DEL 5 mm, à plat+ b30 · − b31SW1bouton 6 mme44 f44 e46 f46Fils (rigides 22 AWG, isolés)W1f1 → f25broche 5V → J1 +W2j27 → rail −J1 − → GNDW3j19 → rail +rail 3V3W4j6 → rail −rail GNDW5j31 → rail +récepteur +W6j33 → rail −récepteur −W7g13 → f35GPIO32 → OUT du récepteurW8h11 → f39GPIO25 → S du buzzerW9j40 → rail +buzzer +W10j41 → rail −buzzer −W11g10 → b26GPIO26 → rangée 26 (b26), bande de R1W12d31 → rail − gaucheDEL −W13f9 → h44GPIO27 → bouton (f44)W14a46 → rail − gauchebouton (e46) → GNDW15rail − gauche → rail − droitliaison GND, rangée 52Rails : le + du haut = 3V3 seulement. La ligne 5V (W1, J1 +)ne doit jamais le toucher : vérifie au multimètre.Plaque : type Perma-Proto pleine taille, 157 × 51 mm. Positiondes trous déduite de la fiche : mesure ta plaque.
Touche le schéma pour l’ouvrir en plein écran.

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

  1. É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.

  2. Étape P2 · Pose les supports de l’ESP32.
  3. É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).

    Permanent P3 : soude les borniers et le support du buzzer Vue de dessus de la plaque, rangées 21 à 45. En évidence : J1, bornier à vis 2 pôles, plus en h25, moins en h27 ; J2, bornier à vis 3 pôles, plus en h31, moins en h33, OUT en h35 ; H3, barrette femelle 1×3, S en h39, plus en h40, moins en h41. Les ouvertures des borniers font face au bord droit, vers les rails. P3×22 · 3×11×3×1++−−−−++jihgfedcba1102030405060+ h25− h27+ h31− h33OUT h35S h39+ h40− h41J1J2H3Ouvertures vers le bord droit (les rails)Chaque pièce bien à plat. Soude par-dessous.

    Vérifie : Chaque bornier est à plat sur la plaque, ouvertures tournées vers le bord droit.

  4. Étape P4 · Soude la résistance, la DEL et le bouton.
  5. É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 5V vers 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.

    Permanent P5 : soude les fils d'alimentation (W1 à W4) Vue de dessus de la plaque, rangées 1 à 30. Fils en évidence : W1 rouge de f1 à f25, de la broche 5V au plus de J1, dans la rainure, loin du trou de fixation ; W2 noir de j27 au rail moins de droite ; W3 rouge de j19 au rail plus de droite, le rail 3V3 ; W4 noir de j6 au rail moins de droite. W1 reste loin du rail plus. P5×422 AWG×1++−−−−++jihgfedcba1102030405060W1W2W3W4W1 (5V) va au + de J1 seulement, jamais près du rail +Fil isolé, à plat dessus, soudé par-dessous.

    Vérifie : W1 va vers J1 + et jamais près du rail +.

  6. Étape P6 · Soude les fils du récepteur (W5 à W7).
  7. Étape P7 · Soude les fils du buzzer (W8 à W10).
  8. Étape P8 · Soude les fils de la DEL et du bouton (W11 à W15).

    W11 vert : g10 → b26 (GPIO26 vers 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 (GPIO27 vers 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.

    Permanent P8 : soude les fils de la DEL et du bouton (W11 à W15) Vue de dessus de toute la plaque. Fils en évidence : W11 vert de g10, la rangée de GPIO26, à la rangée 26 (b26), la bande de R1 ; W12 noir de d31 au rail moins de gauche vers la rangée 34, en biais, loin de la DEL ; W13 bleu de f9, la rangée de GPIO27, à h44, la bande de la patte f44 du bouton ; W14 noir de a46, la bande de la patte e46, au rail moins de gauche ; W15 noir relie le rail moins de gauche au rail moins de droite en rangée 52. Les quinze fils sont posés ; les zones en pointillés restent libres. P8×522 AWG++−−−−++jihgfedcba1102030405060W11W12W13W14W15Les 15 fils posés · cercles et rangées 20–23 libres

    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.

  9. É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.

  10. É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).

    Permanent P10 : contrôles au multimètre avant la mise sous tension (demande de l'aide) Blocs sur OFF, ESP32 non enfiché. À gauche : le multimètre en mode continuité (bip), pointe rouge dans la douille i1, celle du 5V, pointe noire sur le rail plus de droite : il ne doit PAS biper. À droite, le test clé : bloc allumé, ESP32 toujours débranché, le multimètre en volts continus entre le rail plus et le rail moins doit lire 0 volt. S'il affiche la tension des piles, STOP : la ligne 5V touche le rail 3V3 et détruirait l'ESP32. P10×1++−−−−++jihgfedcba1102030405060i1 (5V)- - -))PAS DE BIPi1 (5V) ↔ rail +rail + ↔ rail − : pas de bip non plusTest cléBloc ON · ESP32 toujours débranché0.00Vrail + ↔ rail −0 V= c’est bonTension des piles ? STOP.Le 5V touche le rail 3V3 :cela détruirait l'ESP32.OFF, trouve le pont, répare.

    Vérifie : Chaque « pas de bip » est silencieux et chaque « bip » bipe.

  11. É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.

  12. Étape P12 · Enfiche l’ESP32.

    Bloc sur OFF. Enfiche l’ESP32 dans ses supports, côté USB à la rangée 1, broche 5V dans 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.

  13. É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.

  14. É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.

    Permanent P15 : mets-le dans le boîtier Vue éclatée du boîtier imprimé en 3D, vue de dessus en biais, pièces soulevées dans l'ordre du montage. En bas : le boîtier, la baie électronique devant et la baie des piles derrière, côté USB ; trois entretoises coniques au fond, une fente USB en U dans la paroi du bout avec PACK OFF en relief à côté, des fentes d'aération dans la paroi de la baie des piles. Au-dessus : la plaque soudée, l'ESP32 enfiché dans ses douilles, port USB vers la paroi du bout, tenue par trois vis M3 sur les entretoises. Derrière : le bloc 4×AA à interrupteur, étiqueté ESP32 4×AA, couvercle en haut, interrupteur côté USB ; ses fils rouge et noir passent par une encoche de la cloison jusqu'au bornier J1. Au-dessus du bloc : la trappe des piles avec une fenêtre sur l'interrupteur et des fentes d'aération, deux vis. En haut : le couvercle avec la fenêtre de la DEL au-dessus de la DEL, les trous du son au-dessus du buzzer et le long poussoir qui descend dans son tube au-dessus du bouton ; quatre vis. Le boîtier n'est pas étanche : laisse les fentes d'aération ouvertes. L'émetteur et son bloc 3×AA restent sur la porte, hors de ce boîtier. P15×9M3×14×AA×1ESP32 4×AAcouvercle : 4 vislong poussoir → boutonfenêtre de la DELtrous du sontrappe : fenêtre, 2 visbloc : interrupteur côté USBfils → J1 (encoche)plaque : 3 vis M3 sur les entretoisesfente USB · PACK OFF d'abordaérations : laisse ouvertPas étanche : ne bouche jamais les aérations

    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.

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 :

Mission 02 · Alarme laser

  • 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
  1. Adafruit, IR Break Beam Sensors guide (wiring, power, sunlight, no shared power or ground between the halves)
  2. 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)
  3. Adafruit product 830, 4×AA holder with on/off switch (voltages, dimensions, pin ends)
  4. Adafruit product 1606, Perma-Proto full-sized breadboard PCB (157 × 51 mm, mounting holes)
  5. Espressif, ESP32-DevKitC V4 schematic (regulator AMS1117-3.3, 22 µF / 10 V input capacitor, power LED)
  6. Espressif, ESP32-DevKitC V4 user guide (power options: only one at a time)
  7. Espressif, ESP32-DevKitC V4 dimensions
  8. Espressif, ESP32 datasheet (3.6 V maximum, 3.0 V minimum, deep-sleep and Wi-Fi currents, pull-up)
  9. ESP-IDF, Sleep modes (wake-up sources, RTC pull-ups)
  10. Arduino-ESP32, Deep sleep API
  11. SparkFun, How to Solder: Through-Hole Soldering (temperature, glasses, helping hands)
  12. Adafruit, Guide to Excellent Soldering (ventilation)
  13. Arduino docs, digitalRead()
  14. 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.

Pince ou touche deux fois pour zoomer, glisse pour changer de schéma.Molette avec Ctrl ou double-clic pour zoomer. Les flèches changent de schéma.