Criando uma Conexão MQTT com ESP32 para Controle e Monitoramento de Dispositivos

autor

Felipe Jovino dos Santos | Nov. 20, 2023

Explicação de como implementar comunicação MQTT

artigo

Introdução

Neste artigo, exploraremos a fascinante integração do protocolo MQTT (Message Queuing Telemetry Transport) com o versátil microcontrolador ESP32. Iremos aproveitar todo o potencial do MQTT para interagir com uma variedade de acionadores e atuadores. Ao longo do tutorial, vamos aprender a receber dados de sensores diversos, como um botão, um potenciômetro e um sensor ultrassônico, enquanto também exploramos a capacidade de enviar comandos para controlar um LED.

O MQTT, um protocolo de comunicação leve amplamente adotado na Internet das Coisas (IoT), será nosso meio de comunicação dinâmico, proporcionando uma base sólida para realizar testes práticos com esses componentes. Esta abordagem ampla e versátil permitirá que exploremos o potencial completo do MQTT, criando uma experiência de aprendizado abrangente e aplicada. Para mais informações sobre MQTT, consulte aqui.

Prepare-se para desvendar as possibilidades emocionantes de interação entre o ESP32 e o MQTT, enquanto mergulhamos na realização de testes práticos envolvendo esses componentes.

Pré-requisitos

Configurando o Ambiente

Nesta seção, abordaremos como instalar e configurar o ambiente de desenvolvimento do Arduino IDE além de configurar para o uso do ESP32. Fica a observação de que é possível usar outros microcontroladores, basta fazer pequenas adaptações como por exemplo os pinos utilizados, estarei sinalizando quais são as exigências por cada componente.

Passo 1: Instalando o Arduino IDE

Para começar, você precisa instalar a IDE para ter seu ambiente de desenvolvimento Arduino, estarei ensinando para o Windows e Linux.

Windows

A primeira e mais fácil opção é via a Microsoft Store, nele pesquisa por “Arduino IDE”, ela foi desenvolvido pela Arduino LLC, preste atenção nisso para não confundi com outros programas.

A segunda opção é o site oficial do Arduino. Siga o passo a passo abaixo e provavelmente não terá grandes problemas.

  1. Visite http://www.arduino.cc/en/main/software para baixar a versão mais recente do Arduino IDE para o sistema operacional do seu computador. Existem versões para sistemas Windows, Mac e Linux. Na página de download, clique na opção “Windows Installer” para facilitar a instalação.
  2. Abra o arquivo zip.
  3. Extraia no local que preferi. OBS: Crie uma pasta e extraia os arquivos nela.
  4. Execute o “Arduino IDE” que estará na pasta recém extraída e estará pronto para uso.

Passo 2: Configurando o Arduino IDE

A próxima coisa a fazer é certificar-se de que o software esteja configurado para sua placa específica. Para isso siga os passos abaixo.

  1. No seu Arduino IDE, vá em Arquivo > Preferências.
  2. Insira o seguinte no campo “URLs adicionais do gerente do conselho”:
    http://arduino.esp8266.com/stable/package_esp8266com_index.json
    preferências IDE

Observação: se você já possui a URL de outras placas, você pode separar as URLs com vírgula.
3. Abra o Gerenciador de Placas. Vá em Ferramentas > Placas > Gerenciador de Placas.
Gerenciador de Placas

  1. Procure ESP32 e pressione o botão de instalação para ESP32 da Espressif Systems:
    Biblioteca ESP32

  2. Em seguida basta ir para Ferramentas > Placa > ESP32 Arduino > Buscar sua Placa.

Placa

OBS: No meu caso será a DOIT ESP32 DEVKIT V1.

Resolvendo Problemas Comuns com o ESP32

Ao tentar utilizar o ESP32, é comum depararmos com dois erros frequentes: o modo de flash/upload que não está ativo e a falta de driver para a porta COM4, essenciais para a comunicação serial. Neste guia, abordaremos como identificar e resolver esses problemas. Portanto, confie em nós e continue lendo!

Comunicação Entre o Computador e o Chip

A placa ESP32 utiliza um conversor USB-Serial para possibilitar a comunicação entre o computador e o chip ESP32 por meio da porta USB. Dependendo da versão da placa, o chip responsável por essa conversão pode ser o CP210x (placas NodeMCU V2 e ESP32) ou o CH340G (placas NodeMCU V3). Vou mostrar como você pode instalar o driver apropriado para garantir que sua placa possa ser programada.

Para verificar se a comunicação está funcionando corretamente, siga os passos a seguir:

  1. Abra a seção Ferramentas no ambiente de desenvolvimento.

  2. Conecte o cabo micro USB a uma das portas do seu notebook e ao ESP32.

  3. Verifique a lista de portas disponíveis na seção Porta.

Se a porta não estiver aparecendo como “COM4” ao lado ou se estiver ocorrendo algum erro relacionado aos drivers mencionados anteriormente, como o COM4 ou comunicação serial, siga os próximos passos para estabelecer a comunicação com o chip.

COM4

Neste caso vamos verificar se o driver é instalado automaticamente, para isso vamos utilizar o Cabo Micro USB para conectar a placa em seu computador. O sistema operacional irá automaticamente buscar por drivers compatíveis na internet. Caso o Windows não consiga encontrar os drivers para instalação da placa, você terá que instalar manualmente.

Quando o Windows não consegue encontrar os drivers, você encontrará um dispositivo sem driver no Gerenciador de Dispositivos como na imagem abaixo.

Sem Drive MCU

Instalação do NodeMCU V2 / ESP32 com conversor USB serial CP210x

A primeira coisa a se fazer é o download dos arquivos dos drivers de instalação acessando o link correspondente ao seus sistema operacional:

No Windows, após o download, descompacte o conteúdo do arquivo e acesse a pasta criada. Você encontrará dois arquivos executáveis, um para sistemas 32 bits e outro para sistemas 64 bits. Escolha o que corrresponde ao seu sistema operacional e execute o arquivo como Administrador. Para isso, basta clicar com o botão direito do mouse sobre o ícone do instalador e selecionar a opção “Executar como Administrador”. Uma janela como a da imagem abaixo deve abrir, a partir disto basta prosseguir com a instalação padrão.

Instalação do NodeMCU com conversor USB serial CH340G (V3)

A primeira coisa a se fazer é o download dos arquivos dos drivers de instalação acessando o link correspondente ao seus sistema operacional:

Da mesma maneira que o driver anterior, após o download descompacte o conteúdo do arquivo, acesse a pasta criada e execute o instalador como administrador. Clique em INSTALL. Após a instalação ser concluída, clique em OK e feche o instalador.

Alterar para modo Flash/upload

Se você tentar fazer o upload de um novo esboço para o seu ESP32 e receber a mensagem de erro “Ocorreu um erro fatal: Falha ao conectar ao ESP32: Tempo limite esgotado… Conectando…”, isso significa que o seu ESP32 não está no modo de flash/upload.

Certifique-se de ter selecionado corretamente o nome da placa e a porta COM4 e, em seguida, siga estas etapas:

  1. Mantenha pressionado o botão “BOOT” na sua placa ESP32. Na imagem abaixo é o botão superior esquerdo.

Imagem 2

  1. Enquanto mantém o botão “BOOT” pressionado, clique no botão “Upload” no Arduino IDE para carregar o seu código.

Seta para executar

  1. Após ver a mensagem “Conectando…” no seu Arduino IDE, solte o botão “BOOT”.

OBS: Para testar com algum código vá para o próximo tópico Testando o seu ESP32.

OBS: Lembre-se de que você terá que repetir essa sequência de botões sempre que quiser fazer upload.

Se desejar resolver esse problema de uma vez por todas, sem a necessidade de pressionar o botão “BOOT”, você precisará conectar um capacitor eletrolítico de 10 uF entre os pinos EN e GND.

É recomendável testar essa configuração primeiro em uma placa de ensaio para garantir que funcione corretamente com a sua placa de desenvolvimento ESP32.

Caso a configuração seja bem-sucedida, você pode optar por soldar o capacitor eletrolítico de 10 uF diretamente na placa. Dado que os pinos GND estão posicionados a certa distância um do outro, é simples conectar o capacitor entre esses pinos e o chip ESP32.

Observação: Neste artigo, não abordaremos o processo de soldagem, nem darei informações mais detalhadas sobre. Por favor, esteja ciente de que qualquer ação tomada é de sua própria responsabilidade. Caso queira mais informações sobre isso click aqui.

Testando o seu ESP32

Para realizar este teste, podemos usar alguns códigos prontos da biblioteca do Arduino. Siga as etapas abaixo:

  1. Abra o Arduino IDE.
  2. Vá em “Arquivo” > “Exemplos” > “01. Basics” > “Blink”.

Não se assuste se, ao abrir o novo Arduino IDE, você se deparar com várias informações e códigos. Para executar o seu código, siga as instruções abaixo:

  1. Clique na seta apontada para a direita, localizada no canto superior esquerdo.

Se o código for executado sem erros e seu ESP32 estiver funcionando corretamente, você verá um LED azul piscando. Parabéns, seu ESP está em perfeito estado!

Lembre-se de que o exemplo fornecido pelo Arduino não possui erros de código. Portanto, qualquer erro provavelmente está relacionado ao seu ESP32 ou a alguma configuração ou instalação incorreta.

Se você tiver problemas, entre em contato comigo pelo meu e-mail, que disponibilizarei ao final deste artigo. Alternativamente, você pode pesquisar na internet para obter ajuda específica sobre o seu erro.

MQTT

Passo 1: O código

#include <WiFi.h>
#include <PubSubClient.h>

// Definição das credenciais da rede Wi-Fi e do servidor MQTT
const char* ssid = "Jovino"; // Nome da rede Wi-Fi
const char* password = "benicio123"; // Senha da rede Wi-Fi
const char* mqtt_server = "broker.hivemq.com"; // Endereço do servidor MQTT

WiFiClient espClient;
PubSubClient client(espClient);
unsigned long lastMsg = 0;
#define MSG_BUFFER_SIZE (50)
char msg[MSG_BUFFER_SIZE];

// Configuração da conexão Wi-Fi
void setup_wifi() {
  delay(10);
  Serial.println();
  Serial.print("Conectando à rede ");
  Serial.println(ssid);

  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);

  // Aguarda a conexão à rede Wi-Fi
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  // Inicializa o gerador de números aleatórios
  randomSeed(micros());

  Serial.println("");
  Serial.println("WiFi conectado");
  Serial.println("Endereço IP: ");
  Serial.println(WiFi.localIP());
}

// Função de callback chamada quando uma mensagem MQTT é recebida
void callback(char* topic, byte* payload, unsigned int length) {
  Serial.print("Mensagem recebida [");
  Serial.print(topic);
  Serial.print("] ");

  // Exibe o conteúdo da mensagem recebida
  for (int i = 0; i < length; i++) {
    Serial.print((char)payload[i]);
  }

  Serial.println();

  // Controla o LED com base no conteúdo da mensagem
  if ((char)payload[0] == 'L') {
    digitalWrite(pin_led, HIGH);
    snprintf (msg, MSG_BUFFER_SIZE, "O LED está aceso");
    Serial.print("Publica mensagem: ");
    Serial.println(msg);
    client.publish("jovino/led", msg);
  }

  if ((char)payload[0] == 'l') {
    digitalWrite(pin_led, LOW);
    snprintf (msg, MSG_BUFFER_SIZE, "O LED está apagado");
    Serial.print("Publica mensagem: ");
    Serial.println(msg);
    client.publish("jovino/led", msg);
  }
}

// Função para reconectar ao servidor MQTT
void reconnect() {
  while (!client.connected()) {
    Serial.print("Tentando conectar ao MQTT...");
    String clientId = "JOVINO_MQTT";
    clientId += String(random(0xffff), HEX);

    // Tenta reconectar ao servidor MQTT
    if (client.connect(clientId.c_str())) {
      Serial.println("Conectado");
      // Subscreve aos tópicos relevantes após a conexão bem-sucedida
      client.subscribe("jovino/publisher");
      client.subscribe("jovino/led/state");
    } else {
      Serial.print("falha, rc=");
      Serial.print(client.state());
      Serial.println(" tentando novamente em 5 segundos");
      delay(5000);
    }
  }
}

// Configuração inicial
void setup() {
  Serial.begin(115200);

  // Configuração da conexão Wi-Fi e do cliente MQTT
  setup_wifi();
  client.setServer(mqtt_server, 1883);
  client.setCallback(callback);
}

// Loop principal
void loop() {
  // Reconecta ao servidor MQTT, se necessário
  if (!client.connected()) {
    reconnect();
  }

  // Mantém a conexão MQTT ativa
  client.loop();

  delay(500);
}

Passo 4: Configurando o Broker MQTT

Antes de prosseguir, é necessário configurar um servidor MQTT (também conhecido como broker). Você pode configurar um servidor local ou usar um serviço de broker MQTT na nuvem.

  1. Acesso ao HiveMQ:
    Acesse o site do HiveMQ e crie uma conta. Escolhemos o HiveMQ devido à sua natureza como um broker MQTT gratuito, oferecendo uma solução robusta para suas necessidades. No entanto, é válido mencionar que você pode escolher qualquer outro broker MQTT de sua preferência.

  2. Motivo da Escolha:
    Optamos pelo HiveMQ por ser uma opção gratuita, tornando-o acessível para projetos de diferentes escalas. A plataforma oferece confiabilidade e recursos essenciais para a configuração do broker MQTT.

  3. Configurando seu Cluster:
    Após criar sua conta e fazer login, você será direcionado para o painel do HiveMQ. No canto superior esquerdo, clique na opção “Clusters” e, em seguida, selecione “FREE #1”. Essa ação permitirá que você acesse o seu cluster gratuito.

Painel do HiveMQ

Agora que você tem o seu broker configurado, podemos prosseguir para os próximos passos da integração MQTT.

Passo 5: Conectando o ESP32 à Rede MQTT

Agora, vamos configurar o ESP32 para se conectar ao servidor MQTT. Isto envolve a configuração do nome do cliente, as credenciais de acesso e a definição dos tópicos MQTT.

Neste passo, vamos estabelecer a conexão entre o ESP32 e o servidor MQTT. Certifique-se de que os passos anteriores foram concluídos, pois a conexão MQTT depende da correta configuração da rede Wi-Fi e do servidor MQTT.

Estabelecendo a Conexão MQTT

  1. Configuração Inicial:

    • No método setup(), a conexão Wi-Fi é configurada utilizando a função setup_wifi(), e o cliente MQTT é inicializado com o endereço do servidor e a porta padrão (1883).

    • Além disso, o método setCallback(callback) é utilizado para especificar a função de callback que será chamada quando uma mensagem MQTT for recebida.
      2. Reconexão ao Servidor MQTT:

    • O método reconnect() é responsável por estabelecer a conexão ou reconectar ao servidor MQTT.

    • Enquanto o cliente não está conectado, ele tenta conectar e, em caso de falha, aguarda por 5 segundos antes de tentar novamente.
      3. Loop Principal:

    • O método loop() contém a chamada para reconnect() para garantir que a conexão com o servidor MQTT seja mantida ativa.

Com esses passos, o ESP32 será capaz de estabelecer e manter a conexão com o servidor MQTT, possibilitando a troca de mensagens entre o dispositivo e o broker MQTT. Certifique-se de adaptar as configurações de rede, como o nome da rede Wi-Fi (ssid), a senha (password), e o endereço do servidor MQTT (mqtt_server), conforme necessário para o seu ambiente.

Passo 2: Enviando as informações

Dentro do loop é necessário enviar as informações para isso use o seguinte código:

  sprintf(msg, "%i", resistencia);
  client.publish("jovino/resistencia", msg);
  1. sprintf(msg, “%i”, r);
    - sprintf é uma função em C/C++ que é usada para formatar e armazenar uma string em uma variável. Neste caso, a variável msg está sendo formatada para conter o valor da variável r como uma string.
    - %i é um especificador de formato que indica que o valor de r será formatado como um número inteiro na string resultante.

Portanto, esta linha de código está convertendo o valor da variável r (presumivelmente um número inteiro) em uma string e armazenando essa string na variável msg.

  1. client.publish(“jovino/resistencia”, msg);
    - client.publish é a função que publica uma mensagem em um tópico específico em um sistema de comunicação, muitas vezes associado a protocolos de mensagens em redes de IoT (como o MQTT). O tópico neste caso é “jovino/resistencia” você pode escolher o nome que preferi.
    - No caso, a mensagem a ser publicada é o conteúdo da variável msg, e o tópico é “jovino/resistencia”.

Passo 3: Recebendo as Informações

Para receber as informações no dispositivo MQTT, é necessário a função de callback que será chamada sempre que uma mensagem MQTT for recebida. No exemplo fornecido no Passo 1, a função callback é responsável por tratar as mensagens recebidas. No entanto, é importante destacar alguns pontos-chave:

  1. Parâmetros da função de callback:
    - char* topic: Representa o tópico ao qual a mensagem foi enviada.
    - byte* payload: Contém os dados da mensagem recebida.
    - unsigned int length: Indica o comprimento da mensagem.

  2. Processamento da mensagem:
    - O conteúdo da mensagem é percorrido byte a byte no loop for, e cada byte é tratado conforme necessário. No exemplo fornecido, o conteúdo da mensagem é exibido no monitor serial.

  3. Controle do LED:
    - O exemplo ilustra o controle de um LED com base no conteúdo da mensagem. Se o primeiro caractere da mensagem for ‘L’, o LED é aceso; se for ‘l’, o LED é apagado. A resposta é então publicada no tópico “jovino/led”.

  4. Publicação de Respostas:
    - Após o processamento da mensagem, é possível gerar uma resposta que pode ser publicada de volta ao servidor MQTT. No exemplo, mensagens indicando o estado do LED são publicadas no tópico “jovino/led”.

Ao implementar a lógica de recebimento e processamento de mensagens no dispositivo MQTT, é possível criar uma comunicação bidirecional eficaz entre o dispositivo e o servidor MQTT.

Conectando um Botão ao ESP32

Neste guia, aprenderemos a conectar um botão ao ESP32 em alguns passos simples. O botão pode ser usado para acionar diversas funções no seu projeto, como ligar e desligar um LED, enviar um sinal, ou realizar outras ações.

  1. Conectando o Botão
  1. Usando o Resistor
  1. Finalizando a Conexão
Imagem 1 Imagem 2

O código

// Define a variável pin_button e atribui o valor 34 a ela
int pin_button = 34;

// Configuração inicial do Arduino
void setup() {
  // Inicia a comunicação serial com uma taxa de transmissão de 115200 bps
  Serial.begin(115200);

  // Configura o pino definido como pin_button como entrada para leitura
  pinMode(pin_button, INPUT);
}

// Loop principal do programa
void loop() {
  // Lê o estado do botão e armazena na variável b
  int b = digitalRead(pin_button);

  // Imprime a mensagem indicando o estado atual do botão no monitor serial
  Serial.print("O estado do botão é: ");
  Serial.println(b);

  // Aguarda 500 milissegundos antes de repetir o loop
  delay(500);
}

Explicação

setup()

loop()

Conectando o Potenciômetro

  1. Conectando o ESP32:
    - Conecte o pino 3V3 do ESP32 a um dos pinos laterais do potenciômetro.
    - Conecte o pino GND do ESP32 ao outro pino lateral do potenciômetro.
    - OBS O posicionamento dos fios nos pinos laterais do potenciômetro não é crítico, uma vez que a ordem não importa. Isso apenas afetará em que direção você precisa girar o potenciômetro para aumentar ou diminuir a resistência.

  2. Conectando o Pino Central do Potenciômetro:
    - Conecte o pino VP (ou outro pino analógico de sua escolha no ESP32) ao pino central do potenciômetro. Este é o pino que permitirá que você leia os valores de resistência variável do potenciômetro.

  3. Alimentação e Terra:
    - Certifique-se de que o ESP32 esteja alimentado e aterrado corretamente para o circuito funcionar adequadamente. Isso é feito através dos fios 3V3 e GND, como mencionado nos passos 1.

Imagem 1 Imagem 2

Código

// Define o pino ao qual o potenciômetro está conectado
int pin_potenciometro = 36;

void setup() {
    // Inicia a comunicação serial a uma taxa de 115200 bits por segundo
    Serial.begin(115200);

    // Configura o pino do potenciômetro como entrada
    pinMode(pin_potenciometro, INPUT);
}

void loop() {
    // Lê o valor analógico do potenciômetro
    int r = analogRead(pin_potenciometro);

    // Imprime a mensagem "Resistência: " seguida pelo valor lido do potenciômetro
    Serial.print("Resistência: ");
    Serial.println(r);

    // Aguarda 500 milissegundos (ou 0,5 segundos)
    delay(500);
}

Explicação

setup()

loop()

Conectando o Sensor Ultrassônico

Nesta seção, vamos mostrar como montar o sensor ultrassônico em seu sistema. O sensor ultrassônico é um dispositivo crucial para medir distâncias usando ondas sonoras, e a correta conexão aos pinos do seu microcontrolador é essencial para o funcionamento adequado. Siga as etapas abaixo para fazer a montagem:

  1. Conexão de Terra (GND): O primeiro passo é conectar o pino GND (terra) do sensor ultrassônico ao GND do seu microcontrolador. Certifique-se de que as tensões estejam niveladas para evitar qualquer dano ao sensor ou ao microcontrolador.

  2. Conexão de Alimentação (VIN): Conecte o pino VIN (tensão de alimentação) do sensor ultrassônico à saída de 3.3V (ou 3V3) do seu microcontrolador. O sensor ultrassônico geralmente opera com uma tensão de 3.3V, portanto, forneça a tensão adequada para garantir seu funcionamento correto.

  3. Conexão do Pino Trig: O pino Trig é usado para enviar o sinal de pulso de ultrassom. Conecte-o ao pino D33 (ou o pino que você escolher) do seu microcontrolador. Certifique-se de configurar o pino D33 como uma saída no código do seu microcontrolador.

  4. Conexão do Pino Echo: O pino Echo é usado para receber o sinal refletido do ultrassom. Conecte-o ao mesmo pino D33 (ou o pino que você escolheu) que você conectou o pino Trig. Certifique-se de configurar o pino D33 como uma entrada no código do seu microcontrolador.

Imagem 1 Imagem 2

Código

// Define os pinos para o sensor ultrassônico
int echo = 32;  // Pino de entrada para receber o eco do sinal ultrassônico
int trig = 33;  // Pino de saída para enviar o sinal ultrassônico

void setup() {
  // Inicializa a comunicação serial para enviar dados para o computador
  Serial.begin(115200);

  // Configura os pinos como saída ou entrada
  pinMode(trig, OUTPUT);  // O pino de envio é configurado como saída
  pinMode(echo, INPUT);   // O pino de recebimento é configurado como entrada
}

void loop() {
  // Envia um pulso ultrassônico curto para o sensor
  digitalWrite(trig, HIGH);
  delayMicroseconds(10);
  digitalWrite(trig, LOW);

  // Mede a duração do eco, que é proporcional à distância
  tempo = pulseIn(echo, HIGH);

  // Converte a duração do eco em centímetros (baseado em uma constante de conversão)
  distancia = tempo / 58;

  // Envia a distância medida para o computador via comunicação serial
  Serial.println(distancia);
}

Explicação

setup()

loop()

Controlando um LED

Nesta seção, vamos mostrar como montar um sistema simples com um LED, utilizando um ESP32. O LED será controlado através do microcontrolador ESP32, e para isso, precisaremos de alguns componentes básicos, incluindo um LED, um resistor de 220 ohms e um ESP32.

Conexões

Para montar o circuito, siga as seguintes etapas de conexão:

  1. Conectar o Pino Positivo do LED ao D2 do ESP32: O pino positivo do LED (ânodo) deve ser conectado ao pino D2 do ESP32. Isso permitirá ao ESP32 controlar o estado do LED, ligando-o e desligando-o.

  2. Conectar o Pino Negativo do LED ao Resistor de 220 ohms: O pino negativo do LED (cátodo) deve ser conectado ao resistor de 220 ohms. O resistor limitará a corrente que passa pelo LED, protegendo-o contra danos.

  3. Conectar o Outro Lado do Resistor ao GND do ESP32: O outro lado do resistor de 220 ohms deve ser conectado ao pino GND (terra) do ESP32. Isso completa o circuito, permitindo que a corrente flua do ESP32, passando pelo LED, e voltando ao GND.

As conexões garantem que o LED possa ser controlado pelo ESP32 de forma segura, evitando sobrecorrente que possa danificar o LED.

Imagem 1 Imagem 2

Código

if ((char)payload[0] == 'L') {
    digitalWrite(pin_led, HIGH);
    snprintf (msg, MSG_BUFFER_SIZE, "O LED está aceso");
    Serial.print("Publica mensagem: ");
    Serial.println(msg);
    client.publish("jovino/led", msg);
}

  if ((char)payload[0] == 'l') {
    digitalWrite(pin_led, LOW);
    snprintf (msg, MSG_BUFFER_SIZE, "O LED está apagado");
    Serial.print("Publica mensagem: ");
    Serial.println(msg);
    client.publish("jovino/led", msg);
}

Considerações Finais

Agora que você tem o ambiente, Broker, comunicação MQTT e vários códigos para testar você pode colocar os códigos dentro do loop for ou em funções como preferir para organizar. Em caso de dúvida estarei anexando aqui o código final, ele está funcionando totalmente, então caso tenha problemas o analise e compare com o seu.

Por fim, neste artigo exploramos como criar uma conexão MQTT com um ESP32 para receber informações de sensores, como botão, potenciômetro e sensor ultrassônico, e também para enviar comandos de controle a um LED. Isso abre um mundo de possibilidades para automação e controle remoto de dispositivos IoT

Referências

Aqui estão algumas referências que podem ser úteis para ajudá-lo a aprofundar seus conhecimentos sobre MQTT, ESP32 e projetos de IoT: