Integração do ESP32 com Serviços em Nuvem através do MQTT

Integrar o ESP32 com serviços em nuvem é uma maneira poderosa de expandir as capacidades dos seus projetos, permitindo monitoramento e controle remotos, armazenamento de dados e muito mais. Neste artigo, vamos abordar como conectar o ESP32 a serviços em nuvem utilizando o protocolo MQTT, um dos pilares da Internet das Coisas (IoT).

Introdução🔗

A Internet das Coisas está transformando a forma como interagimos com dispositivos e sistemas, conectando tudo à internet para coletar dados e automatizar tarefas. O ESP32, com sua capacidade de se conectar a redes Wi-Fi e grande poder de processamento, é uma escolha popular para projetos de IoT. Ao integrá-lo com serviços em nuvem, podemos ampliar ainda mais suas funcionalidades, permitindo que dados sejam acessados e controlados de qualquer lugar do mundo.

O que é o MQTT?🔗

MQTT (Message Queuing Telemetry Transport) é um protocolo de comunicação leve, projetado para dispositivos com recursos limitados e redes de baixa largura de banda. Ele utiliza o modelo publicador/assinante (publish/subscribe), onde dispositivos podem publicar mensagens em tópicos específicos e assinar tópicos para receber mensagens.

Como Funciona o MQTT?

  • Broker: Servidor que gerencia a distribuição de mensagens entre publicadores e assinantes.
  • Publicador: Dispositivo ou aplicativo que envia mensagens para um tópico específico.
  • Assinante: Dispositivo ou aplicativo que recebe mensagens de um tópico ao qual está inscrito.
  • Tópico: Caminho hierárquico utilizado para categorizar mensagens.

Essa arquitetura desacoplada permite uma comunicação eficiente e escalável entre inúmeros dispositivos.

Por que Integrar o ESP32 com Serviços em Nuvem?🔗

Integrar o ESP32 com serviços em nuvem traz diversos benefícios:

  • Acesso Remoto: Monitore e controle dispositivos de qualquer lugar.
  • Armazenamento de Dados: Guarde informações em longo prazo para análise.
  • Escalabilidade: Gerencie múltiplos dispositivos de forma centralizada.
  • Integração com Outros Serviços: Conecte seus dados a plataformas de análise e automação.

Ao utilizar o MQTT, essa integração torna-se rápida e eficiente, devido à sua leveza e simplicidade.

Escolhendo um Serviço em Nuvem🔗

Existem diversos serviços em nuvem que suportam o MQTT. Alguns exemplos são:

  • CloudMQTT: Serviço de broker MQTT na nuvem, ideal para testes e pequenos projetos.
  • AWS IoT Core: Oferece integração com os serviços da Amazon Web Services.
  • Google Cloud IoT Core: Conecta dispositivos aos serviços do Google Cloud.
  • Azure IoT Hub: Plataforma IoT da Microsoft para gestão de dispositivos.

Para este artigo, utilizaremos o CloudMQTT devido à sua simplicidade e oferta de planos gratuitos.

Configurando o Ambiente🔗

Criando uma Conta no CloudMQTT

1. Acesse o site do CloudMQTT e crie uma conta.

2. Crie uma nova instância:

  • Selecione o plano Cute Cat (gratuito).
  • Dê um nome à sua instância.

3. Anote as Credenciais:

  • Hostname (nome do servidor).
  • Porta.
  • Usuário.
  • Senha.

Essas informações serão utilizadas para configurar o ESP32.

Configurando o Arduino IDE para o ESP32

Certifique-se de ter o Arduino IDE instalado e configurado para programar o ESP32.

  • Instale o Suporte ao ESP32:
    • Adicione a URL https://dl.espressif.com/dl/package_esp32_index.json nas preferências.
    • Instale a placa ESP32 no Gerenciador de Placas.
  • Instale as Bibliotecas Necessárias:
    • WiFi.h: Já inclusa com o suporte ao ESP32.
    • PubSubClient.h: Vá em Sketch > Incluir Biblioteca > Gerenciar Bibliotecas e procure por PubSubClient.

Implementação Prática🔗

Vamos desenvolver um projeto onde o ESP32:

  • Publica dados de temperatura em um tópico MQTT.
  • Assina um tópico para receber comandos para ligar ou desligar um LED.

Montagem do Circuito

  • LED: Conecte o ânodo a um resistor de 220Ω, que por sua vez é conectado ao pino GPIO 2 do ESP32.
  • Cátodo: Conecte ao GND do ESP32.

Código Fonte

A seguir, apresentamos o código completo com explicações detalhadas.

#include <WiFi.h>
#include <PubSubClient.h>
// Configurações da rede Wi-Fi
const char* ssid = "SEU_SSID";
const char* password = "SUA_SENHA";
// Configurações do MQTT
const char* mqtt_server = "seu_servidor.cloudmqtt.com";
const int mqtt_port = 1883;
const char* mqtt_user = "seu_usuario";
const char* mqtt_password = "sua_senha";
// Configurações do ESP32
WiFiClient espClient;
PubSubClient client(espClient);
long lastMsg = 0;
char msg[50];
int value = 0;
const int ledPin = 2;
void setup()
{
  pinMode(ledPin, OUTPUT);
  Serial.begin(115200);
  setup_wifi();
  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(callback);
}
void setup_wifi()
{
  delay(10);
  Serial.println();
  Serial.print("Conectando-se a ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED)
  {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi conectado");
  Serial.print("Endereço IP: ");
  Serial.println(WiFi.localIP());
}
void callback(char* topic, byte* payload, unsigned int length)
{
  Serial.print("Mensagem recebida [");
  Serial.print(topic);
  Serial.print("]: ");
  String message;
  for (int i = 0; i < length; i++)
  {
    message += (char)payload[i];
  }
  Serial.println(message);
  if (String(topic) == "esp32/led")
  {
    if (message == "on")
    {
      digitalWrite(ledPin, HIGH);
      Serial.println("LED ligado");
    }
    else if (message == "off")
    {
      digitalWrite(ledPin, LOW);
      Serial.println("LED desligado");
    }
  }
}
void reconnect()
{
  while (!client.connected())
  {
    Serial.print("Tentando se conectar ao MQTT...");
    if (client.connect("ESP32Client", mqtt_user, mqtt_password))
    {
      Serial.println("conectado");
      client.subscribe("esp32/led");
    }
    else
    {
      Serial.print("falhou, rc=");
      Serial.print(client.state());
      Serial.println(" tentando novamente em 5 segundos");
      delay(5000);
    }
  }
}
void loop()
{
  if (!client.connected())
  {
    reconnect();
  }
  client.loop();
  long now = millis();
  if (now - lastMsg > 2000)
  {
    lastMsg = now;
    float t = random(20, 30); // Simulando uma temperatura
    snprintf(msg, 50, "Temperatura: %.2f °C", t);
    Serial.print("Publicando mensagem: ");
    Serial.println(msg);
    client.publish("esp32/temperatura", msg);
  }
}

Detalhes do Código

  • Inclusões: Importamos as bibliotecas necessárias para Wi-Fi e MQTT.
  • Credenciais Wi-Fi e MQTT: Substitua com suas informações.
  • Função setup():
    • Configura o pino do LED.
    • Inicia a comunicação serial.
    • Conecta ao Wi-Fi.
    • Configura o servidor MQTT e o callback.
  • Função setup_wifi():
    • Gerencia a conexão Wi-Fi.
    • Exibe o endereço IP ao conectar.
  • Função callback():
    • Chamado quando uma mensagem é recebida.
    • Verifica o tópico e o conteúdo da mensagem.
    • Controla o LED com base na mensagem recebida.
  • Função reconnect():
    • Tenta reconectar ao broker MQTT em caso de desconexão.
    • Assina o tópico esp32/led.
  • Função loop():
    • Mantém a conexão MQTT.
    • Publica a temperatura simulada a cada 2 segundos no tópico esp32/temperatura.

Configurando suas Credenciais

  • Wi-Fi:
    • ssid: Nome da sua rede Wi-Fi.
    • password: Senha da sua rede Wi-Fi.
  • MQTT:
    • mqtt_server: Hostname fornecido pelo CloudMQTT.
    • mqtt_port: Geralmente é 1883 para conexões não seguras.
    • mqtt_user: Usuário MQTT fornecido.
    • mqtt_password: Senha MQTT fornecida.

Executando o Projeto

1. Compile e Carregue o código no ESP32.

2. Abra o Monitor Serial:

  • Observe as mensagens de conexão e publicação.

3. Acesse o Painel do CloudMQTT:

  • Navegue até a sua instância.
  • Clique em "Websocket UI" para interagir com o broker.

4. Visualize os Dados:

  • Assine o tópico esp32/temperatura para ver as mensagens de temperatura.

5. Controle o LED:

  • Publique no tópico esp32/led a mensagem on para ligar o LED.
  • Publique off para desligar o LED.

Integração com Outros Serviços em Nuvem🔗

Embora o CloudMQTT seja excelente para testes e projetos menores, integrar o ESP32 com serviços em nuvem mais robustos oferece vantagens adicionais, como maior escalabilidade, ferramentas de análise e integração com outros serviços.

AWS IoT Core

  • Características:
    • Suporte a milhões de dispositivos.
    • Integração com outros serviços AWS (Lambda, DynamoDB, etc.).
  • Considerações:
    • Requer configuração de certificados de segurança.
    • Possui custos associados após o nível gratuito.

Google Cloud IoT Core

  • Características:
    • Integração com Google Cloud Dataflow, BigQuery, etc.
    • Gerenciamento seguro de dispositivos.
  • Considerações:
    • Necessita de autenticação JWT.
    • Modelo de preços baseado no uso.

Azure IoT Hub

  • Características:
    • Gerenciamento bidirecional de dispositivos.
    • Integração com serviços Azure.
  • Considerações:
    • Suporte a protocolos adicionais além de MQTT.
    • Modelo de preços por camada (gratuito até um limite).

Aplicações Práticas🔗

A integração do ESP32 com serviços em nuvem permite desenvolver soluções inovadoras em diversos setores:

  • Agricultura Inteligente:
    • Monitoramento de condições do solo e clima.
    • Automação de sistemas de irrigação.
  • Cidades Inteligentes:
    • Monitoramento de tráfego e qualidade do ar.
    • Gestão inteligente de iluminação pública.
  • Indústria 4.0:
    • Monitoramento de máquinas e processos.
    • Manutenção preditiva.
  • Saúde:
    • Monitoramento remoto de pacientes.
    • Dispositivos vestíveis conectados.

Considerações Finais🔗

Conectar o ESP32 a serviços em nuvem através do MQTT é uma maneira eficaz de levar seus projetos ao próximo nível. Com a capacidade de publicar e assinar tópicos, você pode criar sistemas interativos e responsivos que se comunicam em tempo real. Ao explorar diferentes serviços em nuvem, você pode encontrar a solução que melhor se adapta às necessidades do seu projeto, seja ele um protótipo simples ou uma implementação em larga escala.


Este artigo faz parte do grupo Monitoramento Remoto com ESP32 e MQTT
Autor: Marcelo V. Souza - Engenheiro de Sistemas e Entusiasta em IoT e Desenvolvimento de Software, com foco em inovação tecnológica.

Referências🔗

Artigos Relacionados