Leçons · Leçon W1 · Sans fil et objets connectés · 45 min
Wi-Fi et radio (alertes, pages web, carte à carte)
Rejoins ton Wi-Fi sans partager ton mot de passe, envoie une alerte sur ton téléphone, sers une minuscule page de commande, et fais parler deux cartes par radio. Environ 45 minutes.
Ta carte a une radio
Jusqu’ici, ta carte te parlait par un câble. Mais l’ESP32 contient aussi une radio, et elle te permet trois nouveautés :
- Rejoindre ton Wi-Fi comme un téléphone, et atteindre Internet [3].
- Envoyer une alerte sur ton téléphone, de n’importe où chez toi, sans câble.
- Parler à une autre carte directement, sans aucun routeur, avec un protocole appelé ESP-NOW [5].
Imagine une lettre. Ta carte écrit un petit mot, le confie au routeur (la boîte aux lettres de ta porte), le mot voyage jusqu’à un service de messages gratuit appelé ntfy (le centre de tri), et l’appli ntfy de ton téléphone (la voisine qui sonne chez toi) le livre. Chaque étape est une vraie machine, et dans cette leçon tu construis la première.
Rejoindre le Wi-Fi, garder le mot de passe privé
Pour rejoindre un réseau de la maison, la carte travaille en mode station : elle se comporte comme un téléphone ou un ordinateur portable [3]. Ton programme lui donne le nom du réseau et le mot de passe avec WiFi.begin(nom, motDePasse), puis attend que WiFi.status() indique WL_CONNECTED [3]. Une fois connectée, WiFi.localIP() donne l’adresse de la carte sur ton réseau [3].
N’écris jamais ton mot de passe dans un programme que tu pourrais partager. Un programme posté sur un forum, donné à un ami ou mis sur un site emporte tout ce qu’il contient. Range donc les valeurs privées dans un second fichier :
- À côté de ton programme, crée un fichier nommé
secrets.h(dans l’IDE Arduino 2 : bouton ⋯ à droite des onglets, puis Nouvel onglet). Il ne contient que le nom du réseau, le mot de passe et (plus loin) ton sujet. - Dans le programme,
#include "secrets.h"le lit quand tu appuies sur téléverser. - Quand tu partages ton travail, partage le programme et une copie modèle nommée
secrets.example.h, avec des valeurs bidon. Ne partage jamaissecrets.h.
Enregistre-le dans le dossier du programme, à côté du fichier .ino. Si le programme était ouvert dans l’IDE, ferme-le et rouvre-le pour que l’IDE voie le nouveau fichier. Voici le modèle :
// secrets.example.h : un fichier MODÈLE. Uniquement des valeurs bidon.
// Copie ce fichier, nomme la copie secrets.h (dans le même dossier que le programme), puis écris tes vraies valeurs dans
// secrets.h. Ne partage jamais secrets.h, ne le mets jamais en ligne : ne partage que ce fichier modèle.
#pragma once
#define WIFI_NAME "YourWiFiName" // le nom de ton réseau Wi-Fi 2,4 GHz
#define WIFI_PASS "YourWiFiPassword" // son mot de passe
// Ton sujet d’alerte : un long nom aléatoire fait uniquement de lettres, de chiffres, de - et de _ (64 caractères au maximum).
// Quiconque le devine peut lire tes alertes : n’y mets ni ton nom, ni ta rue, ni un mot que tu dirais à voix haute.
#define NTFY_TOPIC "change-me-to-a-long-random-name-k7x2q9"
Si tu colles un jour un vrai mot de passe dans un endroit public, change-le tout de suite sur ton routeur.
Deux faits sur la radio. Utilise un réseau 2,4 GHz : si ton routeur propose des noms séparés en 2,4 et 5 GHz, prends celui en 2,4, car la radio de l’ESP32 ne fonctionne qu’en 2,4 GHz [8]. Et tant que le Wi-Fi est allumé, les broches ADC2 ne peuvent pas lire de valeurs analogiques [7]. Lis plutôt tes capteurs analogiques sur des broches ADC1 (GPIO 32 à 39) [7]. Pour la lecture analogique, voir la leçon K3. Les programmes ci-dessous n’utilisent les broches qu’en tout ou rien.
Une alerte sur ton téléphone avec ntfy
ntfy est un service gratuit qui transforme une requête web en notification sur téléphone. Tu choisis un sujet (topic), le nom de ton canal privé. Tout ce qui est posté sur https://ntfy.sh/<ton sujet> s’affiche sur chaque téléphone abonné à ce sujet [1][2]. Ta carte poste avec un HTTP POST : une requête web dont le corps est ton texte [1].
La vie privée d’abord. Il n’y a pas d’inscription, donc le sujet joue le rôle d’un mot de passe [1]. Et tous les sujets de ntfy.sh sont publics : quiconque devine le tien peut le lire [1]. Alors :
- Prends un sujet long et aléatoire, avec des lettres, des chiffres, des tirets et des tirets bas, jusqu’à 64 caractères [1]. La page de ntfy propose un générateur qui ajoute une fin aléatoire [1].
- Garde le sujet dans
secrets.h, pas dans le programme partagé. - Ne mets jamais de nom, d’adresse, de pièce ni aucun détail personnel dans un message ou un sujet. Écris « Bouton appuyé », pas qui ni où.
Prépare ton téléphone : installe l’appli ntfy (Android ou iPhone) et abonne-toi à ton sujet [2].
Câblage : un bouton-poussoir entre GPIO 27 et GND. Téléverse ce programme et ouvre le moniteur série à 115200 baud :
// Tinker Mission, leçon W1 : une alerte sur ton téléphone avec ntfy (tu appuies sur un bouton, ton téléphone sonne)
// Carte : ESP32 DevKitC, « esp32 by Espressif » 3.3.x. Aucune bibliothèque à ajouter : WiFi et HTTPClient viennent avec le paquet de la carte.
// Câblage : bouton-poussoir entre GPIO 27 et GND (la résistance de rappel intégrée garde la broche à HIGH jusqu’à l’appui).
// Avant de téléverser : crée secrets.h à côté de ce programme (copie secrets.example.h) et remplis tes propres valeurs.
// Ouvre le moniteur série à 115200 baud. Installe l’appli gratuite ntfy sur ton téléphone et abonne-toi à ton sujet.
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <HTTPClient.h>
#include "secrets.h" // WIFI_NAME, WIFI_PASS et NTFY_TOPIC sont ici, dans un fichier que tu ne partages jamais
const int BUTTON_PIN = 27; // appuyé = LOW
const unsigned long WIFI_TIMEOUT_MS = 15000; // abandonne le Wi-Fi après 15 s
const unsigned long MIN_GAP_MS = 10000; // une alerte toutes les 10 s au maximum
unsigned long lastAlert = 0;
bool alertSentOnce = false;
// Essaie de rejoindre le réseau Wi-Fi. Renvoie true quand c’est connecté.
bool connectWifi() {
if (WiFi.status() == WL_CONNECTED) {
return true;
}
Serial.print("Connecting to Wi-Fi");
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_NAME, WIFI_PASS);
unsigned long start = millis();
while (WiFi.status() != WL_CONNECTED && millis() - start < WIFI_TIMEOUT_MS) {
delay(500);
Serial.print(".");
}
Serial.println();
if (WiFi.status() == WL_CONNECTED) {
Serial.print("Connected. IP address: ");
Serial.println(WiFi.localIP());
return true;
}
Serial.println("No Wi-Fi. Check the name, the password and that it is a 2.4 GHz network.");
return false;
}
// Envoie un court message à ton sujet ntfy : un HTTP POST dont le corps est le texte.
void sendAlert(const char* text) {
WiFiClientSecure client;
client.setInsecure(); // saute la vérification de l’identité du serveur, pour que la leçon reste courte
HTTPClient http;
http.setConnectTimeout(5000); // n’attend jamais plus de 5 s le serveur
http.setTimeout(5000);
http.begin(client, String("https://ntfy.sh/") + NTFY_TOPIC);
int code = http.POST(text); // le code de réponse, ou un nombre négatif en cas d’échec
Serial.print("Server answer: ");
Serial.println(code);
http.end();
}
void setup() {
Serial.begin(115200);
pinMode(BUTTON_PIN, INPUT_PULLUP);
connectWifi();
}
void loop() {
bool pressed = (digitalRead(BUTTON_PIN) == LOW);
unsigned long now = millis();
bool waitedEnough = !alertSentOnce || (now - lastAlert >= MIN_GAP_MS);
if (pressed && waitedEnough) {
lastAlert = now;
alertSentOnce = true;
if (connectWifi()) {
Serial.println("Sending the alert...");
sendAlert("Button pressed on my ESP32."); // pas de noms ni de détails personnels dans les messages
}
}
delay(20); // une courte pause : ce programme n’a pas d’autre travail
}
Télécharger le dossier du croquis (.zip)
Appuie sur le bouton : ton téléphone devrait sonner en quelques secondes. Comment ça marche : http.begin donne l’adresse, http.POST(texte) envoie le mot et renvoie un nombre (négatif si le serveur n’a pas pu être joint). Le programme attend aussi 10 secondes entre deux alertes, pour qu’un bouton coincé n’inonde pas ton téléphone. Une dernière chose à savoir : client.setInsecure() garde la connexion chiffrée mais ne vérifie pas que le serveur est bien ntfy.sh, pour que la leçon reste courte. Un appareil de ton réseau, ou sur le chemin jusqu’à ntfy, pourrait se faire passer pour ntfy et lire ou bloquer l’alerte. C’est acceptable pour une alerte de loisir comme « Bouton appuyé », jamais pour des mots de passe ou des données personnelles. Un produit fini vérifie le certificat du serveur.
L’alarme de la mission 01 utilise la même idée ntfy pour son bonus téléphone. Ce programme garde ses valeurs en haut du fichier : une fois les tiennes tapées, ne le partage pas.
Simulation : rien n’est envoyé, rien ne quitte cette page.
Appuie sur le bouton pour envoyer l’alerte.
Sujet court : n’importe qui pourrait le deviner et lire tes alertes. Choisis un nom long et aléatoire.
Ce que chaque étape peut voir
- Enveloppe
- « Button pressed on my ESP32. » Pas de nom, pas de lieu.
- Box
- Que ta carte parle à ntfy.sh, quand, et combien. Pas le texte : le HTTPS le cache.
- ntfy.sh
- Le sujet, le texte et l’adresse internet de ta maison.
- Quiconque a le sujet
- Le texte de chaque alerte.
Voici l’état de départ : les commandes ont besoin de JavaScript.
Une page web sur ta carte
Ta carte peut aussi être un serveur web : un minuscule site qui vit sur la carte. N’importe quel téléphone ou ordinateur sur le même Wi-Fi peut l’ouvrir, comme n’importe quelle page. Le navigateur demande, la carte répond [4].
Câblage : GPIO 26, une résistance de 220 Ω, la longue patte d’une DEL, puis sa courte patte vers GND. Téléverse ce programme, ouvre le moniteur série à 115200 baud, et attends une adresse comme http://192.168.1.42 :
// Tinker Mission, leçon W1 : une minuscule page web de commande servie par la carte (allume une DEL depuis un téléphone)
// Carte : ESP32 DevKitC, « esp32 by Espressif » 3.3.x. Aucune bibliothèque à ajouter : WiFi et WebServer viennent avec le paquet de la carte.
// Câblage : GPIO 26 -> résistance de 220 Ω -> longue patte de la DEL ; courte patte de la DEL -> GND.
// Avant de téléverser : crée secrets.h à côté de ce programme (copie secrets.example.h) et remplis tes propres valeurs.
// Ouvre le moniteur série à 115200 baud : la carte affiche son adresse. Tape-la dans un navigateur sur le MÊME Wi-Fi.
// La page n’a pas de mot de passe : toute personne sur ton Wi-Fi peut l’utiliser. Garde-la sur ton réseau à la maison.
#include <WiFi.h>
#include <WebServer.h>
#include "secrets.h" // WIFI_NAME et WIFI_PASS sont ici, dans un fichier que tu ne partages jamais
const int LED_PIN = 26;
bool ledOn = false;
WebServer server(80); // un serveur web sur le port 80, le port web habituel
// Construit la page : un titre, l’état, et deux gros liens.
String makePage() {
String page = "<!DOCTYPE html><html><head><meta charset=\"utf-8\">";
page += "<meta name=\"viewport\" content=\"width=device-width, initial-scale=1\">";
page += "<title>My ESP32</title></head><body style=\"font-family:sans-serif;text-align:center\">";
page += "<h1>My ESP32</h1>";
page += "<p>The LED is <strong>";
page += ledOn ? "ON" : "OFF";
page += "</strong>.</p>";
page += "<p><a href=\"/on\" style=\"font-size:2em\">Turn ON</a></p>";
page += "<p><a href=\"/off\" style=\"font-size:2em\">Turn OFF</a></p>";
page += "</body></html>";
return page;
}
void handleRoot() {
server.send(200, "text/html", makePage());
}
// Après un clic, change la DEL, puis renvoie le navigateur vers la page principale.
void handleOn() {
ledOn = true;
digitalWrite(LED_PIN, HIGH);
server.sendHeader("Location", "/");
server.send(303);
}
void handleOff() {
ledOn = false;
digitalWrite(LED_PIN, LOW);
server.sendHeader("Location", "/");
server.send(303);
}
void handleNotFound() {
server.send(404, "text/plain", "Nothing here.");
}
void setup() {
Serial.begin(115200);
pinMode(LED_PIN, OUTPUT);
digitalWrite(LED_PIN, LOW);
WiFi.mode(WIFI_STA);
WiFi.begin(WIFI_NAME, WIFI_PASS);
Serial.print("Connecting to Wi-Fi");
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
Serial.print("Open this address in a browser: http://");
Serial.println(WiFi.localIP());
server.on("/", handleRoot); // quelle fonction répond à quelle adresse
server.on("/on", handleOn);
server.on("/off", handleOff);
server.onNotFound(handleNotFound);
server.begin();
}
void loop() {
server.handleClient(); // répond à tout navigateur qui demande
delay(2); // laisse le processeur faire ses autres tâches
}
Télécharger le dossier du croquis (.zip)
Tape cette adresse dans un navigateur, sur un téléphone ou un ordinateur connecté au même Wi-Fi. Tu devrais voir une petite page avec deux liens qui allument et éteignent la DEL.
Comment ça marche : WebServer server(80) crée un serveur sur le port web habituel [4]. server.on("/on", handleOn) veut dire « quand le navigateur demande /on, lance handleOn » [4]. server.handleClient() dans loop() répond à quiconque demande [4]. server.send(200, ...) est la réponse [4]. Après un clic, la carte renvoie le navigateur vers la page principale.
Note de sécurité. Cette page n’a pas de mot de passe : toute personne sur ton Wi-Fi peut l’utiliser. Garde-la pour ton réseau à la maison, et ne règle jamais ton routeur pour l’ouvrir à tout Internet.
Deux cartes, sans routeur : ESP-NOW
ESP-NOW permet à des cartes de s’envoyer de courts messages directement, sans connexion préalable [5]. Pas de routeur, pas de mot de passe, pas d’Internet. Une carte est l’émetteur, l’autre le récepteur.
À savoir :
- Un message contient jusqu’à 250 octets avec la première version du protocole, largement assez pour un court texte [5].
- Pour envoyer à tout le monde à portée, tu ajoutes d’abord l’adresse de diffusion (
FF:FF:FF:FF:FF:FF) comme destinataire [5]. Le récepteur n’a rien à ajouter pour entendre les diffusions [5]. - Les deux cartes doivent être sur le même canal Wi-Fi [5][6]. Les programmes ci-dessous choisissent tous deux le canal 1.
- La livraison n’est pas garantie : un message peut se perdre [5].
- Les messages diffusés ne sont pas chiffrés [5]. N’envoie jamais d’information privée par ce moyen.
- La fonction qui reçoit un message tourne dans la tâche Wi-Fi, donc garde-la très courte [5] : elle copie seulement le texte et lève un drapeau, et
loop()fait le reste.
Carte A (émetteur). Bouton entre GPIO 27 et GND :
// Tinker Mission, leçon W1 : ESP-NOW, l’émetteur (carte A)
// Carte : ESP32 DevKitC, « esp32 by Espressif » 3.3.x. Ni routeur, ni mot de passe : les deux cartes se parlent directement.
// Câblage : bouton-poussoir entre GPIO 27 et GND.
// Chaque appui diffuse un court texte. Toute carte réceptrice sur le même canal et à portée peut l’entendre.
// Les messages diffusés NE SONT PAS chiffrés : n’envoie rien de privé. Ouvre le moniteur série à 115200 baud.
#include <WiFi.h>
#include <esp_now.h>
const int BUTTON_PIN = 27; // appuyé = LOW
const int CHANNEL = 1; // les deux cartes doivent utiliser le même canal
uint8_t BROADCAST_ADDRESS[6] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}; // « tout le monde »
int counter = 0;
bool wasPressed = false;
void setup() {
Serial.begin(115200);
pinMode(BUTTON_PIN, INPUT_PULLUP);
WiFi.mode(WIFI_STA); // ESP-NOW a besoin de la radio Wi-Fi allumée, mais pas d’un réseau
WiFi.setChannel(CHANNEL);
while (!WiFi.STA.started()) {
delay(100);
}
if (esp_now_init() != ESP_OK) {
Serial.println("ESP-NOW did not start. Reset the board.");
while (true) {
delay(1000);
}
}
esp_now_peer_info_t peer = {}; // remplit la « fiche du carnet d’adresses » pour l’adresse de diffusion
memcpy(peer.peer_addr, BROADCAST_ADDRESS, 6);
peer.channel = 0; // 0 = utilise le canal sur lequel la carte est en ce moment
peer.encrypt = false;
if (esp_now_add_peer(&peer) != ESP_OK) {
Serial.println("Could not add the broadcast address.");
}
Serial.println("Ready. Press the button to send.");
}
void loop() {
bool pressed = (digitalRead(BUTTON_PIN) == LOW);
if (pressed && !wasPressed) { // seulement à l’instant de l’appui, pas tant que c’est maintenu
counter = counter + 1;
char message[32];
snprintf(message, sizeof(message), "TM1:press %d", counter); // « TM1: » marque nos propres messages
esp_err_t result = esp_now_send(BROADCAST_ADDRESS, (const uint8_t*)message, strlen(message) + 1);
Serial.print("Sent \"");
Serial.print(message);
Serial.println(result == ESP_OK ? "\"" : "\" (the radio refused it)");
}
wasPressed = pressed;
delay(20); // une courte pause cache aussi les petits rebonds du bouton
}
Télécharger le dossier du croquis (.zip)
Carte B (récepteur). GPIO 26, une résistance de 220 Ω, la longue patte de la DEL, puis sa courte patte vers GND :
// Tinker Mission, leçon W1 : ESP-NOW, le récepteur (carte B)
// Carte : ESP32 DevKitC, « esp32 by Espressif » 3.3.x. Téléverse ce programme sur la DEUXIÈME carte.
// Câblage : GPIO 26 -> résistance de 220 Ω -> longue patte de la DEL ; courte patte de la DEL -> GND.
// Chaque message de l’émetteur inverse la DEL et affiche le texte. Ouvre le moniteur série à 115200 baud.
#include <WiFi.h>
#include <esp_now.h>
const int LED_PIN = 26;
const int CHANNEL = 1; // doit être le même que sur l’émetteur
volatile bool newMessage = false; // levé par la fonction de la radio, lu par loop()
char lastMessage[32] = "";
// Appelée par la radio quand un message arrive. Reste courte : elle copie le texte et lève un drapeau.
void onReceive(const esp_now_recv_info_t* info, const uint8_t* data, int len) {
if (len < 5 || len > (int)sizeof(lastMessage) || memcmp(data, "TM1:", 4) != 0) {
return; // pas un de nos messages : ignore-le
}
memcpy(lastMessage, data, len);
lastMessage[len - 1] = '\0'; // s’assure que le texte se termine correctement
newMessage = true;
}
void setup() {
Serial.begin(115200);
pinMode(LED_PIN, OUTPUT);
WiFi.mode(WIFI_STA);
WiFi.setChannel(CHANNEL);
while (!WiFi.STA.started()) {
delay(100);
}
if (esp_now_init() != ESP_OK) {
Serial.println("ESP-NOW did not start. Reset the board.");
while (true) {
delay(1000);
}
}
esp_now_register_recv_cb(onReceive);
Serial.println("Ready. Waiting for the sender...");
}
void loop() {
if (newMessage) {
newMessage = false;
digitalWrite(LED_PIN, !digitalRead(LED_PIN)); // inverse la DEL
Serial.print("Received: ");
Serial.println(lastMessage);
}
delay(10);
}
Télécharger le dossier du croquis (.zip)
Téléverse chaque programme sur sa carte, une à la fois. Alimente les deux, ouvre le moniteur série de l’émetteur, et appuie sur le bouton : la DEL de la carte B devrait s’inverser à chaque appui. L’émetteur marque ses messages avec TM1: et le récepteur ignore tout le reste, donc la carte d’un inconnu ne peut pas inverser ta DEL par accident.
Essaie tes propres changements
Change une seule chose, puis observe.
- Un autre message. Dans le programme ntfy, change le texte en « Test 1 ». Ton téléphone l’affiche-t-il ?
- Une page, une DEL. Dans le programme de la page web, change le titre de la page et le texte des liens. Que se passe-t-il si tu demandes
/blink, une adresse qui n’existe pas ? - Compte les appuis. Dans le récepteur, affiche combien de messages sont arrivés. Indice : ajoute un compteur à côté de
newMessage. - Éloigne-toi. Emporte la carte A à quelques pas, puis derrière un mur. À quel moment la DEL cesse-t-elle de réagir ?
Quand ça ne marche pas
- Pas de Wi-Fi. Vérifie le nom et le mot de passe dans
secrets.h, majuscules comprises, et que ton réseau est en 2,4 GHz. Ouvre le moniteur série à 115200 baud pour lire les messages. Si le programme de la page web affiche des points sans fin, le nom ou le mot de passe est faux. - « Server answer » est un nombre négatif. La carte n’a pas pu joindre ntfy : vérifie la connexion à Internet, puis réessaie.
- Rien sur le téléphone. Le sujet doit être écrit exactement pareil dans
secrets.het dans l’appli. Vérifie que l’appli a le droit d’afficher des notifications. - La page web ne s’ouvre pas. Le téléphone doit être sur le même Wi-Fi que la carte (pas en données mobiles). Relis l’adresse dans le moniteur série : elle peut avoir changé après un redémarrage. Certains réseaux invités empêchent les appareils de se parler.
- ESP-NOW : il ne se passe rien. Les deux cartes doivent utiliser le même canal [5][6]. Regarde le moniteur série de l’émetteur : s’il affiche « radio refused », redémarre la carte. La livraison n’est jamais garantie [5].
- Un capteur analogique lit zéro quand le Wi-Fi est allumé. Il est peut-être sur une broche ADC2 : déplace-le sur une broche ADC1 [7].
- Le programme ne compile pas : « secrets.h: No such file ». Crée le fichier à côté du programme, comme à l’écran 2.
Vérifie-toi
Trois questions courtes. Rien n’est enregistré, prends ton temps.
Où ranger ton mot de passe Wi-Fi quand tu comptes partager ton programme ?
- Dans un fichier secrets.h séparé que tu ne partages jamais
- En haut du programme, pour que tes amis puissent le lancer tout de suite
- Dans le message envoyé à ton téléphone
Voir la réponse
Dans un fichier secrets.h séparé que tu ne partages jamais. Un programme partagé emporte tout ce qui y est écrit. Garder le nom et le mot de passe dans un secrets.h séparé, et ne partager qu’une copie modèle, les garde privés. C’est l’habitude de cette leçon.
Tout le monde peut lire ce qui est publié sur ntfy.sh s’il connaît le nom du sujet. Que fais-tu ?
- Rien, personne ne regarde jamais
- Tu prends un nom de sujet long et aléatoire, et tu gardes les détails personnels hors des messages
- Tu prends ton prénom comme sujet pour t’en souvenir
Voir la réponse
Tu prends un nom de sujet long et aléatoire, et tu gardes les détails personnels hors des messages. Sur ntfy.sh, tous les sujets sont publics, et sans inscription le sujet joue le rôle d’un mot de passe : il doit être difficile à deviner [1]. Un sujet peut compter jusqu’à 64 caractères : lettres, chiffres, tirets et tirets bas [1].
Tu fais parler deux cartes avec ESP-NOW. Qu’est-ce qui doit être pareil des deux côtés ?
- La couleur de la DEL
- Le mot de passe Wi-Fi de ton routeur, que les deux doivent connaître
- Le canal Wi-Fi qu’elles utilisent
En bref
- Garde le nom de ton Wi-Fi, le mot de passe et le sujet dans
secrets.h, et ne partage quesecrets.example.h. - L’ESP32 rejoint un Wi-Fi 2,4 GHz en mode station avec
WiFi.begin, puis attendWL_CONNECTED[3]. - ntfy transforme un HTTP POST en notification de téléphone. Tous les sujets de ntfy.sh sont publics : prends un sujet long et aléatoire, et aucune information personnelle [1][2].
- Un
WebServercrée une minuscule page sur ta carte, sans mot de passe : garde-la chez toi [4]. - ESP-NOW envoie de courts messages (250 octets) entre cartes sans routeur. Même canal obligatoire, pas de garantie de livraison, diffusion non chiffrée [5][6].
- Les broches ADC2 ne peuvent pas être lues en analogique quand le Wi-Fi est allumé [7].
Prochaines étapes : commander des choses plus grosses avec un signal (C2), ou essayer le bonus téléphone de la mission 01.
Sources
Voir les 8 sources
- ntfy, documentation, « Publishing » (messages envoyés en HTTP PUT ou POST ; les sujets sont créés à la volée ; sans inscription, le sujet sert de mot de passe et doit être difficile à deviner ; noms de sujet en lettres, chiffres, tirets bas et tirets, jusqu’à 64 caractères ; un générateur de nom ajoute un suffixe aléatoire ; « tous les sujets de ntfy.sh sont publics ») — https://docs.ntfy.sh/publish/
- ntfy, documentation, « Subscribe from your phone » (applis Android et iOS ; ajouter un sujet, puis lui publier des messages) — https://docs.ntfy.sh/subscribe/phone/
- Espressif, documentation Arduino-ESP32, « Wi-Fi API » (pilote 802.11 b/g/n ; le mode station connecte la carte à un point d’accès ;
WiFi.begin, boucle jusqu’àWL_CONNECTED, puisWiFi.localIP()) — https://docs.espressif.com/projects/arduino-esp32/en/latest/api/wifi.html - Espressif, dépôt arduino-esp32, exemple WebServer « HelloServer » (
WebServer server(80),server.on(chemin, fonction),server.begin(),server.handleClient()dansloop(),server.send(200, ...),onNotFound) — https://raw.githubusercontent.com/espressif/arduino-esp32/master/libraries/WebServer/examples/HelloServer/HelloServer.ino - Espressif, ESP-IDF Programming Guide, « ESP-NOW » (protocole sans connexion ; 250 octets par message en v1.0 ; l’adresse de diffusion doit être ajoutée comme destinataire avant l’envoi ; un récepteur n’a pas besoin de destinataire pour recevoir des diffusions ; le canal doit correspondre à celui de l’appareil ; livraison non garantie ; pas de chiffrement des trames multicast ; la fonction de réception tourne dans la tâche Wi-Fi et doit être courte) — https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/network/esp_now.html
- Espressif, documentation Arduino-ESP32, « ESP-NOW » (exemples d’émetteur et de récepteur en diffusion ; Wi-Fi en mode station, canal réglé avec
WiFi.setChannel, attente deWiFi.STA.started()) — https://docs.espressif.com/projects/arduino-esp32/en/latest/api/espnow.html - Espressif, ESP-IDF Programming Guide, « GPIO & RTC GPIO » (les broches ADC2 ne peuvent pas être utilisées quand le Wi-Fi est utilisé ; utiliser plutôt une broche ADC1 ; les canaux ADC1 sont sur les GPIO 32 à 39) — https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/peripherals/gpio.html
- Espressif, « ESP32 Series Datasheet » v5.3 (une seule puce Wi-Fi et Bluetooth en 2,4 GHz ; 802.11 b/g/n dans la bande 2,4 GHz) — https://www.espressif.com/sites/default/files/documentation/esp32_datasheet_en.pdf