MicroPython Envoyer des e-mails avec ESP32/ESP826

MicroPython Envoyer des e-mails avec ESP32/ESP826

Apprenez à programmer les cartes ESP32 ou ESP8266 NodeMCU avec MicroPython pour envoyer des e-mails à l’aide d’un serveur SMTP. Cette fonctionnalité peut être utile dans vos projets d’automatisation et IoT pour envoyer des notifications d’alerte, envoyer des messages avec des lectures de capteurs, et bien plus encore.

MicroPython Envoyer des e-mails avec la carte ESP32 ESP826 NodeMCU

Si vous préférez programmer vos cartes à l’aide de l’IDE Arduino, vous pouvez plutôt consulter les tutoriels suivants :

Conditions préalables

Nouveau sur MicroPython ? Vous pouvez commencer ici : Premiers pas avec MicroPython sur ESP32 et ESP8266.

Pour suivre ce tutoriel, vous avez besoin du firmware MicroPython installé dans vos cartes ESP32 ou ESP8266. Vous avez également besoin d’un IDE pour écrire et télécharger le code sur votre carte. Nous suggérons d’utiliser Thonny IDE ou uPyCraft IDE :

Ou, si vous connaissez VS Code, vous pouvez utiliser l’extension PyMakr :

Pour une comparaison entre différents IDE MicroPython, lisez : IDE MicroPython pour ESP32 et ESP8266.

En savoir plus sur MicroPython : Programmation MicroPython avec ESP32 et ESP8266 eBook.

Présentation des serveurs SMTP

SMTP moyens Protocole de transfert de courrier simple et c’est une norme Internet pour la transmission d’e-mails. Pour envoyer des e-mails à l’aide d’une carte ESP32 ou ESP8266, vous devez les connecter à un serveur SMTP.

Module de courrier électronique

Pour envoyer facilement des e-mails avec MicroPython, nous allons utiliser un module appelé uMail. Ce module ne fait pas partie de la collection standard de bibliothèques MicroPython, nous devrons donc le télécharger séparément sur notre carte. Nous fournirons des instructions à ce sujet plus tard dans le didacticiel.

Paramètres du serveur SMTP

Pour envoyer des e-mails avec les cartes ESP32 ou ESP8266, vous avez besoin d’un e-mail d’expéditeur et vous devrez connaître les paramètres de votre serveur de messagerie SMTP. Vous trouverez ci-dessous les paramètres des fournisseurs de messagerie les plus populaires.

Paramètres du serveur SMTP 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 Live 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. Vous les trouverez facilement avec une recherche rapide sur Google.

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 e-mail personnel principal pour envoyer des e-mails via ESP32 ou ESP8266. Si quelque chose ne va pas dans votre code ou si par erreur vous faites trop de demandes, vous pouvez être banni ou voir 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/ESP8266. Si vous souhaitez utiliser un compte Gmail, allez sur ce lien pour en créer un nouveau.

Gmail Créer un nouveau compte

Créer un mot de passe d’application

Vous devez créer un mot de passe d’application pour que les nouveaux appareils puissent envoyer des e-mails à l’aide de votre compte Gmail. Un mot de passe d’application est un code d’accès à 16 chiffres qui autorise une application ou un appareil moins sécurisé à accéder à votre compte Google. En savoir plus sur la connexion avec des mots de passe d’application ici.

Un mot de passe d’application ne peut être utilisé qu’avec des comptes qui ont Vérification en 2 étapes activée.

  1. Ouvrez votre Compte google.
  2. Dans le panneau de navigation, sélectionnez Sécurité.
  3. Sous « Connexion à Google », sélectionnez Vérification en 2 étapes > Commencer.
  4. Suivez les étapes à l’écran.

Après avoir activé la vérification en 2 étapes, vous pouvez créer un mot de passe d’application.

  1. Ouvrez votre Compte google.
  2. Dans le panneau de navigation, sélectionnez Sécurité.
  3. Sous « Connexion à Google », sélectionnez Mots de passe d’application.
Créer un mot de passe d'application gmail
  1. Dans le champ Sélectionner une application, choisissez poster. Pour l’appareil, sélectionnez Autre et donnez-lui un nom, par exemple ESP32. Ensuite, cliquez sur Générer. Une fenêtre apparaîtra avec un mot de passe que vous utiliserez avec l’ESP32 ou l’ESP8266 pour envoyer des e-mails. Enregistrez ce mot de passe (même s’il indique que vous n’aurez pas besoin de vous en souvenir) car vous en aurez besoin plus tard.
Mot de passe d'application généré gmail

Maintenant, vous devriez avoir un mot de passe d’application que vous utiliserez sur le script micropython ESP32/ESP8266 pour envoyer les e-mails.

Mot de passe de l'application Gmail créé pour ESP32 envoyer des e-mails

Si vous utilisez un autre fournisseur de messagerie, vérifiez comment créer un mot de passe d’application. Vous devriez pouvoir trouver les instructions avec une recherche rapide sur Google « votre_fournisseur_email + créer un mot de passe d’application ».

Téléchargement du module uMail

Pour envoyer les e-mails, nous utiliserons le module uMail. Vous pouvez vérifier son Page Github et plusieurs exemples ici. Cette bibliothèque ne fait pas partie de la bibliothèque MicroPython standard par défaut. Vous devez donc télécharger le fichier suivant sur votre carte ESP32/ESP8266 (enregistrez-le sous le nom umail.py) avant d’utiliser la bibliothèque.

# Complete project details: https://Raspberryme.com/micropython-send-emails-esp32-esp826/
# uMail (MicroMail) for MicroPython
# Copyright (c) 2018 Shawwwn <[email protected]> https://github.com/shawwwn/uMail/blob/master/umail.py
# License: MIT
import usocket

DEFAULT_TIMEOUT = 10 # sec
LOCAL_DOMAIN = '127.0.0.1'
CMD_EHLO = 'EHLO'
CMD_STARTTLS = 'STARTTLS'
CMD_AUTH = 'AUTH'
CMD_MAIL = 'MAIL'
AUTH_PLAIN = 'PLAIN'
AUTH_LOGIN = 'LOGIN'

class SMTP:
    def cmd(self, cmd_str):
        sock = self._sock;
        sock.write('%s\r\n' % cmd_str)
        resp = []
        next = True
        while next:
            code = sock.read(3)
            next = sock.read(1) == b'-'
            resp.append(sock.readline().strip().decode())
        return int(code), resp

    def __init__(self, host, port, ssl=False, username=None, password=None):
        import ussl
        self.username = username
        addr = usocket.getaddrinfo(host, port)[0][-1]
        sock = usocket.socket(usocket.AF_INET, usocket.SOCK_STREAM)
        sock.settimeout(DEFAULT_TIMEOUT)
        sock.connect(addr)
        if ssl:
            sock = ussl.wrap_socket(sock)
        code = int(sock.read(3))
        sock.readline()
        assert code==220, 'cant connect to server %d, %s' % (code, resp)
        self._sock = sock

        code, resp = self.cmd(CMD_EHLO + ' ' + LOCAL_DOMAIN)
        assert code==250, '%d' % code
        if not ssl and CMD_STARTTLS in resp:
            code, resp = self.cmd(CMD_STARTTLS)
            assert code==220, 'start tls failed %d, %s' % (code, resp)
            self._sock = ussl.wrap_socket(sock)

        if username and password:
            self.login(username, password)

    def login(self, username, password):
        self.username = username
        code, resp = self.cmd(CMD_EHLO + ' ' + LOCAL_DOMAIN)
        assert code==250, '%d, %s' % (code, resp)

        auths = None
        for feature in resp:
            if feature[:4].upper() == CMD_AUTH:
                auths = feature[4:].strip('=').upper().split()
        assert auths!=None, "no auth method"

        from ubinascii import b2a_base64 as b64
        if AUTH_PLAIN in auths:
            cren = b64("\0%s\0%s" % (username, password))[:-1].decode()
            code, resp = self.cmd('%s %s %s' % (CMD_AUTH, AUTH_PLAIN, cren))
        elif AUTH_LOGIN in auths:
            code, resp = self.cmd("%s %s %s" % (CMD_AUTH, AUTH_LOGIN, b64(username)[:-1].decode()))
            assert code==334, 'wrong username %d, %s' % (code, resp)
            code, resp = self.cmd(b64(password)[:-1].decode())
        else:
            raise Exception("auth(%s) not supported " % ', '.join(auths))

        assert code==235 or code==503, 'auth error %d, %s' % (code, resp)
        return code, resp

    def to(self, addrs, mail_from=None):
        mail_from = self.username if mail_from==None else mail_from
        code, resp = self.cmd(CMD_EHLO + ' ' + LOCAL_DOMAIN)
        assert code==250, '%d' % code
        code, resp = self.cmd('MAIL FROM: <%s>' % mail_from)
        assert code==250, 'sender refused %d, %s' % (code, resp)

        if isinstance(addrs, str):
            addrs = [addrs]
        count = 0
        for addr in addrs:
            code, resp = self.cmd('RCPT TO: <%s>' % addr)
            if code!=250 and code!=251:
                print('%s refused, %s' % (addr, resp))
                count += 1
        assert count!=len(addrs), 'recipient refused, %d, %s' % (code, resp)

        code, resp = self.cmd('DATA')
        assert code==354, 'data refused, %d, %s' % (code, resp)
        return code, resp

    def write(self, content):
        self._sock.write(content)

    def send(self, content=""):
        if content:
            self.write(content)
        self._sock.write('\r\n.\r\n') # the five letter sequence marked for ending
        line = self._sock.readline()
        return (int(line[:3]), line[4:].strip().decode())

    def quit(self):
        self.cmd("QUIT")
        self._sock.close()

Afficher le code brut

Quel que soit l’IDE que vous utilisez, voici les instructions générales pour télécharger la bibliothèque uMail sur votre carte :

  1. Tout d’abord, assurez-vous que votre carte exécute le micrologiciel MicroPython – vérifiez le Rubrique Prérequis.
  2. Créez un nouveau fichier dans votre IDE avec le nom umail.py et collez-y le code précédent. Enregistrez ce fichier.
  3. Établissez une communication série avec votre carte à l’aide de votre IDE.
  4. Télécharger le umail.py fichier à votre conseil d’administration.
  5. À ce stade, la bibliothèque devrait avoir été téléchargée avec succès sur votre carte. Maintenant, vous pouvez utiliser les fonctionnalités de la bibliothèque dans votre code en important la bibliothèque : importer un e-mail.

Envoi d’emails avec l’ESP32/ESP8266 (MicroPython) – Code

À ce stade, vous devriez avoir téléchargé le umail.py fichier à votre tableau pour pouvoir envoyer des e-mails en utilisant le umail module.

Le script suivant envoie un simple e-mail lorsque la carte ESP32/ESP8266 démarre/réinitialise pour la première fois.

# Complete project details: https://Raspberryme.com/micropython-send-emails-esp32-esp826/
# Micropython lib to send emails: https://github.com/shawwwn/uMail
import umail
import network

# Your network credentials
ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'

# Email details
sender_email="REPLACE_WITH_THE_SENDER_EMAIL"
sender_name="ESP32" #sender name
sender_app_password = 'REPLACE_WITH_THE_SENDER_EMAIL_APP_PASSWORD'
recipient_email="REPLACE_WITH_THE_RECIPIENT_EMAIL"
email_subject="Test Email"

def connect_wifi(ssid, password):
  #Connect to your network
  station = network.WLAN(network.STA_IF)
  station.active(True)
  station.connect(ssid, password)
  while station.isconnected() == False:
    pass
  print('Connection successful')
  print(station.ifconfig())
    
# Connect to your network
connect_wifi(ssid, password)

# Send the email
smtp = umail.SMTP('smtp.gmail.com', 465, ssl=True) # Gmail's SSL port
smtp.login(sender_email, sender_app_password)
smtp.to(recipient_email)
smtp.write("From:" + sender_name + "<"+ sender_email+">\n")
smtp.write("Subject:" + email_subject + "\n")
smtp.write("Hello from ESP32")
smtp.send()
smtp.quit()

Afficher le code brut

Vous devez insérer vos coordonnées sur le code avant de télécharger le code sur le tableau : SSID et mot de passe, e-mail de l’expéditeur, nom de l’expéditeur et mot de passe d’application correspondant, e-mail du destinataire et objet de l’e-mail.

Après avoir inséré toutes vos coordonnées, vous pouvez télécharger le code sur votre tableau. Le fichier avec le code doit être nommé main.pysinon, ça ne marchera pas.

Comment fonctionne le code

Tout d’abord, incluez les bibliothèques requises. Les umail bibliothèque, que nous avons chargée précédemment sur le tableau, afin que nous puissions envoyer des e-mails, et la réseau bibliothèque afin que nous puissions définir l’ESP32/ESP8266 comme une station wi-fi pour pouvoir se connecter à Internet (réseau local).

import umail # Micropython lib to send emails: https://github.com/shawwwn/uMail
import network

Insérez vos identifiants réseau, SSID et mot de passe, sur les variables suivantes afin que votre carte puisse se connecter à internet :

ssid = 'REPLACE_WITH_YOUR_SSID'
password = 'REPLACE_WITH_YOUR_PASSWORD'

Insérez les détails de l’e-mail : e-mail de l’expéditeur, nom de l’expéditeur et mot de passe d’application correspondant. Vous devez vraiment créer un mot de passe d’application – l’utilisation du mot de passe de messagerie standard ne fonctionnera pas, voir cette rubrique.

# Email details
sender_email="REPLACE_WITH_THE_SENDER_EMAIL"
sender_name="ESP32" #sender name
sender_app_password = 'REPLACE_WITH_THE_SENDER_EMAIL_APP_PASSWORD'

Insérez l’e-mail du destinataire sur le Destinataire E-mail variable:

recipient_email="REPLACE_WITH_THE_RECIPIENT_EMAIL"

L’objet de l’e-mail est défini sur Courriel d’essaimais vous pouvez le modifier sur le Sujet du courriel variable.

email_subject="Test Email"

Nous avons créé une fonction appelée connect_wifi() qui accepte comme arguments le SSID et le mot de passe du réseau auquel vous souhaitez vous connecter. Vous devriez appeler cette fonction plus tard pour connecter réellement la carte ESP à Internet.

def connect_wifi(ssid, password):
  #Connect to your network
  station = network.WLAN(network.STA_IF)
  station.active(True)
  station.connect(ssid, password)
  while station.isconnected() == False:
    pass
  print('Connection successful')
  print(station.ifconfig())

Avant d’envoyer l’e-mail, nous devons connecter l’ESP32/ESP8266 à Internet, alors appelez le connect_wifi() fonction (passez en arguments le ssid et le mot de passe).

# Connect to your network
connect_wifi(ssid, password)

Maintenant, nous pouvons enfin commencer à préparer et à envoyer l’e-mail.

Commencez par créer un client SMTP à l’aide des paramètres SMTP de votre fournisseur de messagerie appelé smtp. Ici, nous utilisons un compte Gmail. Modifiez les paramètres si vous utilisez un autre fournisseur de messagerie—définissez le serveur, le port et si SSL est requis ou non.

smtp = umail.SMTP('smtp.gmail.com', 465, ssl=True) # Gmail's SSL port

Ensuite, connectez-vous à votre compte en utilisant le connexion() méthode sur la smtp client : transmettez comme arguments l’e-mail et le mot de passe d’application correspondant.

smtp.login(sender_email, sender_app_password)

Définissez le destinataire à l’aide de la pour() et passez l’email du destinataire en argument :

smtp.to(recipient_email)

Ensuite, utilisez le écrivez() méthode pour écrire l’e-mail. Vous pouvez utiliser cette méthode comme suit pour définir le nom de l’expéditeur.

smtp.write("From:" + sender_name + "<"+ sender_email+">\n")

Et vous pouvez utiliser la ligne suivante pour définir l’objet de l’e-mail.

smtp.write("Subject:" + email_subject + "\n")

Enfin, vous pouvez réellement écrire le contenu de votre e-mail. Ceci est juste un e-mail de test. Nous définissons le message sur « Bonjour de la carte ESP32/ESP8266 ». Les écrivez() méthode envoie l’e-mail au serveur SMTP.

smtp.write("Hello from the ESP32/ESP8266")

Si vous devez envoyer une longue chaîne comme corps de l’e-mail, divisez l’e-mail en petits morceaux et envoyez chaque morceau à l’aide de la écrivez() méthode-voir la documentation de la bibliothèque uMail.

Enfin, utilisez le envoyer() méthode pour que le serveur SMTP envoie l’e-mail au destinataire.

smtp.send()

A la fin, fermez la connexion avec le serveur en utilisant le arrêter() méthode.

smtp.quit()

Manifestation

Après avoir téléchargé le umail modules et le main.py script sur votre carte, exécutez le code ou réinitialisez/redémarrez votre carte. Vous devriez obtenir un message similaire dans le shell indiquant que votre carte s’est connectée avec succès à Internet.

connexion internet micropython réussie

Au bout d’un moment, vous devriez recevoir un nouvel e-mail sur le compte de messagerie du destinataire.

e-mail de test envoyé depuis EPS32/ESP8266 à l'aide de MicroPython (boîte de réception)

Ouvrez l’e-mail pour vérifier son contenu.

e-mail de test envoyé depuis EPS32/ESP8266 à l'aide de MicroPython

Conclusion

Dans ce didacticiel, vous avez appris à envoyer des e-mails avec l’ESP32/ESP8266 à l’aide du micrologiciel MicroPython. L’envoi d’un e-mail à l’aide d’un serveur SMTP est très simple grâce à la Module uMail Micropython.

Nous vous avons montré un exemple d’application simple. Maintenant, l’idée est d’utiliser cette fonctionnalité dans vos propres projets. Cela peut être utile pour envoyer des alertes de notification, des lectures de capteurs et d’autres applications.

Nous espérons que vous trouverez ce tutoriel utile. Si vous souhaitez utiliser une méthode de notification différente, nous avons un tutoriel montrant comment envoyer des messages à WhatsApp en utilisant MicroPython (ESP32 et ESP8266) :

Vous pouvez consulter tous nos projets MicroPython ici.

Si vous souhaitez en savoir plus sur la programmation des cartes ESP32 et ESP8266 avec MicroPython, consultez notre eBook : Programmation MicroPython avec ESP32 et ESP8266.

Merci d’avoir lu

Plongez dans l’histoire de Raspberry Pi avec cette vidéo :

YouTube video