English

Projets · 08

Balise morse d’espion

Tape un message secret sur ton ordinateur et la balise le fait clignoter et sonner en vrai code Morse. Appuie sur le bouton pour devenir le radio, puis maintiens-le 3 secondes et la balise répète un message toute seule, même sur piles. Le câblage est celui de la leçon K2 : c’est le premier projet de code le plus rapide. Ensuite, si tu veux, envoie du Morse par radio entre deux cartes, lis-le avec un capteur de lumière, ou soude-le dans un petit boîtier.

À 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. Une DEL et sa résistance (E3)disponiblepourquoi la résistance de 220 Ω, comment on mesure une tension (U).
  2. Connecter et téléverser du code sur ton ESP32 (K1)disponibleinstaller le paquet de carte, téléverser un croquis, ouvrir le moniteur série.
  3. Entrées, sorties et si (K2)disponiblelire un bouton, allumer une DEL et un buzzer, prendre une décision. Cette mission reprend exactement le câblage de K2.

Tu peux commencer sans elles : les encadrés « Rappel » donnent l’idée en deux lignes. Si tu as déjà monté la leçon K2 (ou la mission 01), ta plaque est prête : passe à l’étape 8.

Niveau
Niveau 1un premier projet de code facile : sans soudure, même câblage que la leçon K2
Durée
Un après-midi1–2 h (montage de base). Chaque « Pour aller plus loin » ajoute 1–2 h. Version permanente : ajoute 2–3 h · estimation
Coût
—
Outils
Facilesmontage de base : ni soudure, ni outil électrique. La version permanente demande un fer à souder.
Demande de l’aide
1 étapeétape 15
Leçon d’abord
Les DEL et la bonne résistancedisponible

Basse tension seulement. USB (5 V) ou un bloc 4×AA, rien d’autre. Pas de secteur, et pas de laser : une DEL puissante fait la lumière de cette mission, et tu n’y ajoutes jamais de module laser.

La sécurité d’abord

Lis cet encadré avant de brancher quoi que ce soit.

  • Piles
  • Petites pièces
  • Basse tension seulement. USB (5 V) ou un bloc 4×AA, rien d’autre. Pas de secteur, et pas de laser : une DEL puissante fait la lumière de cette mission, et tu n’y ajoutes jamais de module laser.
  • Logique 3,3 V seulement. L’ESP32 fonctionne en 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.
  • 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 la balise 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.
  • N’envoie pas de SOS là où il pourrait sembler réel. Pas de SOS (ni aucun signal de détresse) fait clignoter par une fenêtre la nuit, près de l’eau ou d’une route, ni sur une vraie radio. C’est un signal de jeu : pour les essais, utilise des mots comme HELLO ou OK.
  • Lumière clignotante : à la vitesse par défaut, la DEL clignote plusieurs fois par seconde. Si une personne près de toi est sensible aux lumières clignotantes (par exemple l’épilepsie photosensible), n’utilise pas la DEL près d’elle. Garde-la hors de la ligne de vue directe de toute personne qui te le demande, et reste à la vitesse par défaut.
  • Buzzer : fais court dans les lieux partagés (la commande /quiet le coupe, la DEL continue). Ne tiens jamais le buzzer près de ton oreille.
  • Option radio : la carte utilise sa radio Wi-Fi 2,4 GHz habituelle, comme tout ESP32. Ne modifie pas son antenne et n’augmente pas sa puissance. Les vraies fréquences de radioamateur sont un autre loisir et demandent une licence : elles ne font pas partie de cette mission.
  • Option capteur de lumière : le capteur (une LDR) contient du sulfure de cadmium. Ne le casse pas et ne le brûle pas, et jette-le avec les déchets électroniques.
  • 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

Une seule liste pour tout, sur plaque d’essai sans soudure. Le montage de base demande les neuf premières lignes. Les lignes marquées « Pour aller plus loin » servent seulement aux options. Les pièces de la version permanente sont dans une liste séparée plus bas.

Voir les 14 pièces · —
  • 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 de l’utiliser avec 4 piles alcalines (étape 2) : la puce à 3 pattes avec une grande languette près de la broche 5V doit porter la mention AMS1117.

  • 2

    Plaque d’essai×1

    Relie les pièces sans soudure

    Spécification exacte : Format complet 830 points. Une carte 38 broches avec ses pièces ne tient pas sur une plaque de 400 points.

  • 3

    DEL jaune 5 mm×1

    Fait clignoter les points et les traits

    Spécification exacte : 5 mm, un jaune « haute luminosité » quelconque. Tension directe d’environ 2,0–2,2 V (valeur typique, à vérifier sur la fiche de ta DEL). Le jaune se voit bien et se distingue du rouge de la mission 01, mais toute couleur marche avec la même résistance.

  • 4

    Résistance 220 Ω×1

    Protège la DEL

    Spécification exacte : 220 Ω, 1/4 W, traversante. Environ (3,3 − 2,1) / 220 ≈ 5,5 mA : assez lumineux en intérieur et bien en dessous des 20 mA habituels d’une DEL.

  • 5

    Module buzzer actif×1

    Fait sonner les points et les traits

    Spécification exacte : Module actif (son intégré), 3 broches S / + / −, 3,3–5 V, sonne quand S est HIGH. Certains modules fonctionnent à l’envers : tu le testes à l’étape 9 et tu peux le corriger à l’étape 10. Consomme environ 20–30 mA (valeur typique, à confirmer sur ton module).

  • 6

    Bouton poussoir×1

    Ta clé de télégraphe

    Spécification exacte : Bouton tactile 6 mm, 4 pattes. Pas de résistance : le code active la résistance de rappel interne de la carte.

  • 7

    Fils de connexionenviron 10

    Relient les pièces

    Spécification exacte : Mâle-mâle, 10–20 cm environ.

  • 8

    Câble USB données×1

    Envoyer le code et taper tes messages

    Spécification exacte : Câble données (pas charge seule), adapté au port de la carte.

  • 9

    Support 4×AA avec interrupteur ON/OFF, couvercle et extrémités à broches×1facultatif

    Facultatif : fait tourner la balise loin de l’ordinateur

    Spécification exacte : Le même support que la mission 01 (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 : change les piles avant d’en arriver là. Un support 3×AA ne suffit pas : il part à 4,5 V et passe sous la limite presque tout de suite.

  • 10

    Piles AA×4facultatif

    Facultatif : remplissent le support 4×AA

    Spécification exacte : Piles AA alcalines (LR6), ou NiMH AA à faible autodécharge. Même type et même marque, jamais mélangés. 4 piles NiMH seulement si ton régulateur n’est pas un AMS1117 (étape 2).

  • 11

    Deuxième kit de base complet (carte, plaque, DEL, 220 Ω, buzzer, bouton, fils, câble USB)1 lotfacultatif

    Pour aller plus loin 1 : l’autre bout de la liaison radio

    Spécification exacte : Identique au montage de base. La carte d’un ami convient, à condition que ce soit un ESP32 38 broches avec le même câblage.

  • 12

    Photorésistance (LDR), type GL5528×1facultatif

    Pour aller plus loin 2 : voit les éclairs de l’autre carte

    Spécification exacte : GL5528 ou équivalent. Un peu lente (quelques dizaines de millisecondes, valeur typique, à vérifier sur la fiche), c’est pourquoi cette option reste à 10 WPM ou moins. Contient du sulfure de cadmium (voir Sécurité).

  • 13

    Résistance 10 kΩ×1facultatif

    Pour aller plus loin 2 : fait la paire avec la LDR

    Spécification exacte : 10 kΩ, 1/4 W, traversante

  • 14

    Petit tube opaque, 3–5 cm×1facultatif

    Pour aller plus loin 2 : abrite la LDR pour que seule la lumière de la DEL l’atteigne

    Spécification exacte : Une paille entourée de ruban noir, un rouleau de papier noir, ou un tube imprimé.

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

Outils

Voir les 3 outils (2 en option)
  • Ordinateur avec Arduino IDE

    Envoyer le code et lire le moniteur série

    Spécification exacte : Arduino IDE 2.x + « esp32 by Espressif » 3.3.x (téléchargement gratuit sur arduino.cc)

  • Étiquette autocollante et un stylofacultatif

    Étiqueter le bloc de piles (seulement si tu en utilises un)

    Spécification exacte : N’importe lesquelles

  • Multimètrefacultatif

    Vérifier les piles et la tension du bloc ; mesurer la vraie durée de vie (nécessaire pour la version permanente)

    Spécification exacte : Multimètre numérique de base

Comment ça marche

Tape un message sur ton ordinateur et la balise le fait clignoter avec une DEL jaune et sonner avec un buzzer, en vrai code Morse international. La carte écrit aussi les points et les traits à l’écran, pour que tu puisses lire ce qu’elle envoie.

Le même bouton fait de toi le radio. Appuie dessus : la DEL et le buzzer suivent ton doigt ; la carte affiche les lettres que tu tapes, donc tu vois tout de suite tes erreurs. Maintiens le bouton 3 secondes et la carte devient un phare : elle répète un message toute seule, toutes les quelques secondes, même sur piles, loin de l’ordinateur. Ce message est le dernier que tu as tapé, ou HELLO AGENT après chaque mise sous tension, réinitialisation ou réveil (donc toujours HELLO AGENT sur piles, sauf si tu le changes dans le code).

Le câblage est exactement celui de la leçon K2 (bouton sur GPIO27, DEL sur GPIO26, buzzer sur GPIO25) : si tu as fait K2 ou la mission 01, il n’y a rien de nouveau à câbler, seulement du nouveau code. C’est le premier projet de code le plus économique, et tu peux le lire en entier. Les options ajoutent la radio entre deux cartes (ESP-NOW, sans routeur) et un capteur de lumière qui lit les éclairs, et une version soudée dans un boîtier rend la balise permanente.

Le temps en morse : tout se compte en unités Le temps du morse en unités. Un point dure 1 unité et un trait 3 unités. Dans une lettre, les signaux sont séparés par 1 unité de silence ; les lettres par 3 unités ; les mots par 7 unités. Le mot étalon PARIS, point trait trait point, point trait, point trait point, point point, point point point, dure exactement 50 unités avec son silence de fin de mot de 7 unités : P 14, A 8, R 10, I 6, S 12. Donc à W mots par minute, une unité dure 1200 divisé par W millisecondes : 120 ms à 10 mots par minute, la vitesse par défaut de la balise, 150 ms à 8 pour le bouton, 60 ms à 20. FIG. 3 — LE TEMPS EN MORSE (UIT-R M.1677-1)Tout se compte en unitéspoint1 unitétrait3 unitéssilence dans une lettre1 unitésilence entre lettres3 unitéssilence entre mots7 unitésBloc jaune en relief = DEL et buzzer allumés · case en pointillés = silence (éteint).Le mot étalon PARIS = 50 unitésONOFFP· − − ·A· −R· − ·I· ·S· · ·01020304050P 11+3 = 14A 5+3 = 8R 7+3 = 10I 3+3 = 6S 5+7 = 127fin de mot333314+8+10+6+12 = 50 unitésVitesse en mots par minute (WPM)1 mot = PARIS = 50 unités1 minute = 60 000 ms = 50 × WPM unitésunité (ms) = 1200 ÷ WPM60 000 ÷ 50 = 1200Un point à chaque vitesse5 WPM240 ms8 WPM150 msbouton (KEY_WPM)10 WPM120 msbalise par défaut15 WPM80 ms20 WPM60 msDébutants : 5–10 WPM. Le programme accepte 5–20.
Touche le schéma pour l’ouvrir en plein écran.

Leçons liées : 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 08, vue plaque d'essai Plaque d'essai complète de 830 trous 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 et les rangées 20 à 23 restent vides sous l'antenne. Dix fils numérotés. 1 rouge de 3V3 (j19) au rail rouge de droite, réservé au 3V3 ; 2 noir de GND (j6) au rail bleu de droite ; 3 noir relie les rails bleus de gauche et de droite, tous deux à la masse. Module buzzer en h39 (S), h40 (+), h41 (−) : 4 orange de GPIO25 (j11) à j39, 5 rouge du rail 3V3 à j40, 6 noir de j41 au rail GND. 7 vert de GPIO26 (j10) à b26 ; la résistance de 220 ohms est couchée de d26 à d30 ; la patte longue de la DEL jaune est en b30, la courte en b31 ; 8 noir de a31 au rail bleu de gauche. 9 bleu de GPIO27 (j9) à j44 ; le bouton est à cheval sur la rainure en e44, f44, e46 et f46 ; 10 noir de a46 au rail bleu de gauche. En option : un bloc 4×AA à interrupteur pour jouer loin de l'ordinateur, embout rouge en j1 à côté de la broche 5V, jamais sur un rail rouge, embout noir dans le rail bleu de droite. FIG. 1 — VUE PLAQUE D'ESSAI (DE DESSUS)+−−+jihgfedcba+−−+jihgfedcba253035404555ESP325VCMDD3D213GND1214GPIO27GPIO26GPIO2533323534VNVPEN3V3USB · rangée 1rangées 20–23 vides (antenne)S+−+AB++++ONOFF4×AABBBEn option : balise loin de l'ordinateurrouge → j1 (5V) · jamais un rail rougeDEL jaune · buzzer · boutonMêmes broches que K2 et la mission 01 : 27 · 26 · 25Plaque de la mission 01 ? Retire le récepteur : c'est prêt.4GPIO25 → S du buzzer79GPIO27 → bouton A12568103module buzzer220 ΩDEL jauneboutonRails de droite (en haut ici) : + rouge = 3V3 seulement · − bleu = GND.Rails de gauche (en bas ici) : − bleu = GND, relié par le fil 3 · + 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 (−), à droite3noirrail GND de gauche (−)rail GND de droite (−)4orangeESP32 GPIO25 (j11)buzzer S (j39)5rougerail 3V3 (+)buzzer + (j40)6noirbuzzer − (j41)rail GND (−)7vertESP32 GPIO26 (j10)rangée 26 (b26), bande 220 Ω8noirrangée − de la DEL (a31)rail GND (−), à gauche9bleuESP32 GPIO27 (j9)bouton patte A (j44)10noirbouton patte B (a46)rail GND (−), à gaucheBbloc 4×AA + / −j1 (5V) / rail GND de droiteB = seulement sur piles. L'USB seul suffit pour jouer.Règles d'alimentationBloc 4×AA (B) : rouge → j1, rangée du 5V.Jamais sur un rail rouge : c'est le 3V3.Jamais 3×AA dans la broche 3V3 (3,6 V max).Une seule source : bloc sur OFF avant l'USB.Débranche tout avant de bouger un fil.Rangées 20–23 vides (antenne).
Touche le schéma pour l’ouvrir en plein écran.
Câblage mission 08, schéma Schéma IEC. La carte ESP32 reçoit 5 V par l'USB, ou par un bloc 4×AA à interrupteur en option dans sa broche 5V, en pointillés ; son régulateur fait le 3,3 V pour la puce et la broche 3V3. GPIO25 commande la broche S du module buzzer actif, alimenté par le 3V3 et la masse (fils 4, 5, 6) : HIGH le fait biper. GPIO26 commande une résistance de 220 ohms et la DEL jaune vers la masse (fils 7 et 8) : HIGH l'allume, environ 5,5 milliampères. GPIO27 passe par le bouton-poussoir jusqu'à la masse (fils 9 et 10) ; dans la puce, une résistance de rappel d'environ 45 kilohms, activée par INPUT_PULLUP, tient la broche à HIGH : pressé, elle lit LOW. La DEL et le buzzer s'allument ensemble pour envoyer le morse. FIG. 2 — SCHÉMA (SYMBOLES IEC)bloc 4×AA en option (B)+−B5V3.3 V REGAMS1117ESP32DevKitC3V3GPIO25GPIO26GPIO27GND3V3≈ 45 kΩINPUT_PULLUP3V3S+−buzzer actifHIGH → bip220 ΩDEL jauneHIGH → allumée≈ 5,5 mAboutonpressé → lit LOW45678910DEL + buzzer ensemble :c'est le signal morse.
Touche le schéma pour l’ouvrir en plein écran.
Voir les 11 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 noirrail bleu de gaucherail bleu de droite (liaison de GND)
4 orangeESP32 GPIO25 (j11)buzzer S (j39)
5 rougerail 3V3buzzer + (j40)
6 noirbuzzer − (j41)rail GND
7 vertESP32 GPIO26 (j10)b26 (rangée 26). La résistance 220 Ω va ensuite de d26 à d30, dans la même rangée que le bout de ce fil, pour que deux pattes ne partagent aucun trou. La patte longue (+) de la DEL va en b30, dans la rangée de l’autre bout de la résistance, et sa patte courte (−) en b31.
8 noirrangée 31 de la DEL (a31, la rangée de la patte courte)rail bleu de gauche
9 bleuESP32 GPIO27 (j9)bouton patte A (j44). Le bouton est à cheval sur la rainure centrale, pattes en e44, f44, e46, f46.
10 noirbouton patte B, en diagonale de A (a46)rail bleu de gauche
B rouge / noirbloc 4×AA (facultatif)rouge + dans le trou à côté de la broche 5V (j1), noir − dans le rail bleu de droite. Jamais un rail rouge. Bloc sur OFF jusqu’à l’étape 15.

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). Ce sont exactement les trous de la leçon K2 et de la mission 01 (sans le récepteur) : une plaque issue de l’une ou de l’autre fait donc déjà tourner cette mission. 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 (sur piles seulement, et la seule chose qui va ici)Entrée d’alimentation (environ 4,4–6,5 V ; en dessous, elle se comporte mal)
3V3rail 3V3 : buzzer +Sortie d’alimentation (3
GNDrail GND : − du bloc, buzzer −, DEL, boutonMasse
GPIO27Bouton (autre patte à GND)Entrée avec résistance de rappel interne (LOW = appuyé). Peut réveiller la carte du sommeil profond.
GPIO26220 Ω → DELSortie (HIGH = DEL allumée)
GPIO25Buzzer SSortie (HIGH = buzzer actif, sauf si ton module est inversé)
GPIO34Pour aller plus loin 2 seulement, sur la carte réceptrice : le milieu de la paire LDR / 10 kΩEntrée analogique (broche d’entrée seulement)

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. Évite les broches 0, 2, 5, 12 et 15 pour tes propres ajouts : la carte les lit au démarrage.

Étapes de montage

Fais une étape, vérifie, puis passe à la suivante.

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

    Montage de base seulement : carte, plaque, DEL, résistance 220 Ω, buzzer, bouton, fils, câble USB.

    Vérifie : Toutes les pièces dont tu as besoin 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. (Tu n’en as besoin que si tu utilises le bloc de piles, mais vérifie maintenant, la carte est dans ta main.) Lis aussi les inscriptions imprimées sur la carte à côté des broches : sur les clones, l’ordre peut différer de cette fiche, et c’est ta carte qui a raison.

    Vérifie : Tu sais quelle puce régule ta carte, et tu as trouvé les broches 5V, GND, 3V3, 25, 26 et 27 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 de la plaque de 830 trous, broches dans les colonnes a et i, rangées 1 à 19, port USB en rangée 1. 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. Si tu as construit la mission 01, retire son récepteur : le reste est déjà ce circuit. 3×1×1830+−5VCMD123j : librei : broches5V en i1 · USB en rangée 1rangées 20–23 : zone de l'antenne, videsPlaque de la mission 01 ? Retire le récepteur → étape 8

    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 3 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+−123rail 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 · Ajoute le buzzer.
  6. Étape 6 · Ajoute la DEL.

    GPIO26 → résistance 220 Ω → patte longue (+) de la DEL. Le fil vert de GPIO26 se termine en b26. La résistance va de d26 à d30 : elle partage la rangée 26 avec le fil, mais pas un trou. La patte longue de la DEL va en b30 (même rangée que l’autre bout de la résistance) et sa patte courte en b31. Un fil va de a31 au rail bleu de gauche.

    Étape 6 : ajoute la DEL jaune La résistance de 220 ohms est couchée de d26 à d30. La patte longue de la DEL jaune va en b30, la courte en b31. Le fil 7 vert relie GPIO26 (j10) à b26, sur la bande de la résistance ; le fil 8 noir relie a31 au rail GND de gauche. Une loupe montre que la patte longue est le plus et que le côté plat marque la patte courte. 6×1220 Ω×15 mm×2+−78+−patte longue = + · b30côté plat = − · b31220 Ω · d26–d30

    Vérifie : La patte longue est du côté de la résistance.

  7. Étape 7 · Ajoute le bouton.

    Place le bouton à cheval sur la rainure centrale, pattes en e44, f44, e46 et f46. Un fil de GPIO27 va à une patte (côté j44) et un fil de la patte opposée en diagonale (a46) va au rail bleu de gauche. Pas de résistance : le code active la résistance de rappel interne de la carte.

    Étape 7 : ajoute le bouton (ton manipulateur) Le bouton poussoir est à cheval sur la rainure, pattes en e44, f44, e46 et f46. Le fil 9 bleu relie GPIO27 (j9) à j44, sur la bande de la patte A (f44) ; le fil 10 noir relie a46, sur la bande de la patte B (e46), en diagonale, au rail GND de gauche. Pas de résistance : le code active le rappel interne. 7×16 mm×2+−910ABpattes câblées en diagonaleA = f44 · B = e46

    Vérifie : Les deux pattes câblées sont en diagonale (pas du même côté).

  8. Étape 8 · Envoie le code.

    Ouvre le croquis « 08-morse-beacon » dans l’Arduino IDE. Branche le câble USB, choisis « ESP32 Dev Module » et le bon port, téléverse. Laisse le câble branché. (Pas encore de bloc de piles : une seule source d’alimentation à la fois.)

    Vérifie : « Done uploading » s’affiche.

  9. Étape 9 · Dis OK.

    Ouvre le moniteur série à 115200 bauds et règle la fin de ligne sur « Nouvelle ligne » (« Newline »). Appuie sur EN (reset). La DEL et le buzzer jouent OK en Morse (trait-trait-trait, trait-point-trait), puis le moniteur affiche un court texte d’aide. C’est la carte qui se teste toute seule.

    Vérifie : Tu vois et tu entends OK, et le texte d’aide s’affiche. Un buzzer qui reste muet, ou qui sonne tout le temps et se tait pendant les bips, fonctionne à l’envers : va à l’étape 10.

  10. Étape 10 · Corrige un buzzer inversé (seulement si besoin).

    Si le buzzer sonne quand il devrait se taire, trouve const int BUZZER_ON = HIGH; en haut du code, remplace HIGH par LOW, téléverse à nouveau.

    Vérifie : Le buzzer se tait entre les signaux et sonne avec la DEL.

  11. Étape 11 · Envoie ton premier message.

    Dans le moniteur série, tape HELLO et appuie sur Entrée. Le moniteur l’affiche en points et en traits, puis la DEL et le buzzer le jouent. Essaie ton prénom. Majuscules ou minuscules, peu importe. Le é est envoyé en ..-.. (UIT) ; les autres lettres accentuées sont ignorées, et le moniteur te le dit. La ligne que tu as tapée devient le message de la balise, jusqu’à ce que la carte soit éteinte, réinitialisée ou endormie (elle revient alors à HELLO AGENT).

    Étape 11 : tape un message secret La carte est branchée à l'ordinateur avec un câble USB de données. Après le téléversement du programme, ouvre le moniteur série à 115200 bauds avec Newline. Tape SOS puis Entrée : l'écran répond SOS, flèche, point point point, trait trait trait, point point point, et la DEL jaune clignote et le buzzer bipe le même motif : trois courts, trois longs, trois courts. Les commandes commencent par une barre oblique : /wpm 15, /quiet, /loud, /help. 11×1données×1Moniteur sérieSOSSOS -> ... --- ...115200 · Newlinetape, puis Entrée ⏎ESP32DEL + buzzer le jouentS · · ·O − − −S · · ·Commandes : /wpm 15 · /quiet · /loud · /help

    Vérifie : Les points et les traits du moniteur correspondent aux éclairs. Garde les essais pour des mots comme HELLO : jamais SOS (voir Sécurité).

  12. Étape 12 · Tape avec la clé.

    Appuie sur le bouton : la DEL et le buzzer suivent ton doigt. Relâche : ils s’arrêtent. La carte mesure la durée de ton appui (court = point, long = trait) et celle de ton attente, et affiche ce que tu as tapé. Attends un instant après une lettre et elle apparaît sur le moniteur. Attends plus longtemps et elle ajoute une espace. Tape lentement : la carte attend environ 8 WPM. Essaie E (un point), T (un trait), puis le mot HI (quatre points, une pause, deux points).

    Étape 12 : deviens l'opérateur radio Appuie sur le bouton : tant qu'il est enfoncé, la DEL et le buzzer restent allumés. Tape O, trois appuis longs, puis K, long court long. Le programme chronomètre chaque appui : moins de 2 unités, 300 millisecondes aux 8 mots par minute du bouton, c'est un point ; plus long, c'est un trait. Un silence de 2,5 unités, 375 millisecondes, termine la lettre et le moniteur série l'affiche ; 6 unités, 900 millisecondes, affichent une espace. 12×1allumée tant que tu appuiesTu tapes : O puis KOK≥ 2 unités : trait< 2 : point≥ 2,5 : fin de lettre≥ 6 : espace1 unité = 150 ms à KEY_WPM 8 (1200 ÷ 8)Moniteur série--- O-.- Kune erreur se voit ici : recommence

    Vérifie : Le moniteur affiche les points et les traits pendant que tu tapes, puis la lettre. Une mauvaise lettre veut dire qu’un point était trop long ou un silence trop court : ralentis.

  13. Étape 13 · Lance la balise.
  14. Étape 14 · Change la vitesse et le volume.

    Tape /wpm 15 pour envoyer plus vite (plage permise : 5–20 WPM). Tape /quiet pour couper le buzzer (la DEL continue) et /loud pour le remettre. /help liste les commandes. Essaie différents mots à différentes vitesses : à partir de quand devient-ce difficile à lire à l’œil ?

    Vérifie : Les messages se jouent à la nouvelle vitesse et le buzzer obéit à /quiet.

  15. Étape 15 · Fais-la tourner sur piles (facultatif). Demande de l’aide

    USB débranché d’abord. Mets 4 piles dans le support 4×AA, en suivant les marques + / −, mets-le sur OFF et é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. Mets-le sur ON : la carte dit OK. Maintiens le bouton 3 s pour lancer la balise, et appuie pour l’arrêter. Sans ordinateur, tu ne peux pas taper de message, et un message tapé est oublié quand le courant est coupé : sur piles, la balise joue donc toujours le message par défaut du code (HELLO AGENT). Pour envoyer le tien sur piles, change DEFAULT_MESSAGE dans le code et téléverse à nouveau (bloc sur OFF, puis USB). Mets le bloc sur OFF quand tu arrêtes.

    Vérifie : Le rouge va dans la rangée 5V, le noir dans le rail bleu, et une personne expérimentée (ou toi, deux fois) a contrôlé. La balise tourne sans câble.

Ce que te dit la carte (le sommeil profond, en mots simples)

Pour que les piles durent, la carte tourne à vitesse réduite (80 MHz), garde le Wi-Fi et le Bluetooth éteints, et passe en sommeil profond après 3 minutes sans rien : presque éteinte, elle consomme très peu. Un appui sur le bouton la réveille et elle redémarre normalement, avec son OK. La seule chose qui ne s’endort jamais toute seule, c’est la balise : c’est son travail, et elle vide le bloc (voir plus bas).

Voir les 5 signaux de la DEL et l’autonomie
Ce que tu voisCe que ça veut dire
OK en Morse à la mise sous tensionAuto-test : la carte a démarré, et la DEL et le buzzer fonctionnent.
La DEL et le buzzer suivent ton doigtMode clé droite : tu es le radio.
Un court bip après un maintien de 3 sLa balise démarre. Lâche le bouton.
Ton message toutes les 5 sBalise en marche. Un appui sur le bouton l’arrête.
Deux clignotements, puis le noir3 minutes sans rien : la carte part en sommeil profond. Appuie sur le bouton pour la réveiller.

Appuyer sur le bouton pour réveiller la carte n’envoie pas de lettre : cela relance simplement le programme. Sur USB, le sommeil ménage seulement la carte ; sur piles, il ménage les piles. Tu peux le désactiver dans le code (SLEEP_AFTER_MS = 0). Un message que tu avais tapé est oublié lui aussi : après un réveil, la balise rejoue HELLO AGENT.

Combien de temps les piles durent-elles ?

BlocAutonomieRemarques
Éveillée, en attente, 4×AA alcalinesenviron 2–3 jours de marche continueEnviron 30–40 mA, dont l’essentiel vient de la puce, du régulateur et de la DEL d’alimentation de la carte.
Balise en marche, 4×AA alcalinesenviron 1,5–2,5 joursLa DEL et le buzzer s’ajoutent à la consommation de la carte, surtout quand le buzzer est actif. /quiet en économise un peu.
Sommeil profond (après 3 min), 4×AA alcalinesenviron 10–12 jours en veillePresque toute la consommation vient du régulateur et de la DEL d’alimentation de la carte, pas de ton code.
Option radio (Pour aller plus loin 1), à l’écoute, 4×AA alcalinesenviron 15–20 heuresLa radio Wi-Fi à l’écoute coûte le plus : environ 105–115 mA. De courtes rafales à l’envoi coûtent davantage.

Mets le bloc sur OFF quand tu arrêtes de jouer. Laissée allumée en mode balise, elle dure environ deux jours.

Ce sont des estimations tirées de fiches techniques et de valeurs typiques, pas des mesures. À mesurer sur ton montage : mets un multimètre en série sur le fil rouge du bloc et lis le courant dans chaque état. Quand les piles faiblissent, la carte 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. Trois croquis : celui de base (08-morse-beacon, sans Wi-Fi), celui de la radio (08b-morse-radio, Pour aller plus loin 1) et celui de la lumière (08c-morse-light, Pour aller plus loin 2). Le croquis de base n’utilise aucune bibliothèque et il est écrit pour être lu : court et plein de commentaires.

Télécharger le fichier .ino Télécharger le dossier du croquis (.zip)

  1. Bloc 1 En-tête et câblage

    Les notes du haut : ce que fait le croquis (messages tapés, le bouton comme clé, mode balise), les commandes, le câblage (le même que la leçon K2) et la règle des piles. Puis trois inclusions pour le sommeil profond : les broches RTC, dont la résistance de rappel continue de marcher pendant le sommeil, le maintien des broches qui garde la DEL et le buzzer éteints, et les fonctions de sommeil. À changer : rien

    Voir le code (27 lignes)
    // Tinker Mission — Mission 08: Morse spy beacon
    // Board: ESP32 Dev Module ("esp32 by Espressif" 3.3.x). No extra library needed.
    //
    // How it works:
    //   1. Type a message in the Serial Monitor (115200 baud, "Newline"): the LED flashes it and the
    //      buzzer beeps it in real International Morse code. It also becomes the beacon message.
    //   2. Press the button like a radio operator's key: the LED and buzzer follow your finger, and
    //      the Serial Monitor shows the dots, dashes and letters you tapped.
    //   3. Hold the button 3 s: beacon mode. The message repeats every 5 s until you tap the button.
    //      It repeats your last typed message, or DEFAULT_MESSAGE if you typed nothing since power-on
    //      (always the case on batteries, away from the computer).
    //   Nothing happens for 3 minutes (and no beacon)? The board goes to deep sleep. Press the button
    //   to wake it up.
    //
    // Commands you can type: /wpm 15 (speed, 5 to 20 words per minute), /quiet (buzzer off),
    // /loud (buzzer on), /help.
    //
    // Wiring (ESP32 DevKitC, 38 pins), the same as lesson K2:
    //   Push button   GPIO27 -> button -> GND
    //   LED           GPIO26 -> 220 ohm resistor -> LED long leg; LED short leg -> GND
    //   Buzzer module S -> GPIO25   + -> 3V3   - -> GND   (active buzzer)
    //   4xAA pack (optional) red (+) -> 5V pin   black (-) -> GND   (5V pin ONLY, never a red rail)
    // Switch the pack OFF before you plug in the USB cable: one power source at a time.
    
    #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 message par défaut

    Un nom pour chaque broche (LED_PIN, BUZZER_PIN, BUTTON_PIN), le niveau qui fait sonner le buzzer (BUZZER_ON), puis les nombres que tu peux changer : vitesse d’envoi (10 WPM), vitesse de la clé (8 WPM), durée de maintien pour la balise (3 s), pause entre deux messages de la balise (5 s), délai avant le sommeil profond (3 min), message le plus long (100 caractères) et les seuils du décodeur du bouton. DEFAULT_MESSAGE (« HELLO AGENT ») est ce que la balise joue après chaque mise sous tension, réinitialisation ou réveil. À changer : BUZZER_ON seulement si l’étape 10 te l’a dit ; DEFAULT_MESSAGE pour ton propre texte de balise ; les nombres si tu veux

    Voir le code (25 lignes)
    // ---------- Pins ----------
    const gpio_num_t BUTTON_PIN = GPIO_NUM_27;  // pressed = LOW (wired to GND). Can wake the ESP32.
    const gpio_num_t LED_PIN = GPIO_NUM_26;
    const gpio_num_t BUZZER_PIN = GPIO_NUM_25;
    
    // ---------- Settings you may change ----------
    // Most buzzer modules beep when S is HIGH. A "low-level trigger" module beeps when S is LOW:
    // if yours beeps all the time, change HIGH to LOW.
    const int BUZZER_ON = HIGH;
    const int SEND_WPM = 10;                    // sending speed at start-up, in words per minute
    const int KEY_WPM = 8;                      // how fast we expect YOU to tap the button
    const unsigned long HOLD_FOR_BEACON_MS = 3000;  // hold the button this long = beacon mode
    const unsigned long BEACON_PAUSE_MS = 5000;     // beacon: pause between two repeats
    const unsigned long SLEEP_AFTER_MS = 180000;    // 3 minutes without activity = deep sleep (0 = never)
    // The beacon message after power-on. On batteries (no computer, so nothing typed) the beacon
    // always plays this one: change it here, then upload again. A typed message replaces it only
    // until the board is switched off, reset or goes to deep sleep (it lives in normal memory).
    const char* DEFAULT_MESSAGE = "HELLO AGENT";
    const int MAX_LINE = 100;                   // longest message, in characters
    
    // How the button decoder tells things apart, counted in "units" (one unit = one dot):
    const float DASH_AT_UNITS = 2.0;     // a press shorter than 2 units is a dot, longer is a dash
    const float LETTER_END_UNITS = 2.5;  // silence of 2.5 units = the letter is finished
    const float WORD_END_UNITS = 6.0;    // silence of 6 units = the word is finished
    const unsigned long DEBOUNCE_MS = 30;  // a button "bounces" for a few ms: ignore changes this short
  3. Bloc 3 La table Morse et le temps

    L’alphabet, les chiffres et la ponctuation, chacun écrit en points et en traits dans une simple liste (UIT-R M.1677-1). Puis les règles de durée (trait = 3 unités, silences de 1, 3 et 7) et l’unité, 1200 ÷ WPM millisecondes. Trois petites fonctions : morseFor() trouve les points et les traits d’un caractère (les minuscules deviennent des majuscules, é est envoyé en ..-.., les autres caractères inconnus ne donnent rien), letterFor() fait le chemin inverse, morseUnits() compte la durée d’un message. À changer : rien

    Voir le code (67 lignes)
    // ---------- Morse code table and timing (pure code: no pins, no Serial) ----------
    // International Morse code (ITU-R M.1677-1): letters, figures, some punctuation and É.
    const char* MORSE[][2] = {
      {"A", ".-"}, {"B", "-..."}, {"C", "-.-."}, {"D", "-.."}, {"E", "."}, {"F", "..-."},
      {"G", "--."}, {"H", "...."}, {"I", ".."}, {"J", ".---"}, {"K", "-.-"}, {"L", ".-.."},
      {"M", "--"}, {"N", "-."}, {"O", "---"}, {"P", ".--."}, {"Q", "--.-"}, {"R", ".-."},
      {"S", "..."}, {"T", "-"}, {"U", "..-"}, {"V", "...-"}, {"W", ".--"}, {"X", "-..-"},
      {"Y", "-.--"}, {"Z", "--.."},
      {"0", "-----"}, {"1", ".----"}, {"2", "..---"}, {"3", "...--"}, {"4", "....-"},
      {"5", "....."}, {"6", "-...."}, {"7", "--..."}, {"8", "---.."}, {"9", "----."},
      {".", ".-.-.-"}, {",", "--..--"}, {"?", "..--.."}, {"'", ".----."}, {"/", "-..-."},
      {"(", "-.--."}, {")", "-.--.-"}, {":", "---..."}, {"=", "-...-"}, {"+", ".-.-."},
      {"-", "-....-"}, {"\"", ".-..-."}, {"@", ".--.-."},
      {"É", "..-.."},  // the only accented letter in the ITU table (é is sent as É)
    };
    const int MORSE_COUNT = sizeof(MORSE) / sizeof(MORSE[0]);
    
    // Morse timing, in units: a dash is 3 dots long. Silences: 1 unit inside a letter,
    // 3 units between letters, 7 units between words.
    const int DOT = 1, DASH = 3, ELEMENT_GAP = 1, LETTER_GAP = 3, WORD_GAP = 7;
    
    // One unit in milliseconds. The word "PARIS" (with its word gap) is exactly 50 units, and
    // "10 words per minute" means 10 PARIS per minute: 60000 ms / (50 x WPM) = 1200 / WPM.
    unsigned long unitMs(int wpm) { return 1200 / wpm; }
    
    // How many bytes the character at the start of text takes. The Serial Monitor sends text as
    // UTF-8: 1 byte for A-Z, figures, punctuation and spaces; 2 for é (0xC3 0xA9); up to 4 for emoji.
    int charBytes(const char* text) {
      int n = 1;
      if ((unsigned char)text[0] >= 0xC0)        // first byte of a longer character...
        while ((text[n] & 0xC0) == 0x80) n++;   // ...its next bytes all start with the bits 10
      return n;
    }
    
    // The dots and dashes of the character at the start of text, or NULL if it has no Morse code
    // (other accented letters, emoji...). Lowercase letters count as uppercase, and é as É.
    const char* morseFor(const char* text) {
      int n = charBytes(text);
      if (n > 2) return NULL;
      char key[3] = {(char)toupper((unsigned char)text[0]), n == 2 ? text[1] : (char)0, 0};
      if (strcmp(key, "é") == 0) strcpy(key, "É");
      for (int i = 0; i < MORSE_COUNT; i++)
        if (strcmp(MORSE[i][0], key) == 0) return MORSE[i][1];
      return NULL;
    }
    
    // The character for some dots and dashes ("É" is 2 bytes), or "?" if no character has them.
    const char* letterFor(const char* code) {
      for (int i = 0; i < MORSE_COUNT; i++)
        if (strcmp(MORSE[i][1], code) == 0) return MORSE[i][0];
      return "?";
    }
    
    // How long a message lasts, in units, with exactly the rules sendMorse() uses below
    // (characters with no Morse code skipped, several spaces = one word gap, a word gap at the end).
    int morseUnits(const char* text) {
      int units = 0, gapBefore = 0;  // gapBefore = silence to leave before the next letter
      for (int i = 0; text[i] != 0; i += charBytes(text + i)) {
        if (text[i] == ' ') { if (gapBefore > 0) gapBefore = WORD_GAP; continue; }
        const char* code = morseFor(text + i);
        if (code == NULL) continue;
        units += gapBefore;
        for (int k = 0; code[k] != 0; k++) units += (k > 0 ? ELEMENT_GAP : 0) + (code[k] == '.' ? DOT : DASH);
        gapBefore = LETTER_GAP;
      }
      return gapBefore > 0 ? units + WORD_GAP : 0;
    }
  4. Bloc 4 Mémoire et petits outils

    Les variables qui retiennent ce que fait la carte : vitesse, buzzer coupé ou non, le message de la balise (il commence à DEFAULT_MESSAGE) et le décodeur du bouton. Puis les outils : setSignal() allume la DEL et le buzzer ensemble (le buzzer reste muet après /quiet), waitOrPress() attend mais s’arrête aussitôt si le bouton est appuyé, et printHelp(). À changer : rien

    Voir le code (46 lignes)
    // ---------- Variables ----------
    int sendWpm = SEND_WPM;            // changed with /wpm
    bool quiet = false;                // /quiet: buzzer off, the LED still works
    String beaconMessage = DEFAULT_MESSAGE;
    bool beaconOn = false;
    unsigned long nextBeaconAt = 0;    // when the beacon plays the message again
    unsigned long lastActivity = 0;    // for the deep sleep timer
    
    // Button decoder
    bool keyDown = false;              // the button, after debouncing
    bool lastRaw = false;              // the button, as read just now
    unsigned long lastChange = 0;      // when the raw reading last changed
    unsigned long pressStart = 0, releasedAt = 0;
    bool ignorePress = false;          // this press stops the beacon: do not decode it
    String tapped = "";                // dots and dashes of the letter being tapped
    String tappedWord = "";                  // letters of the word being tapped
    
    // ---------- Small helpers ----------
    // LED and buzzer together (the buzzer only if not /quiet).
    void setSignal(bool on) {
      digitalWrite(LED_PIN, on ? HIGH : LOW);
      digitalWrite(BUZZER_PIN, (on && !quiet) ? BUZZER_ON : !BUZZER_ON);
    }
    
    bool buttonPressed() { return digitalRead(BUTTON_PIN) == LOW; }
    
    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(unsigned long ms) {
      unsigned long start = millis();
      while (millis() - start < ms) {
        if (buttonPressed()) return true;
        delay(1);
      }
      return false;
    }
    
    void printHelp() {
      Serial.println("Type a message and press Enter: I send it in Morse.");
      Serial.println("Commands: /wpm 15 (speed 5-20)  /quiet  /loud  /help");
      Serial.println("Button: tap Morse yourself. Hold 3 s = beacon mode, tap to stop it.");
    }
  5. Bloc 5 Envoyer un message

    sendMorse() parcourt le texte lettre par lettre, joue chaque point et chaque trait, laisse les bons silences et vérifie le bouton entre les signaux, pour qu’un appui puisse l’arrêter. printMorse() affiche les points et les traits avec la durée et liste les caractères ignorés. sendAndReport() réunit les deux. À changer : rien

    Voir le code (49 lignes)
    // ---------- Sending Morse: LED + buzzer ----------
    // Plays a text in Morse. Returns true if the button stopped it.
    bool sendMorse(const char* text) {
      unsigned long unit = unitMs(sendWpm);
      int gapBefore = 0;  // silence to leave before the next letter (0 before the first one)
      for (int i = 0; text[i] != 0; i += charBytes(text + i)) {
        if (text[i] == ' ') { if (gapBefore > 0) gapBefore = WORD_GAP; continue; }
        const char* code = morseFor(text + i);
        if (code == NULL) continue;  // no Morse code for it: skip
        if (waitOrPress(gapBefore * unit)) return true;
        for (int k = 0; code[k] != 0; k++) {
          if (k > 0 && waitOrPress(ELEMENT_GAP * unit)) return true;
          setSignal(true);
          bool pressed = waitOrPress((code[k] == '.' ? DOT : DASH) * unit);
          setSignal(false);
          if (pressed) return true;
        }
        gapBefore = LETTER_GAP;
      }
      return gapBefore > 0 && waitOrPress(WORD_GAP * unit);  // word gap at the end
    }
    
    // Shows "SOS -> ... --- ..." on the Serial Monitor, and lists the characters with no Morse code.
    void printMorse(const char* text) {
      String skipped = "";
      Serial.print(text);
      Serial.print(" ->");
      for (int i = 0; text[i] != 0; i += charBytes(text + i)) {
        const char* code = morseFor(text + i);
        if (text[i] == ' ') Serial.print(" /");
        else if (code == NULL) for (int k = 0; k < charBytes(text + i); k++) skipped += text[i + k];
        else { Serial.print(" "); Serial.print(code); }
      }
      Serial.print("   (");
      Serial.print(morseUnits(text) * unitMs(sendWpm) / 1000.0, 1);
      Serial.println(" s)");
      if (skipped.length() > 0) { Serial.print("skipped: "); Serial.println(skipped); }
    }
    
    // Sends a text; if the button stops it, wait for the release so that press is not decoded.
    void sendAndReport(const char* text) {
      if (sendMorse(text)) {
        Serial.println("Stopped by the button.");
        waitButtonRelease();
        keyDown = lastRaw = false;
        beaconOn = false;
      }
      lastActivity = millis();
    }
  6. Bloc 6 Lignes tapées, commandes et mode balise

    handleLine() nettoie la ligne que tu as tapée. Une ligne qui commence par / est une commande : /wpm (5 à 20), /quiet, /loud, /help. Toute autre ligne est un message : coupé à 100 caractères, affiché en points et en traits, joué, et gardé comme message de la balise jusqu’à l’extinction, la réinitialisation ou le sommeil. startBeacon() donne un court bip de confirmation et lance la répétition ; stopBeacon() l’arrête. À changer : le 5 et le 20 de /wpm, si tu veux une autre plage de vitesse

    Voir le code (49 lignes)
    // ---------- Typed lines and commands ----------
    void handleLine(String line) {
      line.trim();  // removes spaces and line endings at both ends
      if (line.length() == 0) return;
      if (line.startsWith("/wpm")) {
        sendWpm = constrain(line.substring(4).toInt(), 5, 20);  // keeps it between 5 and 20
        Serial.print("Speed: ");
        Serial.print(sendWpm);
        Serial.println(" words per minute");
      } else if (line == "/quiet") {
        quiet = true;
        Serial.println("Buzzer off (the LED still flashes)");
      } else if (line == "/loud") {
        quiet = false;
        Serial.println("Buzzer on");
      } else if (line.startsWith("/")) {
        printHelp();
      } else {
        if (line.length() > MAX_LINE) {
          line = line.substring(0, MAX_LINE);
          Serial.println("Too long: only the first 100 characters are sent.");
        }
        beaconMessage = line;  // the beacon repeats this one until power-off, reset or sleep
        printMorse(line.c_str());
        sendAndReport(line.c_str());
      }
    }
    
    // ---------- Beacon mode ----------
    void startBeacon() {
      setSignal(false);
      tapped = "";
      tappedWord = "";
      ignorePress = true;  // the long press itself is not a dash
      delay(200);
      setSignal(true);        // one short beep = beacon mode on
      delay(100);
      setSignal(false);
      beaconOn = true;
      nextBeaconAt = millis() + 1000;
      Serial.print("Beacon mode: ");
      Serial.println(beaconMessage);
    }
    
    void stopBeacon() {
      beaconOn = false;
      ignorePress = true;  // the stop press is not decoded
      Serial.println("Beacon stopped.");
    }
  7. Bloc 7 Le bouton comme clé Morse

    readKey() ignore les changements de moins de 30 ms (anti-rebond), fait suivre ton doigt par la DEL et le buzzer et mesure chaque appui : court = point, long = trait. Un silence d’environ 2,5 unités termine une lettre et 6 unités terminent un mot. Elle cherche la lettre dans la table, ou affiche ? si rien ne correspond. Un maintien de 3 secondes appelle startBeacon() ; un appui pendant que la balise tourne l’arrête. À changer : les seuils (voir Broches), si tu tapes très vite ou très lentement

    Voir le code (39 lignes)
    // ---------- The button as a Morse key ----------
    void readKey() {
      unsigned long now = millis();
      bool raw = buttonPressed();
      if (raw != lastRaw) { lastRaw = raw; lastChange = now; }
    
      if (raw != keyDown && now - lastChange >= DEBOUNCE_MS) {  // a real change
        keyDown = raw;
        lastActivity = now;
        if (keyDown) {  // just pressed
          pressStart = now;
          if (beaconOn) stopBeacon();
          else setSignal(true);  // the LED and buzzer follow your finger
        } else {        // just released
          setSignal(false);
          if (ignorePress) { ignorePress = false; return; }
          unsigned long unit = unitMs(KEY_WPM);
          char symbol = (now - pressStart < DASH_AT_UNITS * unit) ? '.' : '-';
          tapped += symbol;
          Serial.print(symbol);  // show each dot or dash at once
          releasedAt = now;
        }
      }
    
      unsigned long unit = unitMs(KEY_WPM);
      if (keyDown && !ignorePress && now - pressStart >= HOLD_FOR_BEACON_MS) startBeacon();
      if (!keyDown && tapped.length() > 0 && now - releasedAt >= LETTER_END_UNITS * unit) {
        const char* letter = letterFor(tapped.c_str());  // "?" if the dots and dashes mean nothing
        Serial.print("  ");
        Serial.println(letter);
        tappedWord += letter;
        tapped = "";
      }
      if (!keyDown && tappedWord.length() > 0 && now - releasedAt >= WORD_END_UNITS * unit) {
        Serial.print("Word: ");
        Serial.println(tappedWord);
        tappedWord = "";
      }
    }
  8. Bloc 8 Sommeil profond, démarrage et boucle

    goToSleep() clignote deux fois, fige la DEL et le buzzer éteints, garde vivante la résistance de rappel du bouton et demande à être réveillée quand GPIO27 passe à LOW. setup() s’exécute à la mise sous tension, au reset et à chaque réveil : elle ralentit la carte à 80 MHz, joue OK et affiche l’aide. loop() écoute le moniteur série et le bouton, joue la balise quand c’est l’heure, et s’endort après 3 minutes sans rien (jamais pendant la balise ni bouton enfoncé). À changer : SLEEP_AFTER_MS (0 = ne jamais dormir)

    Voir le code (59 lignes)
    // ---------- Deep sleep ----------
    void goToSleep() {
      Serial.println("Nothing for 3 minutes: sleeping. Press the button to wake me up.");
      for (int i = 0; i < 2; i++) {  // two blinks = going to sleep
        digitalWrite(LED_PIN, HIGH);
        delay(150);
        digitalWrite(LED_PIN, LOW);
        delay(150);
      }
      // Freeze the buzzer OFF and the LED off during sleep (else the pins could float).
      digitalWrite(BUZZER_PIN, !BUZZER_ON);
      gpio_hold_en(BUZZER_PIN);
      gpio_hold_en(LED_PIN);
      gpio_deep_sleep_hold_en();
      // Keep the "RTC" part powered so the button's pull-up keeps working (a few microamps).
      esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
      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);
      esp_sleep_enable_ext0_wakeup(BUTTON_PIN, LOW);  // wake up when the button pulls GPIO27 LOW
      Serial.flush();
      esp_deep_sleep_start();  // the ESP32 stops here; waking up starts setup() again
    }
    
    // ---------- setup(): runs at power-on, reset and every wake-up ----------
    void setup() {
      setCpuFrequencyMhz(80);  // slower = less current. Wi-Fi and Bluetooth stay off.
      Serial.begin(115200);
      // Unfreeze the outputs, and give the button pin back to normal code.
      gpio_hold_dis(BUZZER_PIN);
      gpio_hold_dis(LED_PIN);
      rtc_gpio_deinit(BUTTON_PIN);
      pinMode(BUZZER_PIN, OUTPUT);
      pinMode(LED_PIN, OUTPUT);
      setSignal(false);
      pinMode(BUTTON_PIN, INPUT_PULLUP);  // built-in pull-up: pressed = LOW
    
      if (esp_sleep_get_wakeup_cause() == ESP_SLEEP_WAKEUP_EXT0) waitButtonRelease();  // woken by the button
      Serial.println();
      Serial.println("Morse spy beacon ready.");
      sendAndReport("OK");  // self-test: --- -.- on the LED and buzzer
      printHelp();
      lastActivity = millis();
    }
    
    // ---------- loop(): runs again and again ----------
    void loop() {
      if (Serial.available()) {  // a typed line (the Serial Monitor sends it when you press Enter)
        lastActivity = millis();
        handleLine(Serial.readStringUntil('\n'));
      }
      readKey();
      if (beaconOn && !keyDown && (long)(millis() - nextBeaconAt) >= 0) {
        sendAndReport(beaconMessage.c_str());
        nextBeaconAt = millis() + BEACON_PAUSE_MS;
      }
      if (SLEEP_AFTER_MS > 0 && !beaconOn && !keyDown && millis() - lastActivity >= SLEEP_AFTER_MS) goToSleep();
    }
Le croquis complet, d’un seul tenant
// Tinker Mission — Mission 08: Morse spy beacon
// Board: ESP32 Dev Module ("esp32 by Espressif" 3.3.x). No extra library needed.
//
// How it works:
//   1. Type a message in the Serial Monitor (115200 baud, "Newline"): the LED flashes it and the
//      buzzer beeps it in real International Morse code. It also becomes the beacon message.
//   2. Press the button like a radio operator's key: the LED and buzzer follow your finger, and
//      the Serial Monitor shows the dots, dashes and letters you tapped.
//   3. Hold the button 3 s: beacon mode. The message repeats every 5 s until you tap the button.
//      It repeats your last typed message, or DEFAULT_MESSAGE if you typed nothing since power-on
//      (always the case on batteries, away from the computer).
//   Nothing happens for 3 minutes (and no beacon)? The board goes to deep sleep. Press the button
//   to wake it up.
//
// Commands you can type: /wpm 15 (speed, 5 to 20 words per minute), /quiet (buzzer off),
// /loud (buzzer on), /help.
//
// Wiring (ESP32 DevKitC, 38 pins), the same as lesson K2:
//   Push button   GPIO27 -> button -> GND
//   LED           GPIO26 -> 220 ohm resistor -> LED long leg; LED short leg -> GND
//   Buzzer module S -> GPIO25   + -> 3V3   - -> GND   (active buzzer)
//   4xAA pack (optional) red (+) -> 5V pin   black (-) -> GND   (5V pin ONLY, never a red rail)
// Switch the pack OFF before you plug in the USB cable: one power source at a time.

#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 ----------
const gpio_num_t BUTTON_PIN = GPIO_NUM_27;  // pressed = LOW (wired to GND). Can wake the ESP32.
const gpio_num_t LED_PIN = GPIO_NUM_26;
const gpio_num_t BUZZER_PIN = GPIO_NUM_25;

// ---------- Settings you may change ----------
// Most buzzer modules beep when S is HIGH. A "low-level trigger" module beeps when S is LOW:
// if yours beeps all the time, change HIGH to LOW.
const int BUZZER_ON = HIGH;
const int SEND_WPM = 10;                    // sending speed at start-up, in words per minute
const int KEY_WPM = 8;                      // how fast we expect YOU to tap the button
const unsigned long HOLD_FOR_BEACON_MS = 3000;  // hold the button this long = beacon mode
const unsigned long BEACON_PAUSE_MS = 5000;     // beacon: pause between two repeats
const unsigned long SLEEP_AFTER_MS = 180000;    // 3 minutes without activity = deep sleep (0 = never)
// The beacon message after power-on. On batteries (no computer, so nothing typed) the beacon
// always plays this one: change it here, then upload again. A typed message replaces it only
// until the board is switched off, reset or goes to deep sleep (it lives in normal memory).
const char* DEFAULT_MESSAGE = "HELLO AGENT";
const int MAX_LINE = 100;                   // longest message, in characters

// How the button decoder tells things apart, counted in "units" (one unit = one dot):
const float DASH_AT_UNITS = 2.0;     // a press shorter than 2 units is a dot, longer is a dash
const float LETTER_END_UNITS = 2.5;  // silence of 2.5 units = the letter is finished
const float WORD_END_UNITS = 6.0;    // silence of 6 units = the word is finished
const unsigned long DEBOUNCE_MS = 30;  // a button "bounces" for a few ms: ignore changes this short

// ---------- Morse code table and timing (pure code: no pins, no Serial) ----------
// International Morse code (ITU-R M.1677-1): letters, figures, some punctuation and É.
const char* MORSE[][2] = {
  {"A", ".-"}, {"B", "-..."}, {"C", "-.-."}, {"D", "-.."}, {"E", "."}, {"F", "..-."},
  {"G", "--."}, {"H", "...."}, {"I", ".."}, {"J", ".---"}, {"K", "-.-"}, {"L", ".-.."},
  {"M", "--"}, {"N", "-."}, {"O", "---"}, {"P", ".--."}, {"Q", "--.-"}, {"R", ".-."},
  {"S", "..."}, {"T", "-"}, {"U", "..-"}, {"V", "...-"}, {"W", ".--"}, {"X", "-..-"},
  {"Y", "-.--"}, {"Z", "--.."},
  {"0", "-----"}, {"1", ".----"}, {"2", "..---"}, {"3", "...--"}, {"4", "....-"},
  {"5", "....."}, {"6", "-...."}, {"7", "--..."}, {"8", "---.."}, {"9", "----."},
  {".", ".-.-.-"}, {",", "--..--"}, {"?", "..--.."}, {"'", ".----."}, {"/", "-..-."},
  {"(", "-.--."}, {")", "-.--.-"}, {":", "---..."}, {"=", "-...-"}, {"+", ".-.-."},
  {"-", "-....-"}, {"\"", ".-..-."}, {"@", ".--.-."},
  {"É", "..-.."},  // the only accented letter in the ITU table (é is sent as É)
};
const int MORSE_COUNT = sizeof(MORSE) / sizeof(MORSE[0]);

// Morse timing, in units: a dash is 3 dots long. Silences: 1 unit inside a letter,
// 3 units between letters, 7 units between words.
const int DOT = 1, DASH = 3, ELEMENT_GAP = 1, LETTER_GAP = 3, WORD_GAP = 7;

// One unit in milliseconds. The word "PARIS" (with its word gap) is exactly 50 units, and
// "10 words per minute" means 10 PARIS per minute: 60000 ms / (50 x WPM) = 1200 / WPM.
unsigned long unitMs(int wpm) { return 1200 / wpm; }

// How many bytes the character at the start of text takes. The Serial Monitor sends text as
// UTF-8: 1 byte for A-Z, figures, punctuation and spaces; 2 for é (0xC3 0xA9); up to 4 for emoji.
int charBytes(const char* text) {
  int n = 1;
  if ((unsigned char)text[0] >= 0xC0)        // first byte of a longer character...
    while ((text[n] & 0xC0) == 0x80) n++;   // ...its next bytes all start with the bits 10
  return n;
}

// The dots and dashes of the character at the start of text, or NULL if it has no Morse code
// (other accented letters, emoji...). Lowercase letters count as uppercase, and é as É.
const char* morseFor(const char* text) {
  int n = charBytes(text);
  if (n > 2) return NULL;
  char key[3] = {(char)toupper((unsigned char)text[0]), n == 2 ? text[1] : (char)0, 0};
  if (strcmp(key, "é") == 0) strcpy(key, "É");
  for (int i = 0; i < MORSE_COUNT; i++)
    if (strcmp(MORSE[i][0], key) == 0) return MORSE[i][1];
  return NULL;
}

// The character for some dots and dashes ("É" is 2 bytes), or "?" if no character has them.
const char* letterFor(const char* code) {
  for (int i = 0; i < MORSE_COUNT; i++)
    if (strcmp(MORSE[i][1], code) == 0) return MORSE[i][0];
  return "?";
}

// How long a message lasts, in units, with exactly the rules sendMorse() uses below
// (characters with no Morse code skipped, several spaces = one word gap, a word gap at the end).
int morseUnits(const char* text) {
  int units = 0, gapBefore = 0;  // gapBefore = silence to leave before the next letter
  for (int i = 0; text[i] != 0; i += charBytes(text + i)) {
    if (text[i] == ' ') { if (gapBefore > 0) gapBefore = WORD_GAP; continue; }
    const char* code = morseFor(text + i);
    if (code == NULL) continue;
    units += gapBefore;
    for (int k = 0; code[k] != 0; k++) units += (k > 0 ? ELEMENT_GAP : 0) + (code[k] == '.' ? DOT : DASH);
    gapBefore = LETTER_GAP;
  }
  return gapBefore > 0 ? units + WORD_GAP : 0;
}

// ---------- Variables ----------
int sendWpm = SEND_WPM;            // changed with /wpm
bool quiet = false;                // /quiet: buzzer off, the LED still works
String beaconMessage = DEFAULT_MESSAGE;
bool beaconOn = false;
unsigned long nextBeaconAt = 0;    // when the beacon plays the message again
unsigned long lastActivity = 0;    // for the deep sleep timer

// Button decoder
bool keyDown = false;              // the button, after debouncing
bool lastRaw = false;              // the button, as read just now
unsigned long lastChange = 0;      // when the raw reading last changed
unsigned long pressStart = 0, releasedAt = 0;
bool ignorePress = false;          // this press stops the beacon: do not decode it
String tapped = "";                // dots and dashes of the letter being tapped
String tappedWord = "";                  // letters of the word being tapped

// ---------- Small helpers ----------
// LED and buzzer together (the buzzer only if not /quiet).
void setSignal(bool on) {
  digitalWrite(LED_PIN, on ? HIGH : LOW);
  digitalWrite(BUZZER_PIN, (on && !quiet) ? BUZZER_ON : !BUZZER_ON);
}

bool buttonPressed() { return digitalRead(BUTTON_PIN) == LOW; }

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(unsigned long ms) {
  unsigned long start = millis();
  while (millis() - start < ms) {
    if (buttonPressed()) return true;
    delay(1);
  }
  return false;
}

void printHelp() {
  Serial.println("Type a message and press Enter: I send it in Morse.");
  Serial.println("Commands: /wpm 15 (speed 5-20)  /quiet  /loud  /help");
  Serial.println("Button: tap Morse yourself. Hold 3 s = beacon mode, tap to stop it.");
}

// ---------- Sending Morse: LED + buzzer ----------
// Plays a text in Morse. Returns true if the button stopped it.
bool sendMorse(const char* text) {
  unsigned long unit = unitMs(sendWpm);
  int gapBefore = 0;  // silence to leave before the next letter (0 before the first one)
  for (int i = 0; text[i] != 0; i += charBytes(text + i)) {
    if (text[i] == ' ') { if (gapBefore > 0) gapBefore = WORD_GAP; continue; }
    const char* code = morseFor(text + i);
    if (code == NULL) continue;  // no Morse code for it: skip
    if (waitOrPress(gapBefore * unit)) return true;
    for (int k = 0; code[k] != 0; k++) {
      if (k > 0 && waitOrPress(ELEMENT_GAP * unit)) return true;
      setSignal(true);
      bool pressed = waitOrPress((code[k] == '.' ? DOT : DASH) * unit);
      setSignal(false);
      if (pressed) return true;
    }
    gapBefore = LETTER_GAP;
  }
  return gapBefore > 0 && waitOrPress(WORD_GAP * unit);  // word gap at the end
}

// Shows "SOS -> ... --- ..." on the Serial Monitor, and lists the characters with no Morse code.
void printMorse(const char* text) {
  String skipped = "";
  Serial.print(text);
  Serial.print(" ->");
  for (int i = 0; text[i] != 0; i += charBytes(text + i)) {
    const char* code = morseFor(text + i);
    if (text[i] == ' ') Serial.print(" /");
    else if (code == NULL) for (int k = 0; k < charBytes(text + i); k++) skipped += text[i + k];
    else { Serial.print(" "); Serial.print(code); }
  }
  Serial.print("   (");
  Serial.print(morseUnits(text) * unitMs(sendWpm) / 1000.0, 1);
  Serial.println(" s)");
  if (skipped.length() > 0) { Serial.print("skipped: "); Serial.println(skipped); }
}

// Sends a text; if the button stops it, wait for the release so that press is not decoded.
void sendAndReport(const char* text) {
  if (sendMorse(text)) {
    Serial.println("Stopped by the button.");
    waitButtonRelease();
    keyDown = lastRaw = false;
    beaconOn = false;
  }
  lastActivity = millis();
}

// ---------- Typed lines and commands ----------
void handleLine(String line) {
  line.trim();  // removes spaces and line endings at both ends
  if (line.length() == 0) return;
  if (line.startsWith("/wpm")) {
    sendWpm = constrain(line.substring(4).toInt(), 5, 20);  // keeps it between 5 and 20
    Serial.print("Speed: ");
    Serial.print(sendWpm);
    Serial.println(" words per minute");
  } else if (line == "/quiet") {
    quiet = true;
    Serial.println("Buzzer off (the LED still flashes)");
  } else if (line == "/loud") {
    quiet = false;
    Serial.println("Buzzer on");
  } else if (line.startsWith("/")) {
    printHelp();
  } else {
    if (line.length() > MAX_LINE) {
      line = line.substring(0, MAX_LINE);
      Serial.println("Too long: only the first 100 characters are sent.");
    }
    beaconMessage = line;  // the beacon repeats this one until power-off, reset or sleep
    printMorse(line.c_str());
    sendAndReport(line.c_str());
  }
}

// ---------- Beacon mode ----------
void startBeacon() {
  setSignal(false);
  tapped = "";
  tappedWord = "";
  ignorePress = true;  // the long press itself is not a dash
  delay(200);
  setSignal(true);        // one short beep = beacon mode on
  delay(100);
  setSignal(false);
  beaconOn = true;
  nextBeaconAt = millis() + 1000;
  Serial.print("Beacon mode: ");
  Serial.println(beaconMessage);
}

void stopBeacon() {
  beaconOn = false;
  ignorePress = true;  // the stop press is not decoded
  Serial.println("Beacon stopped.");
}

// ---------- The button as a Morse key ----------
void readKey() {
  unsigned long now = millis();
  bool raw = buttonPressed();
  if (raw != lastRaw) { lastRaw = raw; lastChange = now; }

  if (raw != keyDown && now - lastChange >= DEBOUNCE_MS) {  // a real change
    keyDown = raw;
    lastActivity = now;
    if (keyDown) {  // just pressed
      pressStart = now;
      if (beaconOn) stopBeacon();
      else setSignal(true);  // the LED and buzzer follow your finger
    } else {        // just released
      setSignal(false);
      if (ignorePress) { ignorePress = false; return; }
      unsigned long unit = unitMs(KEY_WPM);
      char symbol = (now - pressStart < DASH_AT_UNITS * unit) ? '.' : '-';
      tapped += symbol;
      Serial.print(symbol);  // show each dot or dash at once
      releasedAt = now;
    }
  }

  unsigned long unit = unitMs(KEY_WPM);
  if (keyDown && !ignorePress && now - pressStart >= HOLD_FOR_BEACON_MS) startBeacon();
  if (!keyDown && tapped.length() > 0 && now - releasedAt >= LETTER_END_UNITS * unit) {
    const char* letter = letterFor(tapped.c_str());  // "?" if the dots and dashes mean nothing
    Serial.print("  ");
    Serial.println(letter);
    tappedWord += letter;
    tapped = "";
  }
  if (!keyDown && tappedWord.length() > 0 && now - releasedAt >= WORD_END_UNITS * unit) {
    Serial.print("Word: ");
    Serial.println(tappedWord);
    tappedWord = "";
  }
}

// ---------- Deep sleep ----------
void goToSleep() {
  Serial.println("Nothing for 3 minutes: sleeping. Press the button to wake me up.");
  for (int i = 0; i < 2; i++) {  // two blinks = going to sleep
    digitalWrite(LED_PIN, HIGH);
    delay(150);
    digitalWrite(LED_PIN, LOW);
    delay(150);
  }
  // Freeze the buzzer OFF and the LED off during sleep (else the pins could float).
  digitalWrite(BUZZER_PIN, !BUZZER_ON);
  gpio_hold_en(BUZZER_PIN);
  gpio_hold_en(LED_PIN);
  gpio_deep_sleep_hold_en();
  // Keep the "RTC" part powered so the button's pull-up keeps working (a few microamps).
  esp_sleep_pd_config(ESP_PD_DOMAIN_RTC_PERIPH, ESP_PD_OPTION_ON);
  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);
  esp_sleep_enable_ext0_wakeup(BUTTON_PIN, LOW);  // wake up when the button pulls GPIO27 LOW
  Serial.flush();
  esp_deep_sleep_start();  // the ESP32 stops here; waking up starts setup() again
}

// ---------- setup(): runs at power-on, reset and every wake-up ----------
void setup() {
  setCpuFrequencyMhz(80);  // slower = less current. Wi-Fi and Bluetooth stay off.
  Serial.begin(115200);
  // Unfreeze the outputs, and give the button pin back to normal code.
  gpio_hold_dis(BUZZER_PIN);
  gpio_hold_dis(LED_PIN);
  rtc_gpio_deinit(BUTTON_PIN);
  pinMode(BUZZER_PIN, OUTPUT);
  pinMode(LED_PIN, OUTPUT);
  setSignal(false);
  pinMode(BUTTON_PIN, INPUT_PULLUP);  // built-in pull-up: pressed = LOW

  if (esp_sleep_get_wakeup_cause() == ESP_SLEEP_WAKEUP_EXT0) waitButtonRelease();  // woken by the button
  Serial.println();
  Serial.println("Morse spy beacon ready.");
  sendAndReport("OK");  // self-test: --- -.- on the LED and buzzer
  printHelp();
  lastActivity = millis();
}

// ---------- loop(): runs again and again ----------
void loop() {
  if (Serial.available()) {  // a typed line (the Serial Monitor sends it when you press Enter)
    lastActivity = millis();
    handleLine(Serial.readStringUntil('\n'));
  }
  readKey();
  if (beaconOn && !keyDown && (long)(millis() - nextBeaconAt) >= 0) {
    sendAndReport(beaconMessage.c_str());
    nextBeaconAt = millis() + BEACON_PAUSE_MS;
  }
  if (SLEEP_AFTER_MS > 0 && !beaconOn && !keyDown && millis() - lastActivity >= SLEEP_AFTER_MS) goToSleep();
}

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 radio, portée du capteur de lumière) peuvent changer. Le code suppose que le buzzer sonne quand sa broche S est HIGH. Vérifie-le sur ton module (étape 9) et change la constante BUZZER_ON si c’est l’inverse.

Liste de contrôle

  • La carte joue OK à la mise sous tension
  • Un mot tapé s’affiche en points et en traits sur le moniteur et correspond aux éclairs
  • Quand tu appuies sur le bouton, la DEL et le buzzer suivent ton doigt, et la bonne lettre apparaît sur le moniteur
  • Un maintien de 3 s lance la balise ; elle se répète toutes les 5 s ; un appui l’arrête
  • Après un reset, la balise rejoue HELLO AGENT (un message tapé est oublié)
  • /wpm change la vitesse et /quiet coupe le buzzer
  • Après 3 minutes sans rien, la DEL clignote deux fois et la carte s’endort ; le bouton la réveille
  • Sur piles, le fil rouge du bloc est dans la rangée 5V et le bloc est sur OFF dès que le câble USB est branché

Dépannage

Rien ne se passe quand j’appuie sur EN
Vérifie que le moniteur série est à 115200 bauds et que le code est bien téléversé (« Done uploading »). Essaie un autre port USB, et un câble données (pas charge seule).
Je tape un message et rien ne part
Règle la fin de ligne du moniteur série sur « Nouvelle ligne » (« Newline »), puis appuie sur Entrée. La ligne ne doit pas commencer par / sauf s’il s’agit d’une commande.
La DEL marche mais pas le buzzer (ou l’inverse)
Vérifie les fils 4, 5 et 6 du buzzer, le fil 7 et les pattes de la DEL (patte longue du côté de la résistance). Un buzzer qui sonne quand il devrait se taire fonctionne à l’envers : change BUZZER_ON (étape 10).
Mes lettres tapées sortent fausses
La carte attend environ 8 WPM : tape lentement et laisse un vrai silence entre les lettres. Un point est un appui rapide, un trait dure environ trois fois plus. Le moniteur affiche les points et les traits qu’il a entendus, tu peux donc voir ce qui a cloché.
La balise ne démarre pas
Maintiens le bouton enfoncé 3 secondes pleines sans lâcher, puis attends le bip de confirmation.
La carte semble morte au bout de quelques minutes
Elle est passée en sommeil profond après 3 minutes sans rien : appuie sur le bouton. Mets SLEEP_AFTER_MS à 0 si tu ne veux pas de ça.
Les piles sont vides au bout d’une nuit
Une balise laissée en marche vide un bloc 4×AA en environ deux jours, et l’interrupteur du bloc s’oublie facilement. Mets le bloc sur OFF quand tu arrêtes de jouer.
Les cartes radio ne s’entendent pas (Pour aller plus loin 1)
Vérifie que le même croquis est sur les deux et que le numéro GROUP est identique (taper /group 0 sur les deux cartes les met d’accord). Rapproche-les. Une lettre manquante veut juste dire qu’un paquet s’est perdu : retape-la.
Le récepteur de lumière rate des lettres (Pour aller plus loin 2)
Mets l’émetteur à 10 WPM (le récepteur lit de 7 à 12 WPM, et la LDR est trop lente au-dessus de 10), raccourcis la distance (5–30 cm), utilise une pièce tamisée et ajuste bien le tube sur la LDR. Calibre à nouveau, DEL de l’émetteur éteinte.

Pour aller plus loin 1 : du Morse par radio entre deux cartes

Deux cartes, chacune avec le montage de base, se parlent par radio. Pas de routeur, pas d’internet, pas de mot de passe : les cartes utilisent un protocole d’Espressif appelé ESP-NOW, qui fonctionne sans point d’accès. Appuie sur la clé d’une carte et la DEL et le buzzer de l’autre suivent ton doigt, en direct.

Pour aller plus loin 1 : le morse par radio entre deux cartes (ESP-NOW) Deux montages de base identiques, A et B, avec le même programme. Quand tu appuies sur le bouton de A, A diffuse un petit événement de touche par ESP-NOW, le protocole Wi-Fi sans connexion d'Espressif : pas de routeur, pas d'internet, pas de mot de passe. La DEL et le buzzer de B suivent ton doigt en direct. Une ligne tapée part en texte, jusqu'à 100 octets, sous la limite de 250 octets, et l'autre carte la joue en morse et l'affiche. Les paquets vont à l'adresse de diffusion FF:FF:FF:FF:FF:FF sur le canal 1 ; un octet GROUP de 0 à 9 sépare deux paires dans une même salle, et chaque carte ignore ses propres paquets. La livraison n'est pas garantie : s'il manque une lettre, tape-la de nouveau. La portée en intérieur est en général de quelques dizaines de mètres. FIG. 4 — POUR ALLER PLUS LOIN 1 : MORSE PAR RADIO (ESP-NOW)Deux cartes se parlent par radio, sans routeurESP32ESP32Carte A : tu appuiesCarte B : elle suitmême montage, même programme (08b)DEL + buzzer suivent A en directdiffusion FF:FF:FF:FF:FF:FF · canal 1Événement de touche (en direct)GROUP 3appuiseq 42puis « relâché », seq 43 (+1) : B relâcheLigne tapée (texte)GROUP 3HELLO AGENT≤ 100 octets (limite ESP-NOW : 250)pas de routeur · pas d'internet · pas de mot de passebouton ADEL BB suit avec quelques ms de retardUn programme, deux cartesChaque carte ignore ses proprespaquets. La carte d'un ami marche.Octet GROUP 0–9Deux paires dans la même sallechoisissent des groupes différents.Livraison non garantieUne lettre manque ? Retape-la.Portée : dizaines de mètres en intérieur (typ.).
Touche le schéma pour l’ouvrir en plein écran.
3 étapes bonus · 2 morceaux de code · Deuxième carte nécessaire
  1. Étape B1 · Monte la deuxième carte.

    Même montage de base, même câblage, mêmes trous. Téléverse d’abord le croquis de base sur chacune, pour vérifier que chacune fonctionne seule (étapes 8 à 11).

    Vérifie : Chaque carte dit OK et envoie seule un message tapé.

  2. Étape B2 · Charge le croquis radio sur les deux.

    Ouvre « 08b-morse-radio » et téléverse-le sur les deux cartes, une à la fois, l’autre débranchée. C’est le même croquis sur les deux. Facultatif : change le numéro GROUP (0–9) dans le code, ou tape /group 3 dans le moniteur série (jusqu’au prochain reset), pour que deux paires dans la même pièce ne s’entendent pas. Les deux cartes d’une paire doivent avoir le même numéro.

    Vérifie : Les deux cartes disent OK au démarrage.

  3. Étape B3 · Tape et écoute.

    Place les cartes à quelques mètres l’une de l’autre, en USB ou sur piles. Appuie sur le bouton de la carte A : la DEL et le buzzer de la carte B suivent ton doigt. Puis tape une ligne dans le moniteur série de la carte A : la carte B la joue en Morse et l’affiche. Échangez les rôles.

    Vérifie : La carte B copie la carte A, et inversement.

La livraison radio n’est pas garantie : un paquet peut se perdre, et le croquis ne le renvoie pas. S’il manque une lettre, retape-la. En intérieur, la portée est probablement de quelques dizaines de mètres (valeur typique, à confirmer en construisant). Une carte à l’écoute sur piles consomme beaucoup plus que dans le montage de base (voir le tableau plus haut) : éteins-la entre les parties. Même règle que pour la base : pas de SOS pour s’amuser. Ce croquis n’a ni mode balise ni sommeil profond : la carte écoute en permanence.

  1. Bloc bonus 1 Envoyer et recevoir par radio

    sendPacket() prépare un petit paquet (une étiquette, le numéro de groupe et le genre de message : bouton appuyé, bouton relâché ou texte tapé) et le diffuse à toutes les cartes à portée. onReceive() s’exécute à chaque arrivée d’un paquet : elle ignore tes propres paquets et les autres groupes, compte les messages du bouton perdus et passe une ligne tapée à loop() pour qu’elle la joue. startRadio() démarre la radio Wi-Fi en mode station (elle ne rejoint jamais de réseau), sur le canal 1, et enregistre l’adresse de diffusion. À changer : GROUP, ou tape /group 3, si deux paires partagent une pièce

    Voir le code (55 lignes)
    // ---------- Radio: send and receive ----------
    void sendPacket(uint8_t kind, const char* text) {
      Packet p;
      p.tag[0] = 'T';
      p.tag[1] = 'M';
      p.group = group;
      p.kind = kind;
      p.seq = (kind == TEXT) ? 0 : ++mySeq;
      int len = HEADER_SIZE;
      if (kind == TEXT) {
        strncpy(p.text, text, MAX_LINE);
        p.text[MAX_LINE] = 0;
        len += strlen(p.text) + 1;  // only the letters used, not the whole box
      }
      esp_now_send(BROADCAST, (uint8_t*)&p, len);
    }
    
    // Called by the radio each time a message arrives. Keep it short: no delay(), no Morse here.
    void onReceive(const esp_now_recv_info_t* info, const uint8_t* data, int len) {
      if (memcmp(info->src_addr, myMac, 6) == 0) return;  // our own message: ignore
      if (len < HEADER_SIZE || len > (int)sizeof(Packet)) return;
      Packet p;
      memset(&p, 0, sizeof(p));
      memcpy(&p, data, len);
      if (p.tag[0] != 'T' || p.tag[1] != 'M' || p.group != group) return;  // not for us
      if (p.kind == KEY_DOWN || p.kind == KEY_UP) {
        if (p.seq == lastSeq) return;  // the same message twice
        if (lastSeq >= 0 && p.seq != (uint8_t)(lastSeq + 1)) lostKeyMessages = lostKeyMessages + 1;
        lastSeq = p.seq;
        remoteDown = (p.kind == KEY_DOWN);
        remoteChangedAt = millis();
      } else if (p.kind == TEXT && !textWaiting) {
        strncpy(incoming, p.text, MAX_LINE);
        incoming[MAX_LINE] = 0;
        textWaiting = true;  // loop() plays it
      }
    }
    
    void startRadio() {
      WiFi.mode(WIFI_STA);  // "station" mode, but we never join a Wi-Fi network
      WiFi.setChannel(RADIO_CHANNEL);
      while (!WiFi.STA.started()) delay(100);
      WiFi.macAddress(myMac);
      if (esp_now_init() != ESP_OK) {
        Serial.println("ESP-NOW did not start: press EN to restart.");
        return;
      }
      esp_now_register_recv_cb(onReceive);
      esp_now_peer_info_t peer = {};  // the "every board" address must be added once
      memcpy(peer.peer_addr, BROADCAST, 6);
      peer.channel = RADIO_CHANNEL;
      peer.ifidx = WIFI_IF_STA;
      peer.encrypt = false;
      esp_now_add_peer(&peer);
    }
  2. Bloc bonus 2 La clé : ton bouton et celui de l’autre carte

    Ton bouton et celui de l’autre carte se mélangent en un seul signal « dans l’air ». Quand l’un des deux est appuyé, la DEL et le buzzer des deux cartes suivent, et les deux moniteurs série décodent les points, les traits et les lettres. Si un message « relâché » se perd, le son s’arrête tout seul au bout de 3 secondes. À changer : rien

    Voir le code (40 lignes)
    // ---------- The key: your button + the other board's button ----------
    void updateKey() {
      unsigned long now = millis();
      bool raw = digitalRead(BUTTON_PIN) == LOW;
      if (raw != lastRaw) { lastRaw = raw; lastChange = now; }
      if (raw != localDown && now - lastChange >= DEBOUNCE_MS) {
        localDown = raw;
        sendPacket(localDown ? KEY_DOWN : KEY_UP, "");  // tell the other board at once
      }
      if (remoteDown && now - remoteChangedAt > REMOTE_KEY_TIMEOUT_MS) {
        remoteDown = false;  // the "released" message was lost
        Serial.println("(radio: a message was lost)");
      }
    
      bool busy = localDown || remoteDown;  // somebody is pressing
      unsigned long unit = unitMs(KEY_WPM);
      if (busy != airOn) {
        airOn = busy;
        setSignal(airOn);
        if (airOn) onSince = now;
        else {
          char symbol = (now - onSince < DASH_AT_UNITS * unit) ? '.' : '-';
          tapped += symbol;
          Serial.print(symbol);
          offSince = now;
        }
      }
      if (!airOn && tapped.length() > 0 && now - offSince >= LETTER_END_UNITS * unit) {
        const char* letter = letterFor(tapped.c_str());
        Serial.print("  ");
        Serial.println(letter);
        tappedWord += letter;
        tapped = "";
      }
      if (!airOn && tappedWord.length() > 0 && now - offSince >= WORD_END_UNITS * unit) {
        Serial.print("Word: ");
        Serial.println(tappedWord);
        tappedWord = "";
      }
    }

Télécharger le croquis radio (.ino)

Rends-la permanente

Sur une plaque d’essai, un choc peut arracher un fil. Ici, tu soudes le même circuit sur une demi-plaque perforée, tu enfiches l’ESP32 dans des supports (pour pouvoir le retirer), tu mets le bloc 4×AA en dessous, et tu fermes le tout dans un petit boîtier imprimé en 3D. Le plan des trous et les fichiers du boîtier sont encore à venir. 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.
9 étapes · +2–3 h · fer à souder · demande de l’aide

Pièces pour la version permanente

Les pièces du montage de base (ESP32, DEL, résistance 220 Ω, buzzer, bouton, support 4×AA et piles) passent sur la nouvelle plaque. Tu ajoutes :

Voir les 6 pièces
  • 1

    Plaque perforée à motif de plaque d’essai, demi-format×1

    Remplace la plaque d’essai

    Spécification exacte : Mêmes rangées, mêmes bandes de 5 trous et mêmes rails qu’une plaque d’essai, en demi-format. Taille exacte à vérifier sur la fiche avant d’acheter ; le plan des trous s’y adaptera.

  • 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. Coupe à la pince coupante ; tu perds un trou à chaque coupe.

  • 3

    Bornier à vis, pas de 5,0 / 5,08 mm, 2 pôles×1

    Le bloc de piles se branche sans souder ses 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, 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 M3à confirmer avec les fichiers du boîtier

    Fermer le boîtier et y fixer la plaque

    Spécification exacte : Nombre et type de tête à confirmer quand le boîtier sera terminé.

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

Le plan des trous pour la demi-plaque perforée arrivera avec les fichiers du boîtier. Ce ne sera pas une copie trou pour trou de la plaque d’essai 830.

É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 et du buzzer.

    Enfonce les deux barrettes femelles 1×19 sur les broches de l’ESP32 (elles restent bien alignées), pose-les sur la plaque aux positions du plan des trous, retourne le tout et soude une broche à chaque bout, vérifie que ça tient à plat, puis soude le reste. Même chose pour la barrette de 3 trous du buzzer. Retire l’ESP32 et mets-le de côté. Les noms des trous arriveront avec le plan des trous.

    Vérifie : Les supports sont droits, et chaque broche est un petit cône brillant de soudure, pas une boule.

  3. Étape P3 · Soude le bornier, la résistance, la DEL et le bouton.

    Bornier pour le bloc (+ vers le support 5V, − vers GND), résistance et DEL (patte longue du côté de la résistance), bouton à cheval sur la rainure. Les noms des trous arriveront avec le plan des trous.

    Vérifie : La patte longue de la DEL est du côté de la résistance, et le bouton est à plat.

  4. Étape P4 · Soude les fils.

    Fil isolé 22 AWG, à plat sur le dessus, soudé par en dessous. Les mêmes dix fils que le montage de base : rails 3V3 et GND, buzzer, DEL et bouton. Le + du bloc va au support 5V et jamais près du rail 3V3. La liste des fils avec les noms des trous arrivera avec le plan des trous.

    Vérifie : Tous les fils sont en place, et le fil + du bloc ne touche rien d’autre que le support 5V.

  5. Étape P5 · 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.

  6. Étape P6 · Contrôles au multimètre, bloc sur OFF et ESP32 non enfiché. Demande de l’aide

    Mode continuité (bip). Ne doit PAS biper : rail + vers rail − ; le support 5V vers le rail + ; le support 5V vers le rail −. Doit biper : le + du bornier vers le support 5V, le − du bornier vers GND, le support 3V3 vers le rail +, le support GPIO26 vers la résistance. Le bouton, support GPIO27 vers GND, bipe seulement quand on appuie.

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

  7. Étape P7 · Contrôle le bloc, puis le test clé. Demande de l’aide

    Mets les piles dans le support, 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 le bornier (rouge = +). Maintenant le test clé, l’ESP32 toujours retiré : bloc sur ON, mesure le support 5V contre GND (tu lis la tension du bloc), puis 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.

  8. Étape P8 · Enfiche l’ESP32 et refais les tests.

    Bloc sur OFF. Enfiche l’ESP32 dans ses supports, côté USB en premier. Mets le bloc sur ON : la DEL rouge d’alimentation s’allume et le rail + affiche 3,2–3,4 V. Puis reprends les étapes 9 à 14 du montage de base avec ta carte soudée.

    Vérifie : Elle se comporte exactement comme la version sur plaque d’essai.

  9. Étape P9 · Mets-la dans le boîtier.

    Les fichiers du boîtier (un petit boîtier imprimé en 3D pour la demi-plaque perforée) sont encore à venir. Le plan : la DEL dans un trou de 5 mm sur le dessus (avec en option un capuchon imprimé pour la viser), le bouton accessible sur le dessus par un poussoir imprimé, des trous de grille pour le buzzer, le port USB et l’interrupteur du bloc accessibles de l’extérieur, une trappe pour les piles, et quelques fentes d’aération. La carte consomme bien moins d’un demi-watt, donc elle reste froide, mais les fentes restent ouvertes quand même.

    Vérifie : Le bouton, la DEL, le port USB et l’interrupteur du bloc sont tous accessibles, et les fentes d’aération sont ouvertes.

Fichiers 3D

Fichiers à venir : petit boîtier pour la demi-plaque perforée, poussoir du bouton, capuchon de DEL facultatif, trappe des piles.

Pour aller plus loin 2 : lire le Morse avec un capteur de lumière

Une deuxième carte regarde la DEL de la première avec un capteur de lumière et décode les éclairs en lettres. Même principe qu’une lampe de signalisation entre deux bateaux, avec un ESP32 comme marin.

Pour aller plus loin 2 : lire le morse lumineux avec une deuxième carte La carte A clignote du morse avec sa DEL jaune. La carte B pointe un capteur de lumière, une photorésistance GL5528 ou LDR, à travers un petit tube opaque vers cette DEL, à 5 à 30 centimètres, dans une pièce sombre. La LDR et une résistance de 10 kilohms forment un pont diviseur entre le 3V3 et la masse ; leur point milieu va sur GPIO34, une entrée seule de l'ADC1. Plus de lumière, c'est une LDR plus faible et une tension plus haute, jamais au-dessus de 3,3 V : la broche ne risque rien. Le graphique montre analogRead sur GPIO34 dans le temps : le programme mesure d'abord le niveau sombre pendant 2 secondes, émetteur éteint, place un seuil à mi-chemin entre le sombre et la première lecture claire, avec une bande d'hystérésis d'environ 10 pour cent de l'écart, puis décode allumé et éteint comme le bouton. La LDR est lente : l'émetteur reste à 10 mots par minute ou moins. FIG. 5 — POUR ALLER PLUS LOIN 2 : RÉCEPTEUR DE LUMIÈRE (GPIO34)La carte B lit les éclats de la carte AESP32Carte A : émet (≤ 10 WPM)5–30 cmtube opaque 3–5 cmpaille, papier noirESP3210 kΩCarte B : reçoit (08c)Pièce sombre. Le soleil ou une lampe dans le tube le perturbent.Pont diviseur3V3LDRGL552810 kΩGPIO34ADC1, entrée seulePlus de lumière → LDR ↓ → tension ↑U34 = 3,3 V × 10 kΩ ÷ (R_LDR + 10 kΩ)jamais plus de 3,3 V : sans dangerComment B trouve son seuil1 · calibrage 2 s, émetteur éteint : niveau sombre2 · premier éclat : niveau clair3 · seuil à mi-chemin, hystérésis ≈ 10 % de l'écart4 · décode allumé / éteint comme le bouton (RX_WPM 10)analogRead(34)temps →sombreclairseuilcalibragedécodé→ − · − = Kfronts lents : réponse de la LDR (dizaines de ms)→ émetteur à 10 WPM ou moins
Touche le schéma pour l’ouvrir en plein écran.
4 étapes bonus · 2 morceaux de code · Deuxième carte + LDR · Niveau 2

Liste des fils

#CouleurDeVers
R1 rougeLDR patte 1rail 3V3
R2 bleuLDR patte 2 et résistance 10 kΩ patte 1 (même rangée)GPIO34 (j15)
R3 noirrésistance 10 kΩ patte 2rail GND

Plus la lumière sur la LDR est forte, plus la tension sur GPIO34 monte, sans jamais dépasser 3,3 V : aucun risque. Enfile le tube opaque sur la LDR et vise la DEL de l’émetteur, à 5–30 cm. Utilise-la dans une pièce tamisée.

  1. Étape L1 · Monte la carte réceptrice.

    Le montage de base plus les fils R1 à R3. Garde le buzzer, la DEL et le bouton : le récepteur reproduit aussi ce qu’il voit.

    Vérifie : La LDR est câblée comme dans le tableau, et rien d’autre ne touche GPIO34.

  2. Étape L2 · Charge le croquis récepteur de lumière.

    Téléverse « 08c-morse-light » sur la carte réceptrice. L’émetteur garde le croquis de base.

    Vérifie : Au démarrage, le moniteur indique que le récepteur se calibre.

  3. Étape L3 · Calibre.

    Allume le récepteur avec la DEL de l’émetteur éteinte. Pendant 2 secondes, il apprend l’obscurité de ta pièce. Puis fais clignoter l’émetteur (appuie sur son bouton, ou tape E dans son moniteur série) : la première lecture claire fixe la limite entre sombre et lumineux. Vise la DEL avec le tube. Si tu déplaces les cartes ou que la lumière de la pièce change, tape /cal ou appuie sur le bouton du récepteur pour calibrer à nouveau.

    Vérifie : Le moniteur affiche les niveaux sombre et clair, puis « Ready: listening for Morse light. »

  4. Étape L4 · Envoie et lis.

    Sur l’émetteur, tape un message à sa vitesse par défaut, 10 WPM : c’est celle qu’attend le récepteur (RX_WPM). Il lit des émetteurs de 7 à 12 WPM, mais la LDR traîne au-dessus de 10 : reste à 10 WPM ou moins. Pour lire un émetteur plus lent, règle le récepteur à la même vitesse avec /wpm (5 à 10). Le récepteur affiche les lettres et les reproduit sur sa propre DEL et son buzzer.

    Vérifie : Les lettres du récepteur correspondent au message.

Une LDR réagit lentement (quelques dizaines de millisecondes, valeur typique) : garde l’émetteur à 10 WPM ou moins. Le soleil direct ou une lampe qui scintille peuvent la tromper : utilise une pièce tamisée et un tube court. Pas de laser ici : la DEL fait la lumière de cette mission.

  1. Bloc bonus 1 Apprendre le sombre et le clair

    calibrate() fait la moyenne du capteur de lumière pendant 2 secondes, DEL de l’émetteur éteinte (le niveau sombre), attend la première lecture nettement plus claire (au moins MIN_JUMP de plus), garde la valeur la plus haute pendant 50 ms comme niveau clair et place la limite à mi-chemin entre les deux. Elle attend ensuite la fin de cet éclair pour qu’il ne soit pas décodé. À changer : MIN_JUMP, si ta pièce est très lumineuse

    Voir le code (44 lignes)
    // ---------- Calibration: learn "dark" and "bright" ----------
    void calibrate() {
      setSignal(false);
      Serial.println("Calibration: keep board A's LED OFF for 2 seconds...");
      delay(500);
      long sum = 0;
      int count = 0;
      unsigned long start = millis();
      while (millis() - start < 2000) {  // average of many readings = the dark level
        sum += analogRead(LIGHT_PIN);
        count++;
        delay(SAMPLE_MS);
      }
      darkLevel = sum / count;
      Serial.print("Dark level: ");
      Serial.println(darkLevel);
    
      Serial.println("Now make board A flash (tap its button, or type E in its Serial Monitor)...");
      unsigned long lastHint = millis();
      int v = analogRead(LIGHT_PIN);
      while (v < darkLevel + MIN_JUMP) {  // wait for a clearly brighter reading
        if (millis() - lastHint > 5000) {
          Serial.println("...still waiting for a flash (aim the tube at the LED, dim the room)");
          lastHint = millis();
        }
        delay(SAMPLE_MS);
        v = analogRead(LIGHT_PIN);
      }
      // The LDR needs a few ms to reach full brightness: keep the highest reading for 50 ms.
      brightLevel = v;
      for (int i = 0; i < 25; i++) {
        int r = analogRead(LIGHT_PIN);
        if (r > brightLevel) brightLevel = r;
        delay(SAMPLE_MS);
      }
      printLevels();
      // Wait for the end of that flash, so it is not decoded.
      while (analogRead(LIGHT_PIN) > (darkLevel + brightLevel) / 2) delay(SAMPLE_MS);
      lightOn = false;
      offSince = millis();
      tapped = "";
      tappedWord = "";
      Serial.println("Ready: listening for Morse light.");
    }
  2. Bloc bonus 2 De la lumière aux lettres

    readLight() lit le capteur toutes les 2 ms et décide allumé ou éteint avec la limite plus une bande de 10 % contre le scintillement. Lumière allumée, c’est comme un bouton appuyé : elle mesure chaque éclair et chaque silence comme le décodeur du bouton du croquis de base, mais coupe aux points médians (2, 2 et 5 unités), parce que la LDR lente allonge les éclairs et raccourcit les silences. Les niveaux sombre et clair suivent lentement, et elle recalibre s’ils se rapprochent trop. Avec RX_WPM = 10, elle lit des émetteurs de 7 à 12 WPM. À changer : RX_WPM (ou /wpm sur le récepteur, de 5 à 10)

    Voir le code (49 lignes)
    // ---------- Reading the light: on or off? ----------
    void readLight() {
      int v = analogRead(LIGHT_PIN);
      int span = brightLevel - darkLevel;
      int threshold = darkLevel + span / 2;  // halfway between dark and bright
      int margin = span / 20;                // +/- 5 % = 10 % "hysteresis" band against flicker
      unsigned long now = millis();
      unsigned long unit = unitMs(rxWpm);
    
      if (!lightOn && v > threshold + margin) {  // the light just came on
        lightOn = true;
        onSince = now;
        peak = v;
        setSignal(true);
      } else if (lightOn && v < threshold - margin) {  // the light just went off
        lightOn = false;
        setSignal(false);
        char symbol = (now - onSince < DASH_AT_UNITS * unit) ? '.' : '-';
        tapped += symbol;
        Serial.print(symbol);
        offSince = now;
        // Adaptive threshold: move the bright level a quarter of the way toward this flash.
        brightLevel = brightLevel + (peak - brightLevel) / 4;
      } else if (lightOn) {
        if (v > peak) peak = v;  // remember the brightest reading of this flash
      } else {
        // Light off: follow the room light slowly (1/64 of the difference each reading).
        darkLevel = darkLevel + (v - darkLevel) / 64;
      }
      if (brightLevel - darkLevel < MIN_JUMP / 2) {  // the two levels got too close
        Serial.println();
        Serial.println("Signal too weak: measuring again.");
        calibrate();
        return;
      }
    
      if (!lightOn && tapped.length() > 0 && now - offSince >= LETTER_END_UNITS * unit) {
        const char* letter = letterFor(tapped.c_str());
        Serial.print("  ");
        Serial.println(letter);
        tappedWord += letter;
        tapped = "";
      }
      if (!lightOn && tappedWord.length() > 0 && now - offSince >= WORD_END_UNITS * unit) {
        Serial.print("Word: ");
        Serial.println(tappedWord);
        tappedWord = "";
      }
    }

Télécharger le croquis du récepteur lumière (.ino)

Pour aller plus loin

Idée pour plus tard (pas encore construite) : la même balise sur une minuscule carte ESP32-C3 SuperMini, de la taille d’une poche et tenant des mois sur piles. C’est un montage de niveau 2, comme la version de poche de la mission 01.

Tu pourras réutiliser ta DEL, ton buzzer et ton bouton.

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 29 articles
  • ×1Carte ESP32Amazon.fr
  • ×1Plaque d’essaiAmazon.fr
  • ×1DEL jaune 5 mmAmazon.fr
  • ×1Résistance 220 ΩAmazon.fr
  • ×1Module buzzer actifAmazon.fr
  • ×1Bouton poussoirAmazon.fr
  • environ 10Fils de connexionAmazon.fr
  • ×1Câble USB donnéesAmazon.fr
  • ×1Support 4×AA avec interrupteur ON/OFF, couvercle et extrémités à broches (facultatif)Amazon.fr
  • ×4Piles AA (facultatif)Amazon.fr
  • 1 lotDeuxième kit de base complet (carte, plaque, DEL, 220 Ω, buzzer, bouton, fils, câble USB) (facultatif)Amazon.fr
  • ×1Photorésistance (LDR), type GL5528 (facultatif)Amazon.fr
  • ×1Résistance 10 kΩ (facultatif)Amazon.fr
  • ×1Petit tube opaque, 3–5 cm (facultatif)Amazon.fr
  • ×1Ordinateur avec Arduino IDE—
  • ×1Étiquette autocollante et un stylo (facultatif)Amazon.fr
  • ×1Multimètre (facultatif)Amazon.fr
  • ×1Plaque perforée à motif de plaque d’essai, demi-format (Rends-la permanente)Amazon.fr
  • 2 barrettes : 1×40 + 1×20Barrette femelle, 2,54 mm (Rends-la permanente)Amazon.fr
  • ×1Bornier à vis, pas de 5,0 / 5,08 mm, 2 pôles (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
  • à confirmer avec les fichiers du boîtierVis 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
Balise morse d’espion
1 × Carte ESP32 — ESP32-DevKitC V4 ou un clone : ESP32-WROOM-32, 38 broches, logique 3,3 V. Vérifie le régulateur avant de l’utiliser avec 4 piles alcalines (é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 × Plaque d’essai — Format complet 830 points. Une carte 38 broches avec ses pièces ne tient pas sur une plaque de 400 points.
   https://www.amazon.fr/s?k=platine+d%E2%80%99essai+830+points
1 × DEL jaune 5 mm — 5 mm, un jaune « haute luminosité » quelconque. Tension directe d’environ 2,0–2,2 V (valeur typique, à vérifier sur la fiche de ta DEL). Le jaune se voit bien et se distingue du rouge de la mission 01, mais toute couleur marche avec la même résistance.
   https://www.amazon.fr/s?k=LED+5mm+jaune+haute+luminosit%C3%A9
1 × Résistance 220 Ω — 220 Ω, 1/4 W, traversante. Environ (3,3 − 2,1) / 220 ≈ 5,5 mA : assez lumineux en intérieur et bien en dessous des 20 mA habituels d’une DEL.
   https://www.amazon.fr/s?k=r%C3%A9sistance+220+ohm+1%2F4W
1 × Module buzzer actif — Module actif (son intégré), 3 broches S / + / −, 3,3–5 V, sonne quand S est HIGH. Certains modules fonctionnent à l’envers : tu le testes à l’étape 9 et tu peux le corriger à l’étape 10. Consomme environ 20–30 mA (valeur typique, à confirmer sur ton module).
   https://www.amazon.fr/s?k=module+buzzer+actif+3+broches
1 × Bouton poussoir — Bouton tactile 6 mm, 4 pattes. Pas de résistance : le code active la résistance de rappel interne de la carte.
   https://www.amazon.fr/s?k=bouton+poussoir+tactile+6mm
environ 10 × Fils de connexion — Mâle-mâle, 10–20 cm environ.
   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.
   https://www.amazon.fr/s?k=c%C3%A2ble+USB+data+micro+USB
1 × Support 4×AA avec interrupteur ON/OFF, couvercle et extrémités à broches (facultatif) — Le même support que la mission 01 (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 : change les piles avant d’en arriver là. Un support 3×AA ne suffit pas : il part à 4,5 V et passe sous la limite presque tout de suite.
   https://www.amazon.fr/s?k=support+4%C2%A0piles+AA+interrupteur+couvercle+broches+platine
4 × Piles AA (facultatif) — Piles AA alcalines (LR6), ou NiMH AA à faible autodécharge. Même type et même marque, 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
1 lot × Deuxième kit de base complet (carte, plaque, DEL, 220 Ω, buzzer, bouton, fils, câble USB) (facultatif) — Identique au montage de base. La carte d’un ami convient, à condition que ce soit un ESP32 38 broches avec le même câblage.
   https://www.amazon.fr/s?k=carte+ESP32+DevKitC+38+broches+WROOM-32
1 × Photorésistance (LDR), type GL5528 (facultatif) — GL5528 ou équivalent. Un peu lente (quelques dizaines de millisecondes, valeur typique, à vérifier sur la fiche), c’est pourquoi cette option reste à 10 WPM ou moins. Contient du sulfure de cadmium (voir Sécurité).
   https://www.amazon.fr/s?k=photor%C3%A9sistance+GL5528+LDR
1 × Résistance 10 kΩ (facultatif) — 10 kΩ, 1/4 W, traversante
   https://www.amazon.fr/s?k=r%C3%A9sistance+10k+ohm+1%2F4W
1 × Petit tube opaque, 3–5 cm (facultatif) — Une paille entourée de ruban noir, un rouleau de papier noir, ou un tube imprimé.
   https://www.amazon.fr/s?k=gaine+thermor%C3%A9tractable+noire+6mm
1 × Ordinateur avec Arduino IDE — Arduino IDE 2.x + « esp32 by Espressif » 3.3.x (téléchargement gratuit sur arduino.cc)
1 × Étiquette autocollante et un stylo (facultatif) — 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, demi-format (Rends-la permanente) — Mêmes rangées, mêmes bandes de 5 trous et mêmes rails qu’une plaque d’essai, en demi-format. Taille exacte à vérifier sur la fiche avant d’acheter ; le plan des trous s’y adaptera.
   https://www.amazon.fr/s?k=platine+perma-proto+demi+format
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. Coupe à la pince coupante ; tu perds un trou à chaque coupe.
   https://www.amazon.fr/s?k=barrette+femelle+1x40+2.54mm
1 × Bornier à vis, pas de 5,0 / 5,08 mm, 2 pôles (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
1 lot × Fil de câblage rigide, 22 AWG, plusieurs couleurs (Rends-la permanente) — Isolé, rouge, noir, 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
à confirmer avec les fichiers du boîtier × Vis M3 (Rends-la permanente) — Nombre et type de tête à confirmer quand le boîtier sera terminé.
   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 11 sources
  1. ITU-R M.1677-1 (10/2009), International Morse code: signal lengths and spacing (dash = 3 dots, gaps of 1, 3 and 7 units).
  2. sigrok libsigrokdecode, Morse decoder (quotes ITU-R M.1677-1 section 2 on spacing and the character table)
  3. Espressif, ESP32 datasheet (3.6 V maximum, pin currents, pull-up, power modes, Wi-Fi receive current, GPIO34 = ADC1 input-only)
  4. ESP-IDF, ESP-NOW (connectionless, up to 250 bytes per message (ESP-NOW v1.0), delivery not guaranteed)
  5. Arduino-ESP32, ESP-NOW API and broadcast examples (works without an access point)
  6. SparkFun, Light-Emitting Diodes (20 mA typical continuous rating, forward voltage)
  7. ESP-IDF, Sleep modes (wake-up from deep sleep on a button, ext0)
  8. Arduino-ESP32, ADC API (11 dB range, about 150–3100 mV)
  9. Adafruit product 830, 4×AA holder with on/off switch (voltages, pin ends)
  10. Espressif, ESP32-DevKitC V4 user guide (power options: only one at a time)
  11. SparkFun, How to Solder: Through-Hole Soldering (temperature, glasses, helping hands)

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 tension directe de la DEL jaune, le courant du buzzer, le temps de réponse et la mention cadmium de la LDR, le courant de repos du régulateur, la portée d’ESP-NOW en intérieur, la convention PARIS. À 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.