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.
Fais ces leçons d’abord
- Une DEL et sa résistance (E3)disponiblepourquoi la résistance de 220 Ω, comment on mesure une tension (U).
- 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.
- 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
5Vde la carte, qui reçoit le bloc de piles et rien d’autre. - Le rail rouge, c’est 3V3 seulement. Le bloc 4×AA va sur la rangée de la broche
5Vet sur le rail bleu (−). Ne mets jamais son fil + sur un rail rouge. - 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
/quietle 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
5Vdoit 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é.
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ç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.
Voir les 11 fils et le tableau des broches
Liste des fils
| # | Couleur | De | Vers |
|---|---|---|---|
| 1 | rouge | ESP32 3V3 (trou j19) | rail 3V3 (rouge + à droite) |
| 2 | noir | ESP32 GND (trou j6) | rail GND (bleu − à droite) |
| 3 | noir | rail bleu de gauche | rail bleu de droite (liaison de GND) |
| 4 | orange | ESP32 GPIO25 (j11) | buzzer S (j39) |
| 5 | rouge | rail 3V3 | buzzer + (j40) |
| 6 | noir | buzzer − (j41) | rail GND |
| 7 | vert | ESP32 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 | noir | rangée 31 de la DEL (a31, la rangée de la patte courte) | rail bleu de gauche |
| 9 | bleu | ESP32 GPIO27 (j9) | bouton patte A (j44). Le bouton est à cheval sur la rainure centrale, pattes en e44, f44, e46, f46. |
| 10 | noir | bouton patte B, en diagonale de A (a46) | rail bleu de gauche |
| B | rouge / noir | bloc 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
| Broche | Relié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) |
3V3 | rail 3V3 : buzzer + | Sortie d’alimentation (3 |
GND | rail GND : − du bloc, buzzer −, DEL, bouton | Masse |
GPIO27 | Bouton (autre patte à GND) | Entrée avec résistance de rappel interne (LOW = appuyé). Peut réveiller la carte du sommeil profond. |
GPIO26 | 220 Ω → DEL | Sortie (HIGH = DEL allumée) |
GPIO25 | Buzzer S | Sortie (HIGH = buzzer actif, sauf si ton module est inversé) |
GPIO34 | Pour 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.
É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.
É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,26et27grâce à leurs inscriptions.Étape 3 · Place l’ESP32.
Enfonce la carte à cheval sur la rainure centrale, pour que ses deux rangées de broches tombent dans les colonnes a et i, rangées 1 à 19. Port USB à la rangée 1, antenne vers la rangée 20. Laisse les rangées 20–23 vides : c’est là que se trouve l’antenne. Chaque broche côté j a maintenant un trou libre à côté d’elle (colonne j). Pas de câble pour l’instant.
Vérifie : La carte est à plat, aucune broche n’est tordue, et la broche
5Vest à la rangée 1, colonne i.Étape 4 · Les rails.
Relie la broche
3V3(trou j19) au rail rouge (+) de droite et la brocheGND(trou j6) au rail bleu (−) de droite. Puis relie le rail bleu de gauche au rail bleu de droite avec un fil. Le rail rouge de droite est maintenant 3V3 seulement.Vérifie : Fil rouge sur le rail rouge, fil noir sur le rail bleu, et rien d’autre ne touche encore le rail rouge.
Étape 6 · Ajoute la DEL.
GPIO26→ résistance 220 Ω → patte longue (+) de la DEL. Le fil vert deGPIO26se 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.Vérifie : La patte longue est du côté de la résistance.
Étape 7 · Ajoute le bouton.
Place le bouton à cheval sur la rainure centrale, pattes en e44, f44, e46 et f46. Un fil de
GPIO27va à 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.Vérifie : Les deux pattes câblées sont en diagonale (pas du même côté).
É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.
É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.
É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, remplaceHIGHparLOW, téléverse à nouveau.Vérifie : Le buzzer se tait entre les signaux et sonne avec la DEL.
Étape 11 · Envoie ton premier message.
Dans le moniteur série, tape
HELLOet 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).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é).
É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).
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.
Étape 13 · Lance la balise.
Maintiens le bouton 3 secondes. La DEL et le buzzer font un court bip de confirmation, puis la balise joue son message (ta dernière ligne tapée, ou HELLO AGENT si tu n’as rien tapé depuis la mise sous tension), attend 5 secondes et le rejoue, encore et encore, comme un phare. Un appui sur le bouton l’arrête. Pendant l’envoi, un appui arrête le message en un signal.
Vérifie : Après le maintien de 3 s, le message se répète toutes les 5 s jusqu’à ce que tu appuies sur le bouton.
Étape 14 · Change la vitesse et le volume.
Tape
/wpm 15pour envoyer plus vite (plage permise : 5–20 WPM). Tape/quietpour couper le buzzer (la DEL continue) et/loudpour le remettre./helpliste 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.É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, changeDEFAULT_MESSAGEdans 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 vois | Ce que ça veut dire |
|---|---|
| OK en Morse à la mise sous tension | Auto-test : la carte a démarré, et la DEL et le buzzer fonctionnent. |
| La DEL et le buzzer suivent ton doigt | Mode clé droite : tu es le radio. |
| Un court bip après un maintien de 3 s | La balise démarre. Lâche le bouton. |
| Ton message toutes les 5 s | Balise en marche. Un appui sur le bouton l’arrête. |
| Deux clignotements, puis le noir | 3 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 ?
| Bloc | Autonomie | Remarques |
|---|---|---|
| Éveillée, en attente, 4×AA alcalines | environ 2–3 jours de marche continue | Environ 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 alcalines | environ 1,5–2,5 jours | La 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 alcalines | environ 10–12 jours en veille | Presque 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 alcalines | environ 15–20 heures | La 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)
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 sourcesBloc 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_ONseulement si l’étape 10 te l’a dit ;DEFAULT_MESSAGEpour ton propre texte de balise ; les nombres si tu veuxVoir 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 shortBloc 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 : rienVoir 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; }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é, etprintHelp(). À changer : rienVoir 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."); }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 : rienVoir 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(); }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 : le5et le20de/wpm, si tu veux une autre plage de vitesseVoir 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."); }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 appellestartBeacon(); un appui pendant que la balise tourne l’arrête. À changer : les seuils (voir Broches), si tu tapes très vite ou très lentementVoir 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 = ""; } }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 quandGPIO27passe à 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é ?
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é)
/wpmchange la vitesse et/quietcoupe 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
5Vet 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
Je tape un message et rien ne part
/ sauf s’il s’agit d’une commande.La DEL marche mais pas le buzzer (ou l’inverse)
BUZZER_ON (étape 10).Mes lettres tapées sortent fausses
La balise ne démarre pas
La carte semble morte au bout de quelques minutes
SLEEP_AFTER_MS à 0 si tu ne veux pas de ça.Les piles sont vides au bout d’une nuit
Les cartes radio ne s’entendent pas (Pour aller plus loin 1)
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)
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.
3 étapes bonus · 2 morceaux de code · Deuxième carte nécessaire
É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é.
É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 3dans 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.
É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.
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èceVoir 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); }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 = ""; } }
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
Étape P1 · Installe un établi sûr. Demande de l’aide
Lis la liste de sécurité pour souder. Fenêtre ouverte ou ventilateur allumé, lunettes sur le nez, fer dans son support sur un tapis résistant à la chaleur, plaque dans la pince. Demande à une personne qui a déjà soudé d’être là pour tes cinq premières soudures.
Vérifie : Une personne expérimentée est avec toi, et le fer n’est chaud que quand tu en as besoin.
Étape P2 · Pose les supports de l’ESP32 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.
É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.
É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
5Vet 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.É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.
É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
5Vvers le rail + ; le support5Vvers le rail −. Doit biper : le + du bornier vers le support5V, le − du bornier vers GND, le support3V3vers le rail +, le supportGPIO26vers la résistance. Le bouton, supportGPIO27vers GND, bipe seulement quand on appuie.Vérifie : Chaque « pas de bip » est silencieux et chaque « bip » bipe.
É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
5Vcontre 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.
É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.
É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.
4 étapes bonus · 2 morceaux de code · Deuxième carte + LDR · Niveau 2
Liste des fils
| # | Couleur | De | Vers |
|---|---|---|---|
| R1 | rouge | LDR patte 1 | rail 3V3 |
| R2 | bleu | LDR patte 2 et résistance 10 kΩ patte 1 (même rangée) | GPIO34 (j15) |
| R3 | noir | résistance 10 kΩ patte 2 | rail 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.
É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.É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.
É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
/calou 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. »
É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.
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 moinsMIN_JUMPde 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 lumineuseVoir 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."); }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. AvecRX_WPM= 10, elle lit des émetteurs de 7 à 12 WPM. À changer :RX_WPM(ou/wpmsur 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 = ""; } }
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
- ITU-R M.1677-1 (10/2009), International Morse code: signal lengths and spacing (dash = 3 dots, gaps of 1, 3 and 7 units).
- sigrok libsigrokdecode, Morse decoder (quotes ITU-R M.1677-1 section 2 on spacing and the character table)
- Espressif, ESP32 datasheet (3.6 V maximum, pin currents, pull-up, power modes, Wi-Fi receive current, GPIO34 = ADC1 input-only)
- ESP-IDF, ESP-NOW (connectionless, up to 250 bytes per message (ESP-NOW v1.0), delivery not guaranteed)
- Arduino-ESP32, ESP-NOW API and broadcast examples (works without an access point)
- SparkFun, Light-Emitting Diodes (20 mA typical continuous rating, forward voltage)
- ESP-IDF, Sleep modes (wake-up from deep sleep on a button, ext0)
- Arduino-ESP32, ADC API (11 dB range, about 150–3100 mV)
- Adafruit product 830, 4×AA holder with on/off switch (voltages, pin ends)
- Espressif, ESP32-DevKitC V4 user guide (power options: only one at a time)
- 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.