Guia prático para enviar notificações por e-mail a partir do ESP32

Neste tutorial você vai aprender a enviar e-mails com o ESP32 usando um servidor SMTP. Vamos mostrar como enviar uma mensagem simples em HTML ou texto puro, e também como enviar anexos, como imagens e arquivos .txt. A programação será feita na Arduino IDE, usando a biblioteca ReadyMail.

Neste guia, você vai encontrar:

• Envio de e-mail (HTML e texto puro)
• Envio de e-mails com anexos (imagem e arquivo .txt)

O que é um servidor SMTP?

SMTP significa Simple Mail Transfer Protocol (Protocolo Simples de Transferência de Correio), um padrão da internet usado para o envio de e-mails. Para enviar mensagens a partir do ESP32, é necessário conectá-lo a um servidor SMTP.

Biblioteca ReadyMail

Para enviar e-mails com o ESP32, usaremos a biblioteca ReadyMail. Ela permite que o ESP32 envie e receba e-mails, com ou sem anexos, via servidores SMTP e IMAP.

Neste tutorial, vamos usar apenas o SMTP para enviar e-mails com e sem anexos. Como exemplo, enviaremos uma imagem (.png) e um arquivo de texto (.txt). Os arquivos enviados podem estar salvos no sistema de arquivos do ESP32 (SPIFFS ou LittleFS) ou em um cartão microSD (este último não é abordado aqui).

Instalando a biblioteca ReadyMail

Antes de continuar, você precisa instalar a biblioteca ReadyMail.

Vá em Sketch > Include Library > Manage Libraries e pesquise por ReadyMail. Instale a biblioteca ReadyMail by Mobizt.

E-mail remetente (crie uma conta nova)

Recomendamos criar uma nova conta de e-mail exclusivamente para enviar mensagens ao seu e-mail pessoal principal. Não use seu e-mail pessoal principal para enviar mensagens pelo ESP32. Se algo der errado no seu código, ou se por engano ele fizer muitas requisições, sua conta pode ser bloqueada ou suspensa temporariamente.

Usaremos uma conta Gmail recém-criada como remetente, mas você pode usar qualquer outro provedor de e-mail. O destinatário pode ser tranquilamente seu e-mail pessoal.

Criar uma conta de e-mail remetente

Crie uma nova conta de e-mail para enviar mensagens com o ESP32. Se quiser usar uma conta Gmail, acesse este link para criar uma nova.

Criar uma senha de app

Você precisa criar uma senha de aplicativo para que o ESP32 possa enviar e-mails usando sua conta Gmail. Uma senha de app é um código de 16 dígitos que concede a um dispositivo ou aplicativo menos seguro permissão para acessar sua conta Google.

Uma senha de app só pode ser usada em contas que tenham a verificação em duas etapas ativada.

1. Abra sua Conta do Google.
2. No painel de pesquisa, selecione Segurança.
3. Em "Como fazer login no Google", selecione Verificação em duas etapas > Começar.
4. Siga as instruções na tela.

Depois de ativar a verificação em duas etapas, você pode criar uma senha de app:

1. Abra sua Conta do Google.
2. No painel de pesquisa, procure por Senhas de app.
3. Abra o menu Senhas de app.

Dê um nome para a senha de app, por exemplo ESP. Depois, clique em Criar.

Vai abrir uma janela com uma senha que você usará no ESP32 para enviar e-mails. Salve essa senha (mesmo que a tela diga que você não precisará memorizá-la), pois vai precisar dela mais adiante.

Agora você já tem uma senha de app pronta para usar no código do ESP32.

Se você estiver usando outro provedor de e-mail, verifique como criar uma senha de app específica dele. Normalmente é fácil encontrar as instruções pesquisando "seu_provedor_de_email + criar senha de app".

Configurações do servidor SMTP do Gmail

Para enviar e-mails com o ESP32, você também precisa saber as configurações do servidor SMTP do seu provedor de e-mail.

Se estiver usando uma conta Gmail, estas são as configurações:

Configurações do servidor SMTP do Outlook

Configurações do servidor SMTP do Live/Hotmail

Se estiver usando outro provedor de e-mail, será necessário pesquisar as configurações específicas do servidor SMTP dele. Agora você já tem tudo pronto para começar a enviar e-mails com o seu ESP32.

Enviar um e-mail em HTML ou texto puro com o ESP32 (Arduino IDE)

O código a seguir envia um e-mail via servidor SMTP em HTML ou texto puro. Para fins de demonstração, o ESP32 envia um e-mail assim que é ligado. Depois, você pode adaptar o código para integrá-lo aos seus próprios projetos.

Antes de enviar o código para a placa, insira suas credenciais de rede, além de configurar o e-mail remetente, os dados do servidor SMTP, o destinatário e a mensagem.

/*
  Baseado no exemplo fornecido pela biblioteca ReadyMail: https://github.com/mobizt/ReadyMail/
*/
#include 
#include 
#include 

#define ENABLE_SMTP
#define ENABLE_DEBUG
#include 

// SUBSTITUA PELAS SUAS CREDENCIAIS DE REDE
const char* ssid = "SUBSTITUA_PELO_SEU_SSID";
const char* password = "SUBSTITUA_PELA_SUA_SENHA";

// Configurações do SMTP do remetente (GMAIL)
// Altere se estiver usando outro provedor
#define SMTP_HOST "smtp.gmail.com"
#define SMTP_PORT 465

// E-mail do remetente, senha de app e nome
#define AUTHOR_EMAIL "seu_email@gmail.com"
#define AUTHOR_APP_PASS "SENHA_DE_APP_DO_EMAIL"
#define AUTHOR_NAME "ESP32"

// E-mail do destinatário
#define RECIPIENT_EMAIL "email_destinatario@gmail.com"
#define RECIPIENT_NAME "NOME_DESTINATARIO"

WiFiClientSecure ssl_client;
SMTPClient smtp(ssl_client);

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) delay(500);

  ssl_client.setInsecure();

  auto statusCallback = [](SMTPStatus status) {
    Serial.println(status.text);
  };

  smtp.connect(SMTP_HOST, SMTP_PORT, statusCallback);

  if (smtp.isConnected()) {
    smtp.authenticate(AUTHOR_EMAIL, AUTHOR_APP_PASS, readymail_auth_password);

    SMTPMessage msg;

    msg.headers.add(rfc822_from, String(AUTHOR_NAME) + " <" + AUTHOR_EMAIL + ">");
    msg.headers.add(rfc822_to, String(RECIPIENT_NAME) + " <" + RECIPIENT_EMAIL + ">");
    msg.headers.add(rfc822_subject, "Ola do ESP32");
    //msg.text.body("Esta e uma mensagem em texto puro.");
    msg.html.body("
Ola!
");

    // Configuracao do horario via NTP
    const int gmtOffset_sec = 0; // deslocamento em segundos
    const int daylightOffset_sec = 0; // horario de verao

    configTime(gmtOffset_sec, daylightOffset_sec, "pool.ntp.org");
    while (time(nullptr) < 100000) delay(100);
    msg.timestamp = time(nullptr);

    smtp.send(msg);
  }
}

void loop() {

}

Você também pode baixar o código bruto original diretamente do repositório da Random Nerd Tutorials.

Como o código funciona

Esse código é adaptado de um exemplo fornecido pela própria biblioteca. Vamos analisar os pontos mais relevantes, que você precisa ou pode querer alterar.

Primeiro, incluímos as bibliotecas necessárias:

#include 
#include 
#include 

#define ENABLE_SMTP
#define ENABLE_DEBUG
#include 

Da biblioteca ReadyMail, usaremos o SMTP para enviar os e-mails, e ativaremos as funções de debug para acompanhar o status do envio.

Em seguida, insira suas credenciais de rede:

const char* ssid = "SUBSTITUA_PELO_SEU_SSID";
const char* password = "SUBSTITUA_PELA_SUA_SENHA";

Insira as configurações do servidor SMTP. Se estiver usando o Gmail, estes são os parâmetros:

#define SMTP_HOST "smtp.gmail.com"
#define SMTP_PORT 465

Insira as credenciais de login do e-mail remetente (endereço completo e a senha de app criada anteriormente — não a senha normal da conta, e sim a SENHA DE APP) e o nome do remetente:

#define AUTHOR_EMAIL "seu_email@gmail.com"
#define AUTHOR_APP_PASS "SENHA_DE_APP_DO_EMAIL"
#define AUTHOR_NAME "ESP32"

Insira o e-mail e o nome do destinatário:

#define RECIPIENT_EMAIL "email_destinatario@gmail.com"
#define RECIPIENT_NAME "NOME_DESTINATARIO"

Crie um cliente WiFi para se comunicar com o servidor SMTP:

WiFiClientSecure ssl_client;
SMTPClient smtp(ssl_client);

No setup(), inicialize o Monitor Serial e conecte o ESP32 ao Wi-Fi:

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) delay(500);

Crie uma função chamada statusCallback, que recebe o status SMTP e o imprime no Monitor Serial. Basicamente, isso mostra o andamento das diversas etapas do envio.

auto statusCallback = [](SMTPStatus status) {
  Serial.println(status.text);
};

Conecte-se ao servidor SMTP e faça a autenticação:

smtp.connect(SMTP_HOST, SMTP_PORT, statusCallback);

if (smtp.isConnected()) {
  smtp.authenticate(AUTHOR_EMAIL, AUTHOR_APP_PASS, readymail_auth_password);

Crie um objeto de mensagem SMTP, chamado msg:

SMTPMessage msg;

Adicione os cabeçalhos do e-mail: nome e endereço do remetente, nome e endereço do destinatário, e o assunto da mensagem:

msg.headers.add(rfc822_from, String(AUTHOR_NAME) + " <" + AUTHOR_EMAIL + ">");
msg.headers.add(rfc822_to, String(RECIPIENT_NAME) + " <" + RECIPIENT_EMAIL + ">");
msg.headers.add(rfc822_subject, "Ola do ReadyMail");

Em seguida, defina o corpo do e-mail. Você pode enviar texto puro com msg.text.body(), ou enviar HTML com msg.html.body(). Use apenas um dos dois métodos por vez.

msg.text.body("Esta e uma mensagem em texto puro.");
//msg.html.body("
Ola!
");

Configure o timestamp do e-mail usando um servidor NTP. Ajuste o deslocamento de fuso horário e de horário de verão conforme necessário (gmtOffset_sec e daylightOffset_sec):

const int gmtOffset_sec = 0; // deslocamento em segundos
const int daylightOffset_sec = 0; // horario de verao

configTime(gmtOffset_sec, daylightOffset_sec, "pool.ntp.org");
while (time(nullptr) < 100000) delay(100);
msg.timestamp = time(nullptr);

Por fim, envie o e-mail. É simples assim:

smtp.send(msg);

Para fins de demonstração e teste, o envio acontece uma única vez, dentro do setup(), deixando o loop() vazio:

void loop() {}

Demonstração

Envie o código para o seu ESP32. Depois de enviar, abra o Monitor Serial com baud rate de 115200. Pressione o botão de Reset da placa.

Se tudo correr bem, você verá uma mensagem parecida com esta no Monitor Serial:

Verifique a caixa de entrada do e-mail configurado como destinatário. Você deve ter recebido uma mensagem enviada pelo seu ESP32.

Se você optou por enviar a mensagem em HTML, é assim que ela deve aparecer:

E se você habilitou o envio em texto puro, esta é a aparência esperada da mensagem:

Enviar e-mails com anexos usando o ESP32 (Arduino IDE)

Nesta seção, vamos mostrar como enviar anexos em e-mails a partir do ESP32 — arquivos .txt ou imagens. Isso pode ser útil, por exemplo, para enviar um arquivo .txt com leituras de sensores das últimas horas, ou para enviar uma foto capturada por um ESP32-CAM.

Para este tutorial, os arquivos a serem enviados devem estar salvos no sistema de arquivos do ESP32 (LittleFS).

Enviar arquivos para o LittleFS

Para enviar arquivos por e-mail, eles precisam estar salvos no sistema de arquivos do ESP32 ou em um cartão microSD. Vamos enviar uma imagem e um arquivo .txt para o sistema de arquivos LittleFS do ESP32, usando o plugin ESP32 Filesystem Uploader para a Arduino IDE.

Crie um novo sketch no Arduino e salve-o. Vá em Sketch > Show Sketch Folder. Dentro da pasta do sketch, crie uma pasta chamada data. Mova um arquivo .jpg e um arquivo .txt para essa pasta.

Nota: com o código padrão, seus arquivos precisam se chamar image.png e text_file.txt. Você também pode modificar o código para importar arquivos com outros nomes.

A estrutura de pastas deve ficar assim:

Depois de mover os arquivos para a pasta data, você precisa enviá-los para a placa. Na Arduino IDE, pressione Ctrl+Shift+P (Windows) ou ⌘+Shift+P (macOS) para abrir a paleta de comandos. Procure pelo comando Upload LittleFS to Pico/ESP8266/ESP32 e clique nele.

Você deve ver uma mensagem de sucesso na janela de debug. Se os arquivos foram enviados corretamente, siga para a próxima seção.

Nota: se você começar a ver muitos pontos sendo impressos na janela de debug (….____…..____), segure o botão BOOT da placa para que o envio dos arquivos seja concluído.

Código

O código a seguir envia um e-mail com um arquivo .txt e uma imagem anexados. Antes de enviar o código para a placa, configure o e-mail remetente e o destinatário.

#include 
#include 
#include 
#include 
#include 

#define ENABLE_SMTP  // Habilita a classe SMTP
#define ENABLE_DEBUG // Habilita o debug
#define ENABLE_FS    // Habilita integracao com sistema de arquivos
#define MY_FS LittleFS

#include 

const char* ssid = "SUBSTITUA_PELO_SEU_SSID";
const char* password = "SUBSTITUA_PELA_SUA_SENHA";

#define SMTP_HOST "smtp.gmail.com"
#define SMTP_PORT 465

#define AUTHOR_EMAIL "seu_email@gmail.com"
#define AUTHOR_APP_PASS "SENHA_DE_APP_DO_EMAIL"
#define AUTHOR_NAME "ESP32"

#define RECIPIENT_EMAIL "email_destinatario@gmail.com"
#define RECIPIENT_NAME "NOME_DESTINATARIO"

WiFiClientSecure ssl_client;
SMTPClient smtp(ssl_client);

File myFile;

void fileCb(File &file, const char *filename, readymail_file_operating_mode mode) {
    switch (mode) {
    case readymail_file_mode_open_read:
        myFile = MY_FS.open(filename, FILE_OPEN_MODE_READ);
        break;
    case readymail_file_mode_open_write:
        myFile = MY_FS.open(filename, FILE_OPEN_MODE_WRITE);
        break;
    case readymail_file_mode_open_append:
        myFile = MY_FS.open(filename, FILE_OPEN_MODE_APPEND);
        break;
    case readymail_file_mode_remove:
        MY_FS.remove(filename);
        break;
    default:
        break;
    }
    file = myFile;
}

void initLittleFS() {
    if (!MY_FS.begin(true)){
        Serial.println("Falha ao montar o LittleFS");
        return;
    }
}

void smtpCb(SMTPStatus status){
    if (status.progress.available)
        ReadyMail.printf("ReadyMail[smtp][%d] Enviando arquivo %s, %d %% concluido\n", status.state,
                         status.progress.filename.c_str(), status.progress.value);
    else
        ReadyMail.printf("ReadyMail[smtp][%d]%s\n", status.state, status.text.c_str());
}

void addFileAttachment(SMTPMessage &msg, const String &filename, const String &mime, const String &name, FileCallback cb, const String &filepath, const String &encoding = "", const String &cid = "") {
    Attachment attachment;
    attachment.filename = filename;
    attachment.mime = mime;
    attachment.name = name;
    attachment.content_id = cid;
    attachment.attach_file.callback = cb;
    attachment.attach_file.path = filepath;
    attachment.content_encoding = encoding;
    msg.attachments.add(attachment, cid.length() > 0 ? attach_type_inline : attach_type_attachment);
}

void setup() {
    Serial.begin(115200);
    Serial.println();

    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) delay(500);

    initLittleFS();

    ssl_client.setInsecure();

    smtp.connect(SMTP_HOST, SMTP_PORT, smtpCb);
    if (!smtp.isConnected())
        return;

    smtp.authenticate(AUTHOR_EMAIL, AUTHOR_APP_PASS, readymail_auth_password);
    if (!smtp.isAuthenticated())
        return;

    SMTPMessage msg;
    msg.headers.add(rfc822_from, String(AUTHOR_NAME) + " <" + AUTHOR_EMAIL + ">");
    msg.headers.add(rfc822_to, String(RECIPIENT_NAME) + " <" + RECIPIENT_EMAIL + ">");
    msg.headers.add(rfc822_subject, "Anexos do ESP32");

    String bodyText = "Ola! Veja os anexos";
    msg.text.body(bodyText);
    msg.html.body("
" + bodyText + "
");

    const int gmtOffset_sec = 0;
    const int daylightOffset_sec = 0;

    configTime(gmtOffset_sec, daylightOffset_sec, "pool.ntp.org");
    while (time(nullptr) < 100000) delay(100);
    msg.timestamp = time(nullptr);

    addFileAttachment(msg, "image.png", "image/png", "image.png", fileCb, "/image.png");
    addFileAttachment(msg, "text_file.txt", "text/plain", "text_file.txt", fileCb, "/text_file.txt");
    Serial.print("Enviando email");
    smtp.send(msg);
}

void loop(){

}

O pacote completo do projeto também está disponível para download no repositório original.

Como o código funciona

Esse código é bem parecido com o anterior, então vamos focar apenas nos trechos específicos necessários para enviar anexos salvos no sistema de arquivos do ESP32.

Primeiro, precisamos incluir as bibliotecas FS e LittleFS, para lidar com arquivos no ESP32:

#include 
#include 

Habilitamos a integração com o sistema de arquivos e definimos qual tipo será usado (pode ser SPIFFS, LittleFS ou SD):

#define ENABLE_FS // Habilita integracao com sistema de arquivos
#define MY_FS LittleFS

É necessário criar um objeto File e uma função de callback que será chamada ao criar o anexo. Estamos usando a função fileCb(), adaptada de um dos exemplos da própria biblioteca.

Também é preciso inicializar o sistema de arquivos, o que fazemos na função initLittleFS().

É necessário criar uma função de callback que será executada durante o envio do e-mail — usamos a função smtpCb(), que reporta o progresso do processo.

A função addFileAttachment() reúne todos os passos necessários para criar e adicionar um anexo à mensagem. Confira o significado de cada parâmetro:

• SMTPMessage &msg: o objeto da mensagem de e-mail ao qual o anexo será adicionado.
• const String &filename: o nome do arquivo que o destinatário vai ver.
• const String &mime: o tipo MIME do arquivo (por exemplo: image/png, text/plain, etc).
• const String &name: o nome de exibição do anexo.
• FileCallback cb: a função de callback chamada ao adicionar o anexo.
• const String &filepath: o caminho do arquivo no sistema de arquivos.
• const String &encoding = "": deixe em branco, a menos que o conteúdo já esteja codificado.
• const String &cid = "": ID de conteúdo usado para anexos inline, embutidos no corpo de mensagens HTML.

No setup(), inicializamos o Monitor Serial, conectamos ao Wi-Fi e inicializamos o sistema de arquivos LittleFS. Em seguida, chamamos a função addFileAttachment() com os parâmetros corretos, para anexar uma imagem chamada image.png (salva no LittleFS) e também um arquivo de texto, text_file.txt. Por fim, enviamos a mensagem com o método send(), assim como no exemplo anterior.

Demonstração

Depois de enviar o código, abra o Monitor Serial com baud rate de 115200 e pressione o botão EN/RESET da placa. Se tudo correr bem, você verá uma mensagem parecida com esta:

Verifique o e-mail configurado como destinatário. Você deve ter recebido uma nova mensagem com dois anexos.

Conclusão

Neste tutorial, você aprendeu a enviar e-mails com o ESP32 usando um servidor SMTP. Para que esse método funcione, o ESP32 precisa ter acesso à internet.

Se você não quiser usar um servidor SMTP, também é possível usar um script PHP para enviar notificações por e-mail a partir do ESP32 ou ESP8266.

Você aprendeu a enviar um e-mail simples com texto e também com anexos. Ao usar anexos, os arquivos precisam estar salvos no sistema de arquivos do ESP32 (LittleFS) ou em um cartão microSD.

Os exemplos mostrados enviam um único e-mail quando o ESP32 é ligado. A ideia é que você adapte o código para os seus próprios projetos — por exemplo, enviar um arquivo .txt com leituras de sensores, enviar uma foto capturada por um ESP32-CAM, ou usar deep sleep para acordar a placa periodicamente e enviar dados por e-mail.

Esperamos que este tutorial tenha sido útil para os seus projetos com ESP32.