CAPTEURS/ACTIONNEURS

Caméra ESP32 S3 - Envoyer une photo sur Telegram quand la porte s'ouvre

Ce tutoriel vous montre comment construire une caméra de porte avec l'ESP32 S3. Un capteur de porte magnétique surveille votre porte. Au moment où quelqu'un l'ouvre, l'ESP32 S3 prend une photo et l'envoie sur votre téléphone avec Telegram. Vous voyez qui a ouvert la porte, depuis n'importe où dans le monde.

Ce que vous allez construire :

Votre propre bot Telegram qui vous envoie des messages
Une caméra ESP32 S3 avec un capteur de porte magnétique
Une photo avec le texte « The door is open! » sur votre téléphone, à chaque ouverture de la porte
Une détection propre, pour qu'un seul mouvement de porte envoie exactement une photo

Matériel requis

1	×	ESP32 S3 N16R8 OV5640 Camera
1	×	Alternativement: ESP32 S3 N16R8 OV2640 Camera
1	×	Câble USB Type-A vers Type-C (pour PC USB-A)
1	×	Câble USB Type-C vers Type-C (pour PC USB-C)
1	×	Capteur de porte
1	×	Fils de connexion
1	×	Recommandé: Screw Terminal Expansion Board for ESP32 S3
1	×	Recommandé: Breakout Expansion Board for ESP32 S3
1	×	Recommandé: Power Splitter for ESP32 S3

Ou vous pouvez acheter les kits suivants:

Kit de Capteurs DIYables (18 capteurs/écrans)

Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.

※ Note:

La carte caméra ESP32 S3 a 40 broches, mais le bornier à vis et la carte d'extension ont 44 broches. Elles fonctionnent quand même ensemble. Placez la carte caméra au centre de la carte à 44 broches, pour que 2 broches restent libres du côté gauche et 2 broches restent libres du côté droit.

Le bornier à vis vous permet de connecter des fils avec un tournevis, sans soudure. La carte d'extension vous donne des connecteurs faciles pour une breadboard.

À propos de Telegram

Telegram est une application de discussion gratuite pour votre téléphone et votre ordinateur. Telegram vous permet de créer un bot. Un bot est un ami robot dans votre liste de discussions. Votre ESP32 S3 envoie la photo au bot, et le bot vous la montre.

Vous avez besoin de deux textes secrets :

Nom	Ce que c'est	Ressemble à
Jeton du bot	Le mot de passe de votre bot	8012345678:AAHxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
ID de chat	Le numéro de votre discussion	123456789

※ Note:

Ne montrez jamais le jeton de votre bot à qui que ce soit, et ne le mettez jamais sur un site web ou sur GitHub. Quelqu'un avec votre jeton peut contrôler votre bot.

Étape 1 : créez votre bot

Installez Telegram sur votre téléphone, et créez un compte.
Dans Telegram, cherchez @BotFather. Il a une coche bleue.
Ouvrez la discussion avec BotFather et parlez-lui ainsi :

BotFather

bot

Today

/newbot

10:15 AM ✓✓

Alright, a new bot. How are we going to call it? Please choose a name for your bot.

10:16 AM

My ESP32 Door Camera

10:17 AM ✓✓

Good. Now let's choose a username for your bot. It must end in bot.

10:18 AM

my_esp32_door_bot

10:19 AM ✓✓

Done! Congratulations on your new bot. Use this token to access the HTTP API: 8012345678:AAHxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

10:20 AM

Copiez le jeton du bot du dernier message et gardez-le en lieu sûr.

Étape 2 : trouvez votre ID de chat

Dans Telegram, cherchez le nom de votre nouveau bot et ouvrez la discussion.
Envoyez un message quelconque à votre bot, par exemple hello. Cette étape est nécessaire. Telegram ne laisse pas un bot vous écrire avant que vous ne lui ayez écrit.

ArduinoBot

bot

Today

hello

10:15 AM ✓✓

Ouvrez cette adresse dans votre navigateur web. Mettez votre propre jeton de bot à la place de <YOUR_BOT_TOKEN> :

https://api.telegram.org/bot<YOUR_BOT_TOKEN>/getUpdates

Le navigateur affiche un long texte. Cherchez "chat":{"id":. Le nombre qui suit est votre ID de chat :

{ "ok": true, "result": [ { "update_id": 700000001, "message": { "message_id": 1, "from": { "id": 123456789, "first_name": "John" }, "chat": { "id": 123456789, "first_name": "John", "type": "private" }, "date": 1790000000, "text": "hello" } } ] }

※ Note:

Le navigateur affiche {"ok":true,"result":[]} sans rien à l'intérieur ? Alors vous n'avez pas encore envoyé de message à votre bot. Retournez à l'étape 2, envoyez hello à votre bot, puis rechargez l'adresse.

※ Note:

Beaucoup d'autres tutoriels vous disent de demander au bot @myidbot avec le message /getid. Ce bot appartient à quelqu'un d'autre, et très souvent il ne répond pas du tout. L'adresse web ci-dessus fonctionne toujours, car elle demande directement à Telegram.

※ Note:

Oublié l'étape 2 ? Alors l'ESP32 S3 affiche la réponse Forbidden: bot can't initiate conversation with a user dans le moniteur série. Ouvrez la discussion avec votre bot et envoyez-lui un message quelconque, puis réessayez.

Étape 3 : mettez-les dans le code

Ouvrez le code et changez ces quatre lignes :

const char *WIFI_SSID = "YOUR_WIFI_SSID"; const char *WIFI_PASSWORD = "YOUR_WIFI_PASSWORD"; const char *BOT_TOKEN = "YOUR_TELEGRAM_BOT_TOKEN"; const char *CHAT_ID = "YOUR_TELEGRAM_CHAT_ID";

À propos du capteur de porte

Un capteur de porte a deux parties :

Une petite boîte en plastique avec deux fils. Cette partie contient un interrupteur à lames souples (reed switch). Vous la mettez sur le cadre de la porte.
Une seconde boîte en plastique sans fils. Cette partie contient un aimant. Vous la mettez sur la porte elle-même.

Quand la porte est fermée, l'aimant se trouve à côté de l'interrupteur à lames et le ferme. Quand la porte s'ouvre, l'aimant s'éloigne, et l'interrupteur s'ouvre à nouveau.

Pour plus de détails sur le capteur de porte, voir le tutoriel ESP32 S3 - Capteur de Porte.

Caractéristiques principales

Élément	Valeur
Type	Interrupteur à lames souples magnétique (normalement ouvert)
Fils	2, et ils n'ont pas de sens
Espace de fonctionnement	environ 15 mm à 25 mm
Alimentation	Aucune. C'est seulement un interrupteur.

※ Note:

Les deux fils n'ont ni plus ni moins. Vous pouvez les connecter dans n'importe quel sens.

Comment l'ESP32 S3 lit la porte

Le capteur de porte n'est qu'un interrupteur, donc l'ESP32 S3 doit lui fournir lui-même une tension. Nous utilisons la résistance de pull-up interne :

pinMode(DOOR_PIN, INPUT_PULLUP);

Avec INPUT_PULLUP, la broche est à HIGH quand rien ne la tire vers le bas. Le tableau montre ce qui se passe :

Porte	Aimant	Interrupteur à lames	La broche lit
Fermée	À côté de l'interrupteur	Fermé (connecté à GND)	LOW
Ouverte	Loin de l'interrupteur	Ouvert (rien de connecté)	HIGH

Donc dans le code :

#define DOOR_CLOSED LOW #define DOOR_OPEN HIGH

Pourquoi le code attend 50 millisecondes

Un interrupteur métallique ne change jamais proprement. Dans les premières millisecondes, il saute plusieurs fois entre ouvert et fermé. C'est ce qu'on appelle le rebond. Sans protection, un seul mouvement de porte enverrait cinq photos.

Le code attend que la valeur reste la même pendant 50 millisecondes :

if (reading != lastReadState) { lastReadState = reading; lastChangeTime = millis(); // the value changed, so start counting again } if (millis() - lastChangeTime >= DEBOUNCE_TIME && reading != doorState) { doorState = reading; // the value is stable now, so we believe it }

Capteur de mouvement ou capteur de porte ?

Les deux construisent une petite caméra de sécurité, mais ils ne sont pas identiques :

	Capteur de porte	Capteur de mouvement (PIR)
Détecte	Seulement l'ouverture de la porte	Tout corps chaud qui bouge
Fausses alarmes	Presque jamais	Parfois (chauffages, fenêtres, animaux)
Temps de préchauffage	Aucun	30 à 60 secondes
Besoin d'alimentation	Non	Oui, 5V
Fonctionne à travers le verre	Oui	Non

Un capteur de porte est le meilleur choix quand vous voulez connaître un événement précis. Voir aussi le tutoriel Caméra ESP32 S3 - Envoyer une photo sur Telegram lors d'une détection de mouvement.

Schéma de câblage entre le capteur de porte et l'ESP32 S3

Connectez les deux fils du capteur de porte à votre ESP32 S3.

Schéma de câblage capteur de porte Telegram ESP32 S3

Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.

Fil du capteur de porte	Broche ESP32 S3
Premier fil	GPIO2
Second fil	GND

Puis mettez les deux parties du capteur sur votre porte :

Mettez la partie avec les fils sur le cadre de la porte.
Mettez la partie sans fils sur la porte elle-même.
Bougez la porte jusqu'à ce que les deux parties soient l'une à côté de l'autre. Elles doivent presque se toucher, avec un espace inférieur à 15 mm.
Pointez la caméra vers la porte.

Consignes de sécurité

Le capteur de porte n'a besoin d'aucune alimentation. Ne le connectez pas au 5V ni au 3,3V. Un fil va à GPIO2, l'autre va à GND. Rien ne peut casser, car c'est seulement un interrupteur.

La caméra utilise GPIO4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 15, 16, 17 et 18. N'utilisez pas ces broches pour le capteur. GPIO2 est libre, donc nous l'utilisons.

Réglages de l'Arduino IDE pour la caméra ESP32 S3

La caméra ne fonctionne pas avec les réglages par défaut de l'Arduino IDE. Vous devez changer certains éléments dans le menu Tools avant de téléverser le code.

Élément du menu Tools	Sélectionnez ceci
Board	ESP32S3 Dev Module
Flash Size	16MB (128Mb)
PSRAM	OPI PSRAM
Partition Scheme	Huge APP (3MB No OTA/1MB SPIFFS)
CPU Frequency	240MHz (WiFi)
USB Mode	Hardware CDC and JTAG
Upload Mode	UART0 / Hardware CDC
Upload Speed	921600
USB CDC On Boot	Enabled

※ Note:

PSRAM doit être OPI PSRAM, et Partition Scheme doit être Huge APP. Changez d'abord Flash Size, car la liste des options de Partition Scheme change ensuite.

Comment envoyer une photo sur Telegram

Vous n'avez besoin d'installer aucune bibliothèque. Le code parle directement à Telegram.

Telegram utilise https, donc nous avons besoin d'un client sécurisé.

#include <WiFiClientSecure.h> WiFiClientSecure client; client.setInsecure(); // do not check the certificate of the Telegram server client.connect("api.telegram.org", 443);

※ Note:

setInsecure() signifie que l'ESP32 S3 ne vérifie pas réellement qui est le serveur. Pour un petit projet à la maison, c'est correct, et cela économise beaucoup de mémoire. La photo est quand même envoyée via une connexion chiffrée.

Pour envoyer une photo, nous utilisons l'adresse Telegram /bot<TOKEN>/sendPhoto. La photo voyage à l'intérieur d'un message multipart. Un message multipart a des parties, et une ligne de texte appelée boundary sépare les parties. Ce projet utilise trois parties : l'ID de chat, le texte, et la photo.

String head = "--" BOUNDARY "\r\n"; head += "Content-Disposition: form-data; name=\"chat_id\"\r\n\r\n"; head += String(CHAT_ID) + "\r\n"; head += "--" BOUNDARY "\r\n"; head += "Content-Disposition: form-data; name=\"caption\"\r\n\r\n"; head += "The door is open!\r\n"; head += "--" BOUNDARY "\r\n"; head += "Content-Disposition: form-data; name=\"photo\"; filename=\"photo.jpg\"\r\n"; head += "Content-Type: image/jpeg\r\n\r\n"; String tail = "\r\n--" BOUNDARY "--\r\n";

※ Note:

La partie caption est le texte sous la photo dans Telegram. Changez The door is open! par le message de votre choix.

Le Content-Length doit être la taille de tout : la première partie, la photo, et la dernière partie.

size_t totalLength = head.length() + fb->len + tail.length();

※ Note:

Un Content-Length incorrect est l'erreur la plus courante. Telegram attend alors plus de données et ne répond jamais.

Envoyez la photo en petits morceaux. Un gros write() échoue souvent sur une connexion sécurisée.

for (size_t i = 0; i < fb->len; i += 1024) { size_t piece = fb->len - i; if (piece > 1024) piece = 1024; client.write(fb->buf + i, piece); }

Lisez la réponse. Cette partie a un piège. Telegram répond et ferme la connexion immédiatement, donc votre code doit continuer à lire même après la fermeture de la connexion.

while (millis() - startTime < 15000) { while (client.available()) { answer += (char)client.read(); startTime = millis(); } if (answer.length() > 0 && !client.connected()) break; // the whole answer arrived and the server hung up delay(10); }

※ Note:

Une boucle écrite comme while (client.connected() && ...) semble correcte, mais elle est fausse. Telegram ferme la connexion très rapidement, donc client.connected() est souvent déjà à false. La boucle ne s'exécute alors jamais, et vous jetez une réponse qui est pourtant bien là. Le moniteur série indique que la photo a échoué, même quand la photo est bien arrivée sur votre téléphone.

Quand tout va bien, la réponse de Telegram contient "ok":true.

if (answer.indexOf("\"ok\":true") > 0) { Serial.println("The photo was sent to Telegram"); }

※ Note:

Ce projet utilise une petite taille d'image (FRAMESIZE_SVGA, 800×600), car une petite photo est envoyée beaucoup plus vite. Une photo de 50 Ko prend environ 3 secondes. Une photo de 200 Ko prend environ 10 secondes.

Code ESP32 S3

Le code suivant envoie une photo sur votre discussion Telegram à chaque ouverture de la porte. Rien n'est envoyé quand la porte se referme. Le temps de silence est de 30 secondes, donc une personne qui ouvre et ferme la porte plusieurs fois ne remplit pas votre discussion. Pour le changer, modifiez la ligne #define QUIET_TIME 30000.

/* * Ce code ESP32 S3 a été développé par newbiely.fr * Ce code ESP32 S3 est mis à disposition du public sans aucune restriction. * Pour des instructions complètes et des schémas de câblage, veuillez visiter: * https://newbiely.fr/tutorials/esp32-s3/esp32-s3-camera-send-photo-to-telegram-when-door-opens */ #include <WiFi.h> #include <WiFiClientSecure.h> #include "esp_camera.h" const char *WIFI_SSID = "YOUR_WIFI_SSID"; // CHANGE IT const char *WIFI_PASSWORD = "YOUR_WIFI_PASSWORD"; // CHANGE IT const char *BOT_TOKEN = "1234567890:ABCDefGhIJKlmNoPQRsTUVwXYZ1234567890"; // CHANGE IT const char *CHAT_ID = "1234567890"; // CHANGE IT #define DOOR_PIN 2 // the door sensor is connected to GPIO2 #define DEBOUNCE_TIME 50 // wait 50 milliseconds, because the switch bounces #define QUIET_TIME 30000 // wait 30 seconds before the next message (30000 milliseconds) // Camera pins of the ESP32-S3-N16R8 camera board. // The same pins work for the OV2640, OV3660 and OV5640 versions. #define PWDN_GPIO_NUM -1 #define RESET_GPIO_NUM -1 #define XCLK_GPIO_NUM 15 #define SIOD_GPIO_NUM 4 #define SIOC_GPIO_NUM 5 #define Y9_GPIO_NUM 16 #define Y8_GPIO_NUM 17 #define Y7_GPIO_NUM 18 #define Y6_GPIO_NUM 12 #define Y5_GPIO_NUM 10 #define Y4_GPIO_NUM 8 #define Y3_GPIO_NUM 9 #define Y2_GPIO_NUM 11 #define VSYNC_GPIO_NUM 6 #define HREF_GPIO_NUM 7 #define PCLK_GPIO_NUM 13 #define TELEGRAM_HOST "api.telegram.org" #define BOUNDARY "diyablesphoto" // The door sensor is a switch: // LOW = the switch is closed = the magnet is near = the door is CLOSED // HIGH = the switch is open = the magnet is away = the door is OPEN #define DOOR_CLOSED LOW #define DOOR_OPEN HIGH int doorState = DOOR_CLOSED; int lastReadState = DOOR_CLOSED; unsigned long lastChangeTime = 0; unsigned long lastSendTime = 0; // Returns the name of the camera sensor that is installed on the board const char *getSensorName(int pid) { switch (pid) { case OV2640_PID: return "OV2640 (2 MP, max UXGA 1600x1200)"; case OV3660_PID: return "OV3660 (3 MP, max QXGA 2048x1536)"; case OV5640_PID: return "OV5640 (5 MP, max QSXGA 2592x1944)"; default: return "Unknown sensor"; } } bool initCamera() { camera_config_t config; config.ledc_channel = LEDC_CHANNEL_0; config.ledc_timer = LEDC_TIMER_0; config.pin_d0 = Y2_GPIO_NUM; config.pin_d1 = Y3_GPIO_NUM; config.pin_d2 = Y4_GPIO_NUM; config.pin_d3 = Y5_GPIO_NUM; config.pin_d4 = Y6_GPIO_NUM; config.pin_d5 = Y7_GPIO_NUM; config.pin_d6 = Y8_GPIO_NUM; config.pin_d7 = Y9_GPIO_NUM; config.pin_xclk = XCLK_GPIO_NUM; config.pin_pclk = PCLK_GPIO_NUM; config.pin_vsync = VSYNC_GPIO_NUM; config.pin_href = HREF_GPIO_NUM; config.pin_sccb_sda = SIOD_GPIO_NUM; config.pin_sccb_scl = SIOC_GPIO_NUM; config.pin_pwdn = PWDN_GPIO_NUM; config.pin_reset = RESET_GPIO_NUM; config.xclk_freq_hz = 20000000; config.pixel_format = PIXFORMAT_JPEG; config.frame_size = FRAMESIZE_SVGA; // 800x600 - small, so it is sent quickly config.jpeg_quality = 12; // 0 to 63, a lower number means a better image config.fb_count = 1; config.fb_location = CAMERA_FB_IN_DRAM; config.grab_mode = CAMERA_GRAB_WHEN_EMPTY; if (psramFound()) { config.fb_location = CAMERA_FB_IN_PSRAM; config.jpeg_quality = 10; config.fb_count = 2; config.grab_mode = CAMERA_GRAB_LATEST; } else { config.frame_size = FRAMESIZE_QVGA; Serial.println("WARNING: PSRAM not found. Please set PSRAM to OPI PSRAM in the Tools menu."); } esp_err_t err = esp_camera_init(&config); if (err != ESP_OK) { Serial.printf("Camera init failed with error 0x%x\n", err); return false; } sensor_t *s = esp_camera_sensor_get(); Serial.printf("Camera sensor: %s\n", getSensorName(s->id.PID)); // Each sensor needs slightly different settings switch (s->id.PID) { case OV2640_PID: s->set_vflip(s, 0); s->set_hmirror(s, 0); break; case OV3660_PID: s->set_vflip(s, 1); // the OV3660 image is upside down by default s->set_brightness(s, 1); // make the image a little brighter s->set_saturation(s, -2); // make the colors a little softer break; case OV5640_PID: s->set_vflip(s, 0); s->set_hmirror(s, 0); break; default: break; } return true; } // Sends one photo to your Telegram chat bool sendPhotoToTelegram(camera_fb_t *fb) { WiFiClientSecure client; client.setInsecure(); // do not check the certificate of the Telegram server client.setTimeout(15); Serial.println("Connecting to Telegram..."); if (!client.connect(TELEGRAM_HOST, 443)) { Serial.println("Cannot connect to Telegram"); return false; } // The first part of the message: who receives the photo, and the text String head = "--" BOUNDARY "\r\n"; head += "Content-Disposition: form-data; name=\"chat_id\"\r\n\r\n"; head += String(CHAT_ID) + "\r\n"; head += "--" BOUNDARY "\r\n"; head += "Content-Disposition: form-data; name=\"caption\"\r\n\r\n"; head += "The door is open!\r\n"; head += "--" BOUNDARY "\r\n"; head += "Content-Disposition: form-data; name=\"photo\"; filename=\"photo.jpg\"\r\n"; head += "Content-Type: image/jpeg\r\n\r\n"; // The last part of the message String tail = "\r\n--" BOUNDARY "--\r\n"; size_t totalLength = head.length() + fb->len + tail.length(); // Send the HTTP header client.print("POST /bot" + String(BOT_TOKEN) + "/sendPhoto HTTP/1.1\r\n"); client.print("Host: " TELEGRAM_HOST "\r\n"); client.print("Content-Type: multipart/form-data; boundary=" BOUNDARY "\r\n"); client.print("Content-Length: " + String(totalLength) + "\r\n"); client.print("Connection: close\r\n\r\n"); // Send the message client.print(head); // Send the photo in small pieces of 1024 bytes. // We check every piece. If one fails, Telegram would wait for ever. size_t sent = 0; for (size_t i = 0; i < fb->len; i += 1024) { size_t piece = fb->len - i; if (piece > 1024) piece = 1024; size_t written = client.write(fb->buf + i, piece); if (written != piece) { Serial.printf("Sending stopped after %u of %u bytes\n", (unsigned)(sent + written), (unsigned)fb->len); client.stop(); return false; } sent += written; } client.print(tail); // Read the answer of Telegram. // Do NOT stop when the connection closes. Telegram answers and closes at once, // and the answer is often still waiting in the buffer at that moment. String answer = ""; unsigned long startTime = millis(); while (millis() - startTime < 15000) { while (client.available()) { answer += (char)client.read(); startTime = millis(); } if (answer.length() > 0 && !client.connected()) break; // the whole answer arrived and the server hung up delay(10); } client.stop(); if (answer.length() == 0) { Serial.println("Telegram did not answer at all."); Serial.println("Check your internet, and check that your network does not block Telegram."); return false; } if (answer.indexOf("\"ok\":true") > 0) { Serial.println("The photo was sent to Telegram"); return true; } Serial.println("Telegram did not accept the photo. The answer was:"); Serial.println(answer); return false; } void takeAndSendPhoto() { camera_fb_t *fb = esp_camera_fb_get(); if (!fb) { Serial.println("Photo capture failed"); return; } Serial.printf("Photo taken: %u bytes\n", fb->len); sendPhotoToTelegram(fb); esp_camera_fb_return(fb); // give the memory back to the camera } void setup() { Serial.begin(115200); delay(1000); // INPUT_PULLUP: the pin is HIGH when the switch is open pinMode(DOOR_PIN, INPUT_PULLUP); if (!initCamera()) { Serial.println("Stopped"); while (true) delay(1000); } WiFi.mode(WIFI_STA); WiFi.begin(WIFI_SSID, WIFI_PASSWORD); Serial.print("Connecting to WiFi"); while (WiFi.status() != WL_CONNECTED) { delay(500); Serial.print("."); } Serial.println(); Serial.print("Connected. IP address: "); Serial.println(WiFi.localIP()); doorState = digitalRead(DOOR_PIN); lastReadState = doorState; if (doorState == DOOR_OPEN) Serial.println("Ready. The door is open now."); else Serial.println("Ready. The door is closed now."); } void loop() { int reading = digitalRead(DOOR_PIN); // The switch bounces, so we wait until the value is stable if (reading != lastReadState) { lastReadState = reading; lastChangeTime = millis(); } if (millis() - lastChangeTime >= DEBOUNCE_TIME && reading != doorState) { doorState = reading; if (doorState == DOOR_OPEN) { Serial.println("The door is open!"); if (millis() - lastSendTime >= QUIET_TIME) { takeAndSendPhoto(); lastSendTime = millis(); } else { Serial.println("Too soon after the last photo. Nothing is sent."); } } else { Serial.println("The door is closed."); } } }

Étapes rapides

Nouveau sur l'ESP32 S3 ? Suivez d'abord notre guide ESP32 S3 - Premiers pas.
Créez votre bot Telegram et trouvez votre ID de chat. Voir les étapes ci-dessus.
Débranchez le câble USB, puis connectez les deux fils du capteur de porte comme dans le tableau ci-dessus.
Copiez le code ci-dessus et collez-le dans l'Arduino IDE.
Changez YOUR_WIFI_SSID, YOUR_WIFI_PASSWORD, YOUR_TELEGRAM_BOT_TOKEN et YOUR_TELEGRAM_CHAT_ID.
Changez les réglages dans le menu Tools. Voir le tableau ci-dessus.
Compilez et téléversez le code sur la carte ESP32 S3 en cliquant sur le bouton Upload dans l'Arduino IDE.

Ouvrez le moniteur série dans l'Arduino IDE.

Comment ouvrir le moniteur série sur Arduino IDE

Appuyez une fois sur le bouton RESET.
Mettez les deux parties du capteur l'une à côté de l'autre. Le moniteur série indique que la porte est fermée.
Éloignez les deux parties l'une de l'autre, comme une porte qui s'ouvre.
Regardez votre téléphone. La photo arrive dans votre discussion Telegram, avec le texte en dessous :

ArduinoBot

bot

Today

The door is open!

10:15 AM

Photo de la caméra de porte ESP32 S3 dans Telegram

Moniteur série

Les relevés suivants ont été enregistrés en 2026 :

Newbiely | Arduino IDE 2.3.8

──

☐

Newbiely.ino

···

8 Serial.println("Hello World!");

Output

Serial Monitor

Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')

New Line

9600 baud

[2026-09-23 14:00:01] Camera sensor: OV5640 (5 MP, max QSXGA 2592x1944) [2026-09-23 14:00:01] Connecting to WiFi... [2026-09-23 14:00:04] Connected. IP address: 192.168.0.2 [2026-09-23 14:00:04] Ready. The door is closed now. [2026-09-23 14:01:12] The door is open! [2026-09-23 14:01:12] Photo taken: 51353 bytes [2026-09-23 14:01:12] Connecting to Telegram... [2026-09-23 14:01:15] The photo was sent to Telegram [2026-09-23 14:01:31] The door is closed.

Ln 11, Col 1

ESP32S3 Dev Module on COM15

Quand la porte est rouverte trop vite, le code le signale et n'envoie rien :

Newbiely | Arduino IDE 2.3.8

──

☐

Newbiely.ino

···

8 Serial.println("Hello World!");

Output

Serial Monitor

Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')

New Line

9600 baud

[2026-09-23 14:01:38] The door is open! [2026-09-23 14:01:38] Too soon after the last photo. Nothing is sent.

Ln 11, Col 1

ESP32S3 Dev Module on COM15

Dépannage

Le moniteur série indique toujours que la porte est ouverte, même quand elle est fermée.

Les deux parties sont trop éloignées. Elles doivent presque se toucher, avec un espace inférieur à 15 mm.
Vérifiez le fil sur GPIO2 et le fil sur GND.
Certains capteurs de porte sont « normalement fermés » au lieu de « normalement ouverts ». Dans ce cas, les deux lignes #define DOOR_CLOSED LOW et #define DOOR_OPEN HIGH doivent échanger leurs valeurs.

Le moniteur série indique toujours que la porte est fermée.

Les deux fils se touchent probablement, ou un fil est sur la mauvaise broche. Un fil va à GPIO2, l'autre à GND.

Un mouvement de porte envoie deux ou trois photos.

Augmentez DEBOUNCE_TIME de 50 à 150.

Le moniteur série affiche Forbidden: bot can't initiate conversation with a user.

Vous n'avez jamais écrit à votre bot. Ouvrez Telegram, trouvez votre bot, et envoyez-lui un message quelconque. Puis appuyez sur RESET sur la carte.

Le moniteur série affiche Unauthorized.

Le jeton de votre bot est incorrect. Copiez-le à nouveau depuis BotFather. Le jeton a deux parties reliées par : et vous avez besoin de tout.

Le moniteur série affiche chat not found.

Votre ID de chat est incorrect. Redemandez à @myidbot avec /getid. Ne mettez pas d'espaces autour du nombre.

Le moniteur série affiche Telegram did not answer at all.

La carte a envoyé la photo mais n'a rien reçu en retour. Vérifiez votre connexion internet. Certains réseaux scolaires et d'entreprise bloquent Telegram, essayez donc le partage de connexion de votre téléphone. Si la photo arrive bien sur votre téléphone même si la carte indique un échec, votre boucle de lecture s'arrête trop tôt. Voir la remarque sur client.connected() ci-dessus.

Le moniteur série affiche Sending stopped after ... bytes.

Le WiFi a coupé pendant l'envoi de la photo. Rapprochez la carte du routeur, ou utilisez une taille d'image plus petite.

Le moniteur série affiche Cannot connect to Telegram.

Vérifiez que votre WiFi fonctionne. L'adresse IP doit apparaître dans le moniteur série. Certains réseaux scolaires et d'entreprise bloquent Telegram, essayez donc le partage de connexion de votre téléphone.

La photo prend beaucoup de temps.

Utilisez une taille d'image plus petite. FRAMESIZE_VGA (640×480) fait environ la moitié de SVGA.

La photo est sombre.

La caméra ne voit pas dans le noir. Ajoutez une lumière près de la porte, ou une lampe qui s'allume avec la porte.

Applications

Un capteur de porte vous donne un événement clair avec presque aucune fausse alarme, donc ce projet est utile partout où quelque chose doit rester fermé. Voici des projets pratiques que vous pouvez construire avec ce code :

Caméra de sécurité de porte d'entrée : Voyez qui ouvre votre porte d'entrée pendant que vous êtes au travail ou en vacances.
Caméra de boîte à colis : Recevez une photo quand le livreur ouvre votre boîte à colis ou votre boîte aux lettres.
Alarme d'armoire à pharmacie : Sachez quand un enfant ouvre une armoire qui doit rester fermée.
Compteur de porte de magasin : Gardez une photo de chaque client qui ouvre la porte du magasin.
Alarme de boîte à outils, coffre-fort ou casier : Recevez une photo au moment où quelqu'un l'ouvre, même quand vous êtes loin.
Alerte de porte de garage : Sachez quand votre porte de garage ou votre abri de jardin est ouvert la nuit.
Alarme d'ouverture de fenêtre : Mettez le capteur sur une fenêtre au lieu d'une porte, et recevez une photo quand elle s'ouvre.
Baie de serveurs et armoire de contrôle : Gardez un historique en photos de chaque personne qui ouvre une armoire au travail.
Surveillance de réfrigérateur ou congélateur : Un projet familial amusant pour voir qui prend la dernière part de gâteau.
Chambre d'hôtel ou appartement loué : Sachez que la porte est restée fermée pendant que la pièce était vide.

Vidéo

Regardez ci-dessous le tutoriel vidéo étape par étape pour ce projet ESP32 S3.

Défis

Débutant : Changez le texte sous la photo de The door is open! à votre propre message.
Intermédiaire : Envoyez aussi un message quand la porte se referme, pour savoir combien de temps elle est restée ouverte.
Avancé : Envoyez une photo seulement la nuit, entre 22h00 et 06h00. Utilisez un serveur de temps NTP pour lire l'heure réelle.

Références du langage

Commentaires

Tutoriels connexes

※ NOS MESSAGES

N'hésitez pas à partager le lien de ce tutoriel. Cependant, veuillez ne pas utiliser notre contenu sur d'autres sites web. Nous avons investi beaucoup d'efforts et de temps pour créer ce contenu, veuillez respecter notre travail !