ESP32-CAM : prenez et envoyez des photos par e-mail à l’aide d’un serveur SMTP

ESP32-CAM : prenez et envoyez des photos par e-mail à l'aide d'un serveur SMTP

Ce didacticiel montre comment envoyer des photos capturées de l’ESP32-CAM à votre compte de messagerie à l’aide d’un serveur SMTP. Nous allons vous montrer un exemple simple qui prend une photo au démarrage de l’ESP32 et l’envoie en pièce jointe dans un e-mail. La dernière photo prise est temporairement enregistrée dans l’ESP32 SPIFFS.

ESP32-CAM Prendre et envoyer des photos par e-mail à l'aide d'un serveur SMTP Arduino IDE

Pour que ce projet fonctionne, l’ESP32-CAM doit être connecté à un routeur avec accès à Internet – doit être connecté à votre réseau local.

Ce projet est compatible avec n’importe quel Carte caméra ESP32 avec la caméra OV2640. Il vous suffit de vous assurer que vous utilisez la bonne affectation de broches pour la carte que vous utilisez : Cartes de caméra ESP32-CAM : Guide d’affectation des broches et des GPIO.

Bibliothèque ESP32 MailClient

Pour envoyer des e-mails avec le ESP32-CAM, nous utiliserons le Bibliothèque ESP32 MailClient. Cette bibliothèque permet à l’ESP32 d’envoyer et de recevoir des e-mails avec ou sans pièce jointe via les serveurs SMTP et IMAP.

Dans ce projet, nous utiliserons SMTP pour envoyer un e-mail avec une pièce jointe. La pièce jointe est une photo prise avec l’ESP32-CAM.

SMTP signifie Simple Mail Transfer Protocol et c’est une norme Internet pour la transmission d’e-mails. Pour envoyer des e-mails par code, vous devez connaître les détails de votre serveur SMTP. Chaque fournisseur de messagerie a un serveur SMTP différent.

Installation de la bibliothèque ESP32 MailClient

Avant de poursuivre ce didacticiel, vous devez installer le Bibliothèque ESP32 MailClient. Cette bibliothèque peut être installée via le gestionnaire de bibliothèque IDE Arduino.

Dans votre IDE Arduino, accédez à Esquisser > Inclure la bibliothèque > Gérer les bibliothèques…

Le gestionnaire de bibliothèque devrait s’ouvrir. Rechercher Client de messagerie ESP32 par Mobizt et installez la bibliothèque comme indiqué ci-dessous.

Installer la bibliothèque ESP32 Envoyer un e-mail Serveur SMTP Arduino IDE

E-mail de l’expéditeur (nouveau compte)

Nous vous recommandons de créer un nouveau compte de messagerie pour envoyer les e-mails à votre adresse e-mail personnelle principale. N’utilisez pas votre messagerie personnelle principale pour envoyer des e-mails via ESP32. Si quelque chose ne va pas dans votre code ou si par erreur vous faites trop de demandes, vous pouvez être banni ou avoir votre compte temporairement désactivé.

Nous utiliserons un compte Gmail.com nouvellement créé pour envoyer les e-mails, mais vous pouvez utiliser n’importe quel autre fournisseur de messagerie. L’e-mail du destinataire peut être votre e-mail personnel sans aucun problème.

Créer un compte de messagerie d’expéditeur

Créez un nouveau compte de messagerie pour envoyer des e-mails avec l’ESP32. Si vous souhaitez utiliser un compte Gmail, allez sur ce lien pour en créer un nouveau.

Gmail Créer un nouveau compte

Autoriser les applications moins sécurisées

Autorisez les applications moins sécurisées à accéder à ce nouveau compte Gmail, afin de pouvoir envoyer des e-mails. Tu peux Ouvrez ce lien pour accéder à ce menu.

Gmail permet aux applications moins sécurisées d'envoyer des e-mails avec ESP32

Paramètres du serveur SMTP de Gmail

Si vous utilisez un compte Gmail, voici les détails du serveur SMTP :

  • Serveur SMTP : smtp.gmail.com
  • Nom d’utilisateur SMTP : adresse Gmail complète
  • Mot de passe SMTP : votre mot de passe Gmail
  • Port SMTP (TLS) : 587
  • Port SMTP (SSL) : 465
  • SMTP TLS/SSL requis : Oui

Paramètres du serveur SMTP Outlook

Pour les comptes Outlook, voici les paramètres du serveur SMTP :

  • Serveur SMTP : smtp.office365.com
  • Nom d’utilisateur SMTP : adresse e-mail Outlook complète
  • Mot de passe SMTP : votre mot de passe Outlook
  • Port SMTP : 587
  • SMTP TLS/SSL requis : Oui

Paramètres du serveur SMTP en direct ou Hotmail

Pour les comptes Live ou Hotmail, voici les paramètres du serveur SMTP :

  • Serveur SMTP : smtp.live.com
  • Nom d’utilisateur SMTP : adresse e-mail complète Live/Hotmail
  • Mot de passe SMTP : votre mot de passe Windows Live Hotmail
  • Port SMTP : 587
  • SMTP TLS/SSL requis : Oui

Si vous utilisez un autre fournisseur de messagerie, vous devez rechercher ses paramètres de serveur SMTP. Maintenant, vous avez tout prêt pour commencer à envoyer des e-mails avec l’ESP32-CAM.

Code – ESP32-CAM Envoyer un e-mail

Le code suivant prend une photo lors du premier démarrage de l’ESP32-CAM et l’envoie à votre compte de messagerie. Avant de télécharger le code, assurez-vous d’avoir inséré les paramètres de votre e-mail d’expéditeur ainsi que votre e-mail de destinataire.

/*********
  Rui Santos
  Complete instructions at https://Raspberryme.com/esp32-cam-projects-ebook/
  
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*********/

#include "esp_camera.h"
#include "SPI.h"
#include "driver/rtc_io.h"
#include "ESP32_MailClient.h"
#include <FS.h>
#include <SPIFFS.h>
#include <WiFi.h>

// REPLACE WITH YOUR NETWORK CREDENTIALS
const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

// To send Email using Gmail use port 465 (SSL) and SMTP Server smtp.gmail.com
// YOU MUST ENABLE less secure app option https://myaccount.google.com/lesssecureapps?pli=1
#define emailSenderAccount    "[email protected]"
#define emailSenderPassword   "SENDER_ACCOUNT_PASSWORD"
#define smtpServer            "smtp.gmail.com"
#define smtpServerPort        465
#define emailSubject          "ESP32-CAM Photo Captured"
#define emailRecipient        "[email protected]"

#define CAMERA_MODEL_AI_THINKER

#if defined(CAMERA_MODEL_AI_THINKER)
  #define PWDN_GPIO_NUM     32
  #define RESET_GPIO_NUM    -1
  #define XCLK_GPIO_NUM      0
  #define SIOD_GPIO_NUM     26
  #define SIOC_GPIO_NUM     27
  
  #define Y9_GPIO_NUM       35
  #define Y8_GPIO_NUM       34
  #define Y7_GPIO_NUM       39
  #define Y6_GPIO_NUM       36
  #define Y5_GPIO_NUM       21
  #define Y4_GPIO_NUM       19
  #define Y3_GPIO_NUM       18
  #define Y2_GPIO_NUM        5
  #define VSYNC_GPIO_NUM    25
  #define HREF_GPIO_NUM     23
  #define PCLK_GPIO_NUM     22
#else
  #error "Camera model not selected"
#endif

// The Email Sending data object contains config and data to send
SMTPData smtpData;

// Photo File Name to save in SPIFFS
#define FILE_PHOTO "/photo.jpg"

void setup() {
  WRITE_PERI_REG(RTC_CNTL_BROWN_OUT_REG, 0); //disable brownout detector
  
  Serial.begin(115200);
  Serial.println();

  // Connect to Wi-Fi
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi...");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  
  if (!SPIFFS.begin(true)) {
    Serial.println("An Error has occurred while mounting SPIFFS");
    ESP.restart();
  }
  else {
    delay(500);
    Serial.println("SPIFFS mounted successfully");
  }
  
  // Print ESP32 Local IP Address
  Serial.print("IP Address: http://");
  Serial.println(WiFi.localIP());
   
  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_sscb_sda = SIOD_GPIO_NUM;
  config.pin_sscb_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;
  
  if(psramFound()){
    config.frame_size = FRAMESIZE_UXGA;
    config.jpeg_quality = 10;
    config.fb_count = 2;
  } else {
    config.frame_size = FRAMESIZE_SVGA;
    config.jpeg_quality = 12;
    config.fb_count = 1;
  }

  // Initialize camera
  esp_err_t err = esp_camera_init(&config);
  if (err != ESP_OK) {
    Serial.printf("Camera init failed with error 0x%x", err);
    return;
  }
  
  capturePhotoSaveSpiffs();
  sendPhoto();
}

void loop() {

}

// Check if photo capture was successful
bool checkPhoto( fs::FS &fs ) {
  File f_pic = fs.open( FILE_PHOTO );
  unsigned int pic_sz = f_pic.size();
  return ( pic_sz > 100 );
}

// Capture Photo and Save it to SPIFFS
void capturePhotoSaveSpiffs( void ) {
  camera_fb_t * fb = NULL; // pointer
  bool ok = 0; // Boolean indicating if the picture has been taken correctly

  do {
    // Take a photo with the camera
    Serial.println("Taking a photo...");

    fb = esp_camera_fb_get();
    if (!fb) {
      Serial.println("Camera capture failed");
      return;
    }

    // Photo file name
    Serial.printf("Picture file name: %sn", FILE_PHOTO);
    File file = SPIFFS.open(FILE_PHOTO, FILE_WRITE);

    // Insert the data in the photo file
    if (!file) {
      Serial.println("Failed to open file in writing mode");
    }
    else {
      file.write(fb->buf, fb->len); // payload (image), payload length
      Serial.print("The picture has been saved in ");
      Serial.print(FILE_PHOTO);
      Serial.print(" - Size: ");
      Serial.print(file.size());
      Serial.println(" bytes");
    }
    // Close the file
    file.close();
    esp_camera_fb_return(fb);

    // check if file has been correctly saved in SPIFFS
    ok = checkPhoto(SPIFFS);
  } while ( !ok );
}

void sendPhoto( void ) {
  // Preparing email
  Serial.println("Sending email...");
  // Set the SMTP Server Email host, port, account and password
  smtpData.setLogin(smtpServer, smtpServerPort, emailSenderAccount, emailSenderPassword);
  
  // Set the sender name and Email
  smtpData.setSender("ESP32-CAM", emailSenderAccount);
  
  // Set Email priority or importance High, Normal, Low or 1 to 5 (1 is highest)
  smtpData.setPriority("High");

  // Set the subject
  smtpData.setSubject(emailSubject);
    
  // Set the email message in HTML format
  smtpData.setMessage("<h2>Photo captured with ESP32-CAM and attached in this email.</h2>", true);
  // Set the email message in text format
  //smtpData.setMessage("Photo captured with ESP32-CAM and attached in this email.", false);

  // Add recipients, can add more than one recipient
  smtpData.addRecipient(emailRecipient);
  //smtpData.addRecipient(emailRecipient2);

  // Add attach files from SPIFFS
  smtpData.addAttachFile(FILE_PHOTO, "image/jpg");
  // Set the storage type to attach files in your email (SPIFFS)
  smtpData.setFileStorageType(MailClientStorageType::SPIFFS);

  smtpData.setSendCallback(sendCallback);
  
  // Start sending Email, can be set callback function to track the status
  if (!MailClient.sendMail(smtpData))
    Serial.println("Error sending Email, " + MailClient.smtpErrorReason());

  // Clear all data from Email object to free memory
  smtpData.empty();
}

// Callback function to get the Email sending status
void sendCallback(SendStatus msg) {
  //Print the current status
  Serial.println(msg.info());
}

Afficher le code brut

Comment fonctionne le code

Continuez à lire pour savoir comment fonctionne le code, ou passez à la Manifestation section. N’oubliez pas d’insérer vos informations d’identification réseau et vos paramètres de messagerie dans le code. De plus, si vous utilisez un modèle de caméra autre qu’un ESP32-CAM AI-Thinker, n’oubliez pas de modifier l’affectation des broches.

Importation de bibliothèques

Importez les bibliothèques requises. le ESP32_MailClient.h est utilisé pour envoyer des e-mails, le FS.h et SPIFFS.h sont utilisés pour accéder et enregistrer des fichiers dans SPIFFS et le WiFi.h La bibliothèque est utilisée pour initialiser le Wi-Fi et connecter votre ESP32-CAM à votre réseau local.

#include "esp_camera.h"
#include "SPI.h"
#include "driver/rtc_io.h"
#include "ESP32_MailClient.h"
#include <FS.h>
#include <SPIFFS.h>
#include <WiFi.h>

Identifiants du réseau

Insérez vos identifiants réseau dans les variables suivantes :

const char* ssid = "REPLACE_WITH_YOUR_SSID";
const char* password = "REPLACE_WITH_YOUR_PASSWORD";

Paramètres de messagerie

Tapez le compte de l’expéditeur de l’e-mail sur le emailExpéditeurCompte variable et son mot de passe sur le emailExpéditeurMot de passe variable.

#define emailSenderAccount   "[email protected]"
#define emailSenderPassword  "SENDER_ACCOUNT_PASSWORD"

Insérez l’e-mail du destinataire. C’est l’email qui va recevoir les emails envoyés par l’ESP32 :

#define emailRecipient "[email protected]"

Insérez les paramètres SMTP de votre fournisseur de messagerie sur les lignes suivantes. Nous utilisons les paramètres d’un compte Gmail. Si vous utilisez un autre fournisseur de messagerie, remplacez-le par les paramètres SMTP correspondants.

#define smtpServer "smtp.gmail.com"
#define smtpServerPort 465

Écrivez l’objet de l’e-mail sur le Sujet du courriel variable.

#define emailSubject "ESP32-CAM Photo Captured"

Créé un Données STMP objet appelé smtpDonnées qui contient les données à envoyer par e-mail et toutes les autres configurations.

SMTPData smtpData;

La photo prise avec la caméra ESP32 sera temporairement enregistrée dans SPIFFS sous le nom photo.jpg.

define FILE_PHOTO "/photo.jpg"

Broches de caméra ESP32

Définissez les broches utilisées par votre modèle de caméra. Nous utilisons l’ESP32-CAM AI-Thinker.

#define PWDN_GPIO_NUM     32
#define RESET_GPIO_NUM    -1
#define XCLK_GPIO_NUM      0
#define SIOD_GPIO_NUM     26
#define SIOC_GPIO_NUM     27

#define Y9_GPIO_NUM       35
#define Y8_GPIO_NUM       34
#define Y7_GPIO_NUM       39
#define Y6_GPIO_NUM       36
#define Y5_GPIO_NUM       21
#define Y4_GPIO_NUM       19
#define Y3_GPIO_NUM       18
#define Y2_GPIO_NUM        5
#define VSYNC_GPIO_NUM    25
#define HREF_GPIO_NUM     23
#define PCLK_GPIO_NUM     22

mettre en place()

Dans le mettre en place(), connectez l’ESP32 au Wi-Fi.

// Connect to Wi-Fi
WiFi.begin(ssid, password);
Serial.print("Connecting to WiFi...");
while (WiFi.status() != WL_CONNECTED) {
  delay(500);
  Serial.print(".");
}
Serial.println();

Initialisez SPIFFS (SPI Flash File System) pour enregistrer la dernière photo prise avec l’ESP32-CAM.

if (!SPIFFS.begin(true)) {
  Serial.println("An Error has occurred while mounting SPIFFS");
  ESP.restart();
}
else {
  delay(500);
  Serial.println("SPIFFS mounted successfully");
}

Imprimez l’adresse IP ESP32-CAM :

// Print ESP32 Local IP Address
Serial.print("IP Address: http://");
Serial.println(WiFi.localIP());

Les lignes suivantes configurent la caméra et définissent les paramètres de la caméra :

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_sscb_sda = SIOD_GPIO_NUM;
config.pin_sscb_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;

if(psramFound()){
  config.frame_size = FRAMESIZE_UXGA;
  config.jpeg_quality = 10;
  config.fb_count = 2;
} else {
  config.frame_size = FRAMESIZE_SVGA;
  config.jpeg_quality = 12;
  config.fb_count = 1;
}

Initialisez la caméra.

// Initialize camera
esp_err_t err = esp_camera_init(&config);
if (err != ESP_OK) {
  Serial.printf("Camera init failed with error 0x%x", err);
  return;
}

Après avoir initialisé la caméra, appelez le capturePhotoSaveSpiffs() et le envoyer une photo() les fonctions. Ces fonctions sont définies à la fin du code.

fonction capturePhotoSaveSpiffs()

le capturePhotoSaveSpiffs() La fonction capture une photo et l’enregistre dans l’ESP32 SPIFFS. Dans les lignes suivantes, vous prenez une photo et l’enregistrez dans le framebuffer fb:

fb = esp_camera_fb_get();
if (!fb) {
  Serial.println("Camera capture failed");
  return;
}

Ensuite, créez un nouveau fichier dans SPIFFS où la photo sera enregistrée.

Serial.printf("Picture file name: %sn", FILE_PHOTO);
File file = SPIFFS.open(FILE_PHOTO, FILE_WRITE);

Vérifiez si le fichier a été créé avec succès. Sinon, imprimez un message d’erreur.

if (!file) {
  Serial.println("Failed to open file in writing mode");
}

Si un nouveau fichier a été créé avec succès, « copiez » l’image de la mémoire tampon vers ce fichier nouvellement créé.

file.write(fb->buf, fb->len); // payload (image), payload length
Serial.print("The picture has been saved in ");
Serial.print(FILE_PHOTO);
Serial.print(" - Size: ");
Serial.print(file.size());
Serial.println(" bytes");

Fermez le fichier et effacez le tampon pour une utilisation future.

file.close();
esp_camera_fb_return(fb);

Enfin, vérifiez si la photo a été prise et enregistrée avec succès. Nous pouvons le faire en vérifiant la taille du fichier photo avec le vérifierPhoto() une fonction.

ok = checkPhoto(SPIFFS);

le vérifierPhoto() fonction, vérifie la taille de l’image du fichier. Si la taille de l’image est supérieure à 100 octets, il est presque certain que la photo a été prise et enregistrée avec succès. Dans ce cas, il renvoie 1.

bool checkPhoto( fs::FS &fs ) {
  File f_pic = fs.open( FILE_PHOTO );
  unsigned int pic_sz = f_pic.size();
  return ( pic_sz > 100 );
}

Alors le d’accord variable est égale à 1.

ok = checkPhoto(SPIFFS);

Si la taille de la photo est inférieure à 100 octets, le d’accord variable continuera à être 0, et il continuera à essayer de prendre une nouvelle photo et de l’enregistrer.

fonction sendPhoto()

Après avoir enregistré avec succès la photo dans SPIFFS, nous l’enverrons par e-mail en appelant le envoyer une photo() une fonction. Jetons un coup d’œil à cette fonction.

void sendPhoto( void ) {

La ligne suivante définit l’hôte du serveur SMTP, le port SMTP, l’adresse e-mail du compte et le mot de passe utilisé pour se connecter :

smtpData.setLogin(smtpServer, smtpServerPort, emailSenderAccount, emailSenderPassword);

Définissez le nom de l’expéditeur et l’adresse e-mail de l’expéditeur. Dans ce cas, nous définissons le nom de l’expéditeur sur ESP32-CAM.

smtpData.setSender("ESP32-CAM", emailSenderAccount);

Définissez la priorité des e-mails.

smtpData.setPriority("High");

Définissez l’objet de l’e-mail.

smtpData.setSubject(emailSubject);

La ligne suivante définit le message. Vous pouvez envoyer un texte HTML ou du texte brut. Dans ce cas, nous envoyons un message avec du HTML.

smtpData.setMessage("<h2>Photo captured with ESP32-CAM and attached in this email.</h2>", true);

Lors de l’envoi d’un message au format HTML, vous devez passer vrai comme deuxième paramètre de la setMessage() méthode. Si vous souhaitez envoyer du texte brut, définissez faux.

//smtpData.setMessage("Photo captured with ESP32-CAM and attached in this email.", false);

Enfin, définissez l’e-mail du destinataire. C’est l’email qui recevra les messages de l’ESP32.

smtpData.addRecipient(emailRecipient);

Ensuite, pour joindre un fichier, il suffit d’appeler le addAtatachFile() sur le smtpDonnées objet et passez en argument le chemin du fichier.

smtpData.addAttachFile(FILE_PHOTO, "image/jpg");

Enfin, vous devez définir où vos fichiers sont enregistrés (SPIFFS ou carte SD). Nous utilisons SPIFFS :

smtpData.setFileStorageType(MailClientStorageType::SPIFFS);

Définissez une fonction de rappel qui sera appelée lors de l’envoi d’un e-mail.

smtpData.setSendCallback(sendCallback);

le envoyerCallback() La fonction renvoie si l’e-mail a été envoyé avec succès ou non.

Maintenant que nous avons défini tous les détails de la smtpDonnées, nous sommes prêts à envoyer l’e-mail.

if (!MailClient.sendMail(smtpData))
  Serial.println("Error sending Email, " + MailClient.smtpErrorReason());

Après avoir envoyé l’e-mail, vous pouvez effacer toutes les données du smtpDonnées objet.

smtpData.empty();

Dans cet exemple, l’email est envoyé une seule fois au démarrage de l’ESP32, c’est pourquoi le boucler() est vide. L’idée est d’adapter le code à utiliser dans vos propres projets.

void loop() {

}

Pour envoyer un nouvel e-mail. Vous avez juste besoin de réinitialiser votre carte (appuyez sur le bouton RESET intégré
bouton), afin qu’il redémarre et exécute à nouveau le code.

Manifestation

Après avoir apporté les modifications nécessaires au code : brochage de la caméra, adresse e-mail de l’expéditeur, mot de passe de l’e-mail de l’expéditeur, adresse e-mail du destinataire et identifiants réseau, vous pouvez télécharger le code sur votre tableau.

Si vous ne savez pas comment télécharger du code sur l’ESP32-CAM, lisez le post suivant :

Après le téléchargement, ouvrez le moniteur série et appuyez sur le bouton ESP32-CAM RESET. L’ESP32 doit se connecter au Wi-Fi, prendre une photo, l’enregistrer dans SPIFFS, se connecter au serveur SMTP et envoyer l’e-mail comme indiqué ci-dessous.

ESP32 CAM envoyer une photo par e-mail démonstration du moniteur série

Après quelques secondes, vous devriez avoir un nouvel e-mail de l’ESP32-CAM dans votre boîte de réception. Comme vous pouvez le voir dans l’image ci-dessous, le nom de l’e-mail de l’expéditeur est « ESP32-CAM » comme nous l’avons défini dans le code et le sujet « ESP32-CAM photo capturée ».

ESP32 CAM Email avec photo reçue dans la boîte de réception

Ouvrez l’e-mail et vous devriez voir une photo capturée par l’ESP32-CAM.

ESP32 CAM Envoyer une photo à la boîte de réception Gmail

Vous pouvez ouvrir ou télécharger la photo pour la voir en taille réelle.

Photo prise avec ESP32 CAM Full Size

Conclusion

Dans ce tutoriel, vous avez appris à envoyer des e-mails avec des photos prises avec l’ESP32-CAM. L’exemple présenté est le plus simple possible : il prend une photo et l’envoie par mail au premier démarrage de l’ESP32-CAM. Pour envoyer un autre e-mail, vous devez réinitialiser le tableau.

Ce projet n’a pas d’application pratique, mais il est utile de comprendre comment envoyer un email avec une pièce jointe. Après cela, il devrait être assez facile d’inclure cette fonctionnalité dans vos propres projets ESP32-CAM.

Autres projets ESP32-CAM que vous pourriez aimer :

En savoir plus sur l’ESP32-CAM :

Merci d’avoir lu.