ESP32 MicroPython envia e-mails com cliente SMTP

Publicado em por
Tempo de leitura: 10 minutes

Neste tutorial, você aprenderá a enviar e-mails com um cliente SMTP e MicroPython usando ESP32. Aprenderemos a enviar e-mails para servidores SMTP como Gmail, Hotmail e Outlook. O umail é um cliente SMTP leve e escalável para enviar e-mails no MicroPython. Para demonstração, enviaremos uma mensagem de texto simples por e-mail, mas também podemos usá-la para enviar alertas de notificação, alertas de porta, detecção de movimento e leituras de sensores como BME680, DS18B20, SHT31, DHT22, etc.

 

Pré-requisitos

Antes de começar esta lição, certifique-se de estar familiarizado e ter a versão mais recente do firmware MicroPython instalado em sua placa ESP32 e ter um Ambiente de Desenvolvimento Integrado (IDE) em execução no qual faremos a programação, como uPyCraft IDE ou Thonny IDE.

 

Servidores SMTP Introdução

SMTP (Simple Mail Transfer Protocol) é um protocolo usado para enviar e receber e-mails. Um servidor SMTP é um servidor que implementa o protocolo SMTP e é responsável por enviar e entregar mensagens de e-mail.

Aqui estão alguns servidores SMTP populares:

  • Gmail: smtp.gmail.com (porta 587)
  • Outlook: smtp-mail.outlook.com (porta 587)
  • Yahoo Mail: smtp.mail.yahoo.com (porta 465)
  • Hotmail: smtp.live.com (porta 587)

Observe que diferentes provedores de e-mail podem ter políticas e requisitos diferentes para usar seus servidores SMTP. Você deve consultar a documentação do provedor para obter mais informações sobre como usar seus servidores SMTP.

 

Configurações do servidor SMTP do Gmail

Você pode visualizar as configurações do servidor do Gmail conforme mostrado abaixo. Saber disso é importante porque temos que incluí-los em nosso código de programa para configurar nossa conta corretamente.

  • Servidor: smtp.gmail.com
  • Nome de usuário do remetente: o endereço de e-mail completo da conta do remetente.
  • Senha do usuário do remetente: a senha da conta do remetente
  • Porta do servidor (TLS): 587
  • Porta do servidor (SSL): 465
  • SMTP TLS/SSL necessário: sim

Configurações do servidor SMTP do Outlook

Estas são as configurações comuns do servidor SMTP para Outlook:

  • Servidor: smtp-mail.outlook.com
  • Porta: 587
  • Método de criptografia: TLS
  • Nome de usuário: Seu endereço de e-mail completo do Outlook
  • Senha: Sua senha de e-mail do Outlook

Configurações do servidor SMTP do Hotmail

Estas são as configurações comuns do servidor SMTP para Outlook.com:

  • Servidor: smtp-mail.outlook.com
  • Porta: 587
  • Método de criptografia: TLS
  • Nome de usuário: Seu endereço de e-mail completo do Outlook.com
  • Senha: Sua senha de e-mail do Outlook.com

Configurando a conta do Gmail

Para enviar e-mails usando o ESP32, precisaríamos de duas contas de e-mail. Um para o remetente e outro para o destinatário. Você pode usar sua conta de e-mail como a conta do remetente, mas é recomendável criar uma nova caso algo dê errado no código do programa. Para este artigo, usaremos o Gmail como provedor de e-mail principal. Você pode usar qualquer outro provedor de acordo com sua preferência.

Criando uma conta do Gmail

Para este tutorial, criamos uma nova conta do Gmail e também recomendamos que você crie uma nova conta do Gmail. Porque se algo de errado acontecer com seu código ESP32 MicroPython e você acidentalmente fizer muitas solicitações de e-mail de sua conta pessoal, o Google pode banir sua conta ou bloqueá-la temporariamente. O endereço de e-mail do destinatário pode ser seu endereço de e-mail pessoal.

Para criar uma conta do Google:

  • Vá para a página de inscrição do Google: https://www.google.com/gmail/about/ nas informações necessárias, como nome e sobrenome, endereço de e-mail desejado, senha, número de telefone e data de nascimento.
  • Clique em “Avançar” para prosseguir com o processo de verificação.
  • Leia e aceite os termos de serviço e política de privacidade.
  • Clique em “Criar conta”.

Agora digite todas as informações relevantes e clique em ‘Avançar’. Você pode dar detalhes de acordo com sua preferência.

Prossiga com todas as etapas de acordo para criar sua conta com sucesso.

Criar uma senha de aplicativo

Para enviar um e-mail com o ESP32, primeiro você precisa criar uma senha de App usando sua conta do Gmail. Uma senha de aplicativo no Gmail é uma senha exclusiva gerada para um aplicativo ou dispositivo que não oferece suporte à verificação em duas etapas. Quando a verificação em duas etapas está ativada para uma conta do Gmail, os usuários precisam inserir um código de verificação além da senha ao fazer login. No entanto, alguns aplicativos ou dispositivos podem não ser capazes de solicitar o código de verificação. Nesses casos, os usuários podem gerar uma senha de aplicativo para usar em vez da senha normal para acessar o Gmail no aplicativo ou dispositivo. A senha do aplicativo é válida apenas para um aplicativo ou dispositivo específico e pode ser revogada a qualquer momento nas configurações de segurança da Conta do Google.

 

Primeiro, habilite a verificação em duas etapas em sua conta seguindo estas etapas:

  • Faça login na sua Conta do Google.
  • Vá para a seção “Segurança” nas configurações da sua Conta do Google.
  • Role para baixo até “Fazer login no Google”.
  • Em “Verificação em duas etapas”, clique em “Começar”.
  • Siga as instruções para configurar a autenticação em duas etapas, que pode incluir adicionar um número de telefone para receber códigos de verificação por mensagem de texto ou chamada de voz.
  • Depois de configurar a autenticação em duas etapas, você será solicitado a inserir um código de verificação sempre que fizer login na sua Conta do Google em um novo dispositivo ou navegar

Para obter uma senha de aplicativo:

Faça login na sua Conta do Google e vá para a seção “Segurança” nas configurações da sua Conta do Google.

Role para baixo até “Fazer login no Google”. e clique em “Senhas de aplicativos”.

Siga as instruções para gerar uma senha exclusiva para o aplicativo que deseja usar com sua Conta do Google. No campo de seleção do aplicativo, escolha e-mail e dispositivo como outro. Dê qualquer nome a este dispositivo. Depois disso, clique em gerar.

Ele irá gerar uma senha de aplicativo para este dispositivo específico. Salve isso para uso posterior. Porque vamos usá-lo dentro do nosso código em vez da senha do Gmail.

 

Carregue umail MicroPython SMTP Client Library para Raspberry Pi Pico W

Conforme mencionado anteriormente, estamos usando a biblioteca cliente SMTP umamail para enviar e-mails. Esta biblioteca não está disponível no gerenciador de pacotes Thonny IDE MicroPython. Portanto, precisamos carregá-lo para o ESP32 manualmente através do Thonny IDE.

UMAIL LIBRARY

Crie um novo arquivo no Thonny IDE. Copie o código a seguir nesse arquivo e salve-o com o nome de umail.py.

# uMail (MicroMail) for MicroPython
# Copyright (c) 2018 Shawwwn <shawwwn1@gmai.com> 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()

 

  • Conecte o ESP32 ao seu computador usando um cabo USB.
  • Abra a IDE Thonny e vá em “Ferramentas” > “Opções” > “Intérpretes” > “ESP32”.
  • Clique no botão “Autodetectar” para detectar a placa Pico conectada ao seu computador.
  • Assim que a placa for detectada, você pode carregar o arquivo umamail.py para o ESP32 no Thonny IDE.
  • Salve seu código.
  • Para carregar o código no ESP32, vá em “Executar” > “Executar script atual” ou pressione a tecla “F5”.
  • O código será carregado no Pico e executado automaticamente.

Depois de executar todas as etapas acima com êxito, você poderá usar o código umail.py dentro do sketch do MicroPython com import umail.

 

Código MicroPython para enviar e-mail

Este MicroPython envia um e-mail usando o servidor Gmail e a biblioteca cliente SMTP.

import umail
import network

# Suas credenciais de rede
ssid = 'substitua_pelo_seu_ssid' # Substitua pelo nome da sua rede
password = 'substitua_por_sua_senha' # Substitua pela sua senha de rede

# Detalhes do e-mail
sender_email = 'write_senders_email' # Substitua pelo endereço de e-mail do remetente
sender_name = 'Mail Client' # Substitua pelo nome do remetente
sender_app_password = 'write_senders_app_password' # Substitua pela senha do aplicativo da conta de e-mail do remetente
recipient_email ='write_receivers_email' # Substitua pelo endereço de e-mail do destinatário
email_subject ='Test Email' # Assunto do e-maill

def connect_wifi(ssid, password):
  # Conecte-se à sua rede usando as credenciais fornecidas
  station = network.WLAN(network.STA_IF)
  station.active(True)
  station.connect(ssid, password)
  # Aguarde a conexão ser estabelecida
  while station.isconnected() == False:
    pass
  print('Conexão bem-sucedida') # Imprimir uma mensagem se a conexão for bem-sucedida
  print(station.ifconfig()) # Imprimir a configuração de rede
    
# Conecte-se à sua rede
connect_wifi(ssid, password)

# Envie o e-mail
# Conecte-se à porta SSL do Gmail
smtp = umail.SMTP('smtp.gmail.com', 465, ssl=True)
# Faça login na conta de e-mail usando a senha do aplicativo
smtp.login(sender_email, sender_app_password)
# Especifique o endereço de e-mail do destinatário
smtp.to(recipient_email)
# Escreva o cabeçalho do e-mail
smtp.write("From:" + sender_name + "<"+ sender_email+">\n")
smtp.write("Subject:" + email_subject + "\n")
# Escreva o corpo do e-mail
smtp.write("Test Email from ESP32")
# Envie o e-mail
smtp.send()
# Sair da sessão de e-mail
smtp.quit()

Antes de carregar o script MicroPython acima para o ESP32, substitua ssid, password, sender_email, sender_app_password e destinatário e-mail com seus próprios detalhes.

 

Como funciona o script MicroPython?

Primeiro importa as bibliotecas umamail e de rede. A biblioteca umamail é uma biblioteca cliente SMTP que fornece métodos para enviar e-mails por meio de servidores SMTP e a biblioteca de rede fornece métodos para conectar o ESP32 à sua rede.

import umail
import network

Define as credenciais de rede e os detalhes do e-mail, como endereço de e-mail do remetente, nome e senha do aplicativo, endereço de e-mail do destinatário e assunto do e-mail.

# Suas credenciais de rede 

ssid = 'substitua_pelo_seu_ssid' # Substitua pelo nome da sua rede 
password = 'substitua_por_sua_senha' # Substitua pela sua senha de rede 

# Detalhes do e-mail 

sender_email = 'write_senders_email' # Substitua pelo endereço de e-mail do remetente 
sender_name = 'Mail Client' # Substitua pelo nome do remetente 
sender_app_password = 'write_senders_app_password' # Substitua pela senha do aplicativo da conta de e-mail do remetente 
recipient_email ='write_receivers_email' # Substitua pelo endereço de e-mail do destinatário 
email_subject ='Test Email' # Assunto do e-maill

A seguir, vamos conectar a placa ESP32 à rede Wi-Fi. O network.WLAN() é usado para criar um objeto de interface de rede WLAN.

As interfaces suportadas são:

  • network.STA_IF (modo de estação)
  • network.AP_IF (modo de ponto de acesso flexível)

Depois disso, ative a estação passando o argumento “True” para o método sta_if.active(). O método connect() é usado para conectar-se à rede sem fio especificada usando o nome Wi-Fi (SSID) e a senha especificados.

No modo de estação, o método isconnected() retorna “True” se o ESP32 se conectar com sucesso a uma rede Wi-Fi e um dispositivo também tiver atribuído um endereço IP válido. Caso contrário, retorna “Falso”. Esta instrução verifica se o dispositivo ESP32 se conecta ao Wi-Fi ou não. O código não passa para a próxima etapa até que a placa não esteja conectada à rede Wi-Fi.

Depois que uma conexão Wi-Fi é estabelecida na placa ESP32, um endereço IP é atribuído. O método ifconfig() fornece um endereço IP atribuído ao ESP32. Nesta instrução, imprimimos o endereço IP usando o método ifconfig() no objeto estação que criamos anteriormente.

def connect_wifi(ssid, password):
  # Conecte-se à sua rede usando as credenciais fornecidas
  station = network.WLAN(network.STA_IF)
  station.active(True)
  station.connect(ssid, password)
  # Aguarde a conexão ser estabelecida
  while station.isconnected() == False:
    pass
  print('Connection successful') # Imprimir uma mensagem se a conexão for bem-sucedida
  print(station.ifconfig()) # Imprimir a configuração de rede

 

Chame a função “connect_wifi” para se conectar à rede.

# Conecte-se à sua rede
connect_wifi(ssid, password)

 

Envie um e-mail com o servidor SMTP do Gmail

Conecte-se ao servidor SMTP do Gmail por meio da porta SSL. Use a classe “SMTP” da biblioteca “umail” para criar um objeto para se conectar ao servidor SMTP seguro do Gmail, que é executado na porta 465. Se você estiver usando outro servidor SMTP, como Outlook ou Hotmail, use o endereço do servidor e o número da porta de acordo.

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

 

Faça login na conta de e-mail usando smtp.login(). Esta função faz login na conta do Gmail usando o endereço de e-mail e a senha do aplicativo fornecidos.

smtp.login(sender_email, sender_app_password)

A função smtp.to() especifica o endereço de e-mail do destinatário.

smtp.to(recipient_email)

Escreve o cabeçalho do e-mail que inclui o campo “De” com o nome e o endereço de e-mail do remetente. e também escreve o campo “Assunto” do cabeçalho do e-mail com o assunto especificado.

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

No final, escreve o corpo do e-mail. Este é um e-mail de teste com ESP32. Portanto, estamos enviando “E-mail de teste do ESP32” no corpo do e-mail.

smtp.write("Test Email from ESP32")

Assim que o método send() for executado, ele enviará o e-mail para o servidor.

smtp.send()

Por fim, feche a conexão do cliente SMTP com o servidor Gmail.

smtp.quit()

 

Demonstração

Após o upload dos arquivos umail.py e main.py para o ESP32, clique no botão executar na IDE Thonny.

Assim que você clicar no botão executar e se tudo correr bem, você verá uma mensagem de sucesso no console do Thonny ID conforme imagem abaixo:

Após alguns segundos, você receberá um e-mail em sua conta de destinatário:

 

Resumindo:

Neste tutorial, aprendemos a enviar e-mails com um cliente SMTP e MicroPython usando ESP32. Aprendemos a enviar e-mails para servidores SMTP como Gmail, Hotmail e Outlook

 
Twittar
Compartilhar
Compartilhar
0 Compart.