Controle e Monitoramento IoT com NodeMCU e MQTT

Controle e Monitoramento IoT com NodeMCU e MQTT

O módulo Wifi ESP8266 NodeMCU é uma das mais interessantes placas / plataformas existentes. A razão disso é simples: em uma pequena placa estão disponíveis I/Os, circuitaria de regulação de tensão, conectividade USB para programação (em Lua ou pela Arduino IDE) e conectividade WI-FI (ESP8266 12-E), caracterizando uma placa auto-suficiente para projetos envolvendo IoT, como faremos neste post envolvendo o NodeMCU e MQTT.

NodeMCU - Controle e monitoramento IoT

Será mostrada uma das mais interessantes aplicações desta placa: a conectividade com a nuvem através de MQTT para monitoramento e controle de um output, com um diferencial: a interface com o usuário sendo uma página web.

Funcionamento do MQTT

O MQTT (Message Queue Telemetry Transport) consiste em um protocolo de mensagens leve, criado para comunicação M2M (Machine to Machine). Por exigir muito pouco “poder de fogo” em termos de processamento e banda / consumo de Internet, este é um dos protocolos ideais para dispositivos embarcados. Por esta razão, o MQTT é famoso no conceito IoT (Internet of Things).

Uma comunicação MQTT é composta das seguintes partes: há publishers (quem irá disponibilizar informações), subscribers (quem irá receber as informações) e Broker (servidor MQTT, na nuvem / acessível de qualquer lugar do planeta que contenha conexão com a Internet). Teoricamente, não há limite especificado de subscribers e publishers em uma mesma comunicação MQTT, pois o limite nesse aspecto  é do servidor em lidar com as conexões.

Em suma: publishers enviam informação para o Broker, subscribers recebem informação do Broker e o Broker gerencia a troca de mensagens. Ou seja, o trabalho pesado fica a cargo do Broker, deixando os sistemas embarcados livre para gerenciar outras coisas.

NodeMCU e MQTT

Sem entrar no mérito da especificação do protocolo MQTT (ou seja, byte a byte do protocolo), grosso modo uma mensagem MQTT publicada / enviada possui duas partes importantes:

  • Tópico – “chave” / identificação da informação publicada. É usado para direcionar a informação publicada / enviada a quem assina (quem “dá subscribe”) no tópico. O tópico consiste de uma string (por exemplo: MQTTTesteTopico)
  • Payload – informação que deseja enviar (propriamente dita).

Um publisher, conectado ao Broker (servidor MQTT) , envia/publica as informações em um dado momento. Os subscribers, assim como os publishers, também estão conectados aos brokers e “escutando” mensagens trafegadas com o tópico-alvo. Quando uma mensagem com o tópico alvo é publicada, automaticamente são direcionadas aos subscribers.

Em outras palavras: uma solução em IoT que usa MQTT possui somente um servidor (Broker), sendo todo o restante composto de clients MQTT.

Outra informação importante é que um mesmo client MQTT pode ser subscriber e publisher de diversos tópicos.

Como utilizar o NodeMCU e MQTT

O NodeMCU pode ser programado para interagir com um broker MQTT, ou seja, ele pode ser programado para ser um client MQTT. Antes de ser programado para isso, é necessário:

1 – Preparar a IDE Arduino para programar o NodeMCU. Veja como fazer isso no post Como programar o NodeMCU com IDE Arduino

2 – Baixar e instalar a biblioteca pubsubclient. Para baixar, visite o GitHub do projeto.

Feito isso, devemos escolher um broker MQTT para utilizar. Há inúmeros brokers disponíveis para uso (tanto públicos / sem custo quanto privados / pagos). Dos públicos, eu recomendo fortemente o iot.eclipse.org (broker oficial da equipe que mantém o MQTT), que irá funcionar perfeitamente com o nosso projeto de NodeMCU e MQTT.

Enfim, agora é possível usarmos o NodeMCU como um client MQTT! Para isso, será feito um projeto que permite controlar e monitorar um output do NodeMCU via MQTT. O output em questão é o próprio LED da placa (que, neste caso, está ligado diretamente ao output D0).

Importante:
1)
O LED possui acionamento em lógica invertida, ou seja, para acendê-lo é preciso enviar o estado LOW para D0 e para apagá-lo é necessário enviar estado High. Isto ocorre pois o output está ligado ao catodo do LED na placa.

2) O ID MQTT no código serve como identificador para o broker, o permitindo gerenciar as conexões. Se você escolher um ID MQTT que já está sendo utilizado, a conexão do mesmo será interrompida para a sua ser estabelecida. Isto pode gerar grandes transtornos para ambos os dispositivos com mesmo ID MQTT. Desta forma, recomendo que o ID MQTT seja escolhido como algo aleatório (assim garante-se unicidade do mesmo).

3) Como não foi utilizado nenhum componente além da própria NodeMCU, não há circuito esquemático envolvido (ou seja, em termos de hardware é preciso somente do NodeMCU!)

Programa NodeMCU e MQTT

Vamos à programação!

#Programa: NodeMCU e MQTT - Controle e Monitoramento IoT
#Autor: Pedro Bertoleti

#include <ESP8266WiFi.h> // Importa a Biblioteca ESP8266WiFi
#include <PubSubClient.h> // Importa a Biblioteca PubSubClient

//defines:
//defines de id mqtt e tópicos para publicação e subscribe
#define TOPICO_SUBSCRIBE "MQTTFilipeFlopEnvia"     //tópico MQTT de escuta
#define TOPICO_PUBLISH   "MQTTFilipeFlopRecebe"    //tópico MQTT de envio de informações para Broker
                                                   //IMPORTANTE: recomendamos fortemente alterar os nomes
                                                   //            desses tópicos. Caso contrário, há grandes
                                                   //            chances de você controlar e monitorar o NodeMCU
                                                   //            de outra pessoa.
#define ID_MQTT  "HomeAut"     //id mqtt (para identificação de sessão)
                               //IMPORTANTE: este deve ser único no broker (ou seja, 
                               //            se um client MQTT tentar entrar com o mesmo 
                               //            id de outro já conectado ao broker, o broker 
                               //            irá fechar a conexão de um deles).
                               

//defines - mapeamento de pinos do NodeMCU
#define D0    16
#define D1    5
#define D2    4
#define D3    0
#define D4    2
#define D5    14
#define D6    12
#define D7    13
#define D8    15
#define D9    3
#define D10   1


// WIFI
const char* SSID = "SSID"; // SSID / nome da rede WI-FI que deseja se conectar
const char* PASSWORD = "SENHA"; // Senha da rede WI-FI que deseja se conectar
 
// MQTT
const char* BROKER_MQTT = "iot.eclipse.org"; //URL do broker MQTT que se deseja utilizar
int BROKER_PORT = 1883; // Porta do Broker MQTT


//Variáveis e objetos globais
WiFiClient espClient; // Cria o objeto espClient
PubSubClient MQTT(espClient); // Instancia o Cliente MQTT passando o objeto espClient
char EstadoSaida = '0';  //variável que armazena o estado atual da saída
 
//Prototypes
void initSerial();
void initWiFi();
void initMQTT();
void reconectWiFi(); 
void mqtt_callback(char* topic, byte* payload, unsigned int length);
void VerificaConexoesWiFIEMQTT(void);
void InitOutput(void);

/* 
 *  Implementações das funções
 */
void setup() 
{
    //inicializações:
    InitOutput();
    initSerial();
    initWiFi();
    initMQTT();
}
 
//Função: inicializa comunicação serial com baudrate 115200 (para fins de monitorar no terminal serial 
//        o que está acontecendo.
//Parâmetros: nenhum
//Retorno: nenhum
void initSerial() 
{
    Serial.begin(115200);
}

//Função: inicializa e conecta-se na rede WI-FI desejada
//Parâmetros: nenhum
//Retorno: nenhum
void initWiFi() 
{
    delay(10);
    Serial.println("------Conexao WI-FI------");
    Serial.print("Conectando-se na rede: ");
    Serial.println(SSID);
    Serial.println("Aguarde");
    
    reconectWiFi();
}
 
//Função: inicializa parâmetros de conexão MQTT(endereço do 
//        broker, porta e seta função de callback)
//Parâmetros: nenhum
//Retorno: nenhum
void initMQTT() 
{
    MQTT.setServer(BROKER_MQTT, BROKER_PORT);   //informa qual broker e porta deve ser conectado
    MQTT.setCallback(mqtt_callback);            //atribui função de callback (função chamada quando qualquer informação de um dos tópicos subescritos chega)
}
 
//Função: função de callback 
//        esta função é chamada toda vez que uma informação de 
//        um dos tópicos subescritos chega)
//Parâmetros: nenhum
//Retorno: nenhum
void mqtt_callback(char* topic, byte* payload, unsigned int length) 
{
    String msg;

    //obtem a string do payload recebido
    for(int i = 0; i < length; i++) 
    {
       char c = (char)payload[i];
       msg += c;
    }
  
    //toma ação dependendo da string recebida:
    //verifica se deve colocar nivel alto de tensão na saída D0:
    //IMPORTANTE: o Led já contido na placa é acionado com lógica invertida (ou seja,
    //enviar HIGH para o output faz o Led apagar / enviar LOW faz o Led acender)
    if (msg.equals("L"))
    {
        digitalWrite(D0, LOW);
        EstadoSaida = '1';
    }

    //verifica se deve colocar nivel alto de tensão na saída D0:
    if (msg.equals("D"))
    {
        digitalWrite(D0, HIGH);
        EstadoSaida = '0';
    }
    
}
 
//Função: reconecta-se ao broker MQTT (caso ainda não esteja conectado ou em caso de a conexão cair)
//        em caso de sucesso na conexão ou reconexão, o subscribe dos tópicos é refeito.
//Parâmetros: nenhum
//Retorno: nenhum
void reconnectMQTT() 
{
    while (!MQTT.connected()) 
    {
        Serial.print("* Tentando se conectar ao Broker MQTT: ");
        Serial.println(BROKER_MQTT);
        if (MQTT.connect(ID_MQTT)) 
        {
            Serial.println("Conectado com sucesso ao broker MQTT!");
            MQTT.subscribe(TOPICO_SUBSCRIBE); 
        } 
        else 
        {
            Serial.println("Falha ao reconectar no broker.");
            Serial.println("Havera nova tentatica de conexao em 2s");
            delay(2000);
        }
    }
}
 
//Função: reconecta-se ao WiFi
//Parâmetros: nenhum
//Retorno: nenhum
void reconectWiFi() 
{
    //se já está conectado a rede WI-FI, nada é feito. 
    //Caso contrário, são efetuadas tentativas de conexão
    if (WiFi.status() == WL_CONNECTED)
        return;
        
    WiFi.begin(SSID, PASSWORD); // Conecta na rede WI-FI
    
    while (WiFi.status() != WL_CONNECTED) 
    {
        delay(100);
        Serial.print(".");
    }
  
    Serial.println();
    Serial.print("Conectado com sucesso na rede ");
    Serial.print(SSID);
    Serial.println("IP obtido: ");
    Serial.println(WiFi.localIP());
}

//Função: verifica o estado das conexões WiFI e ao broker MQTT. 
//        Em caso de desconexão (qualquer uma das duas), a conexão
//        é refeita.
//Parâmetros: nenhum
//Retorno: nenhum
void VerificaConexoesWiFIEMQTT(void)
{
    if (!MQTT.connected()) 
        reconnectMQTT(); //se não há conexão com o Broker, a conexão é refeita
    
     reconectWiFi(); //se não há conexão com o WiFI, a conexão é refeita
}

//Função: envia ao Broker o estado atual do output 
//Parâmetros: nenhum
//Retorno: nenhum
void EnviaEstadoOutputMQTT(void)
{
    if (EstadoSaida == '0')
      MQTT.publish(TOPICO_PUBLISH, "D");

    if (EstadoSaida == '1')
      MQTT.publish(TOPICO_PUBLISH, "L");

    Serial.println("- Estado da saida D0 enviado ao broker!");
    delay(1000);
}

//Função: inicializa o output em nível lógico baixo
//Parâmetros: nenhum
//Retorno: nenhum
void InitOutput(void)
{
    //IMPORTANTE: o Led já contido na placa é acionado com lógica invertida (ou seja,
    //enviar HIGH para o output faz o Led apagar / enviar LOW faz o Led acender)
    pinMode(D0, OUTPUT);
    digitalWrite(D0, HIGH);          
}


//programa principal
void loop() 
{   
    //garante funcionamento das conexões WiFi e ao broker MQTT
    VerificaConexoesWiFIEMQTT();

    //envia o status de todos os outputs para o Broker no protocolo esperado
    EnviaEstadoOutputMQTT();

    //keep-alive da comunicação com broker MQTT
    MQTT.loop();
}

Desta forma, seu NodeMCU vira um client MQTT acessível de qualquer lugar do planeta!

Interação com o NodeMCU

Vimos até agora que é possível transformar a incrível placa NodeMCU em um client MQTT acessível por todo o planeta. Mas e para interagir com ele (ligar e desligar o output), como faremos?

Para isso, desenvolvi uma interface web que pode ser baixada clicando AQUI. Você pode hospedar essa interface em QUALQUER servidor web ou mesmo rodar no seu próprio computador / rodar localmente (desde que o computador possua conexão com Internet, claro)!

Esta interface web é basicamente um websocket que se comunica diretamente com o broker, por isso pode estar rodando em qualquer lugar com disponibilidade de Internet que funciona.

Observe a figura abaixo:

Figura 1 – screenshot da página de controle do NodeMCU

Figura 1 – screenshot da página de controle do NodeMCU

Para funcionar:

1 – Definir as strings dos tópicos de publish e subscribe e clicar em “Conectar”. Aguardar a mensagem Conectado ao Broker! aparecer na sessão “Debug / respostas do servidor”.

2 – Clicar em Ligar e Desligar para comandar o LED da placa NodeMCU. Observe que na sessão “Status do output” irá constar o estado atual do LED. Este estado é recebido do próprio NodeMCU, via MQTT (o que torna este controle um controle em tempo real).

3 – Se divertir com o NodeMCU e MQTT!

Gostou ? Ajude-nos a melhorar o blog atribuindo uma nota a este tutorial (estrelas no final do artigo), comente e visite nossa loja FILIPEFLOP!

5
Controle e Monitoramento IoT com NodeMCU e MQTT
41 votos, 4.93 classificação média (98% pontuação)

Engenheiro eletricista formado pela Faculdade de Engenharia de Guaratinguetá (FEG - UNESP), trabalha com desenvolvimento de firmware. Colaborador do site FILIPEFLOP.

Compartilhe este Post

60 Comentários

  1. Guilherme - 26 de abril de 2017

    Olá Pedro. Primeiramente parabéns pelo conteúdo redigido.

    Gostaria de saber se é possível desenvolver uma página web com login e senha em que eu configuro a minha rede wifi no ESP8266 e após isso é gerado um subscribe e um publish aleatório para que assim, um determinado subscriber só possa ver os status de seus respectivos publishers.

    Desde ja agradeço.

    • Pedro Bertoleti - 26 de abril de 2017

      Guilherme, boa noite. Primeiramente, muito obrigado pelo elogio e leitura do artigo!

      Eu não sei se isso é possível (nunca cheguei a fazer algo parecido). Infelizmente vou ficar te devendo a resposta.

      Atenciosamente,
      Pedro Bertoleti

  2. Emanuel Mariano - 8 de março de 2017

    Olá, tenho uma dúvida. Estou implementando um sistema de monitoramento de energia usando MQTT. O protocolo diz que publish e subscriber devem assinar o mesmo tópico para que as informações que um publique o outro tenha acesso. Então, eu n entendi pq vocês criaram dois tópicos e também não vi qual o momento em que os dispositivos assinam esses tópicos.

    • Pedro Bertoleti - 8 de março de 2017

      Emanuel, bom dia.

      O que ocorre é que há um tópico dedicado para transmitir informações da interface web para o NodeMCU e outro dedicado para transmitir informações do NodeMCU para a interface web. Portanto, cada tópico está com publish e subscrbe “amarrado”, conforme especifica o protocolo MQTT.

      A razão de ter dois tópicos foi facilitar a visualização de mensagens MQTT (essa foi a ideia, desculpa se não ficou claro e boa essa parte).

      Quanto ao momento em que o NodeMCU assina o tópico, isso ocorre na função reconnect MQTT.

      Atenciosamente,
      Pedro Bertoleti

      • Emanuel Mariano - 8 de março de 2017

        Pedro, muito obrigado. Pelo que pude entender, estaria igualmente correto utilizar um ao tópico, onde os dois seriam hora publish e hora subscriber?

        Além disso, parabéns pelo trabalho aqui do filipeflop, tem uma postagem de vocês que uso como referência no meu tcc.

  3. ELizeu - 27 de fevereiro de 2017

    Boa tarde Pedro,
    Fiquei com uma dúvida, como eu faço para ter vários tópicos de publicação?
    E como publicar em níveis diferentes?
    exemplo:
    CASA/ILUMINACAO/SALA
    CASA/TEMPERATURA/SALA o que eu teria que alterar no #define abaixo?

    #define TOPICO_SUBSCRIBE “MQTTFilipeFlopEnvia”
    #define TOPICO_PUBLISH “MQTTFilipeFlopRecebe”

    • Pedro Bertoleti - 27 de fevereiro de 2017

      Elizeu, boa noite.

      Para ter vários tópicos distintos, basta criar mais defines e fazer mais subscribes aos tópicos dos defines (quantos quiser, não há limite definido neste caso).
      Respondi sua pergunta (essa era sua dúvida mesmo? não sei se entendi direito a sua pergunta)?

      Atenciosamente,
      Pedro Bertoleti

  4. Jurandir Hora - 22 de fevereiro de 2017

    Pedro, boa noite!
    Primeiramente, parabéns pelo artigo!
    Instalei o MQTT broker no Windows e ele já está funcionando.
    Gostaria de saber quais as modificações que devo fazer no seu código para usa-lo localmente (em localhost).

    Att.:Jurandir

    • Pedro Bertoleti - 23 de fevereiro de 2017

      Jurandir, bom dia.

      Muito obrigado pela leitura e pelo elogio!
      Para fazer o NodeMCU se conectar ao seu broker, basta colocar como “alvo” o IP do computador onde o broker está rodando. Para descobrir o IP do computador que está rodando o broker, vá ao prompt de comando e digite ipconfig. O IP que aparece em IPv4 é o IP de seu computador na rede.
      Com este IP em mãos, ao invés de colocar “iot.eclipse.org” no código, coloque o IP obtido (entre as áspas).

      Atenciosamente,
      Pedro Bertoleti

      • Jurandir Hora - 24 de fevereiro de 2017

        Pedro, boa noite!
        Mudei o trecho do código de conexão BROKER_MQTT no arduino.

        ao invés de:
        //const char* BROKER_MQTT = “iot.eclipse.org”; //URL do broker MQTT que se deseja utilizar
        coloquei
        const char* BROKER_MQTT = “192.168.1.110”; //Ip do meu PC
        int BROKER_PORT = 1883; // Porta do Broker MQTT

        No terminal serial aparece
        Conectando-se na rede: GA-Lab
        Aguarde
        ……………………..
        Conectado com sucesso na rede GA-LabIP obtido:
        192.168.1.188
        * Tentando se conectar ao Broker MQTT: 192.168.1.110
        Conectado com sucesso ao broker MQTT!
        – Estados dos motores enviados ao broker!

        Ou seja ele conecta normalmente, porém quando tento conectar com o código em html e js que você disponibilizou ele não conecta

        Fiz as seguintes mudanças no arquivo tmo.js:
        mosq.ondisconnect = function(rc){
        var p = document.createElement(“p”);
        //var url = “ws://iot.eclipse.org/ws”;
        var url = “ws://192.168.1.110/ws”;
        e
        Page.prototype.connect = function(){
        //var url = “ws://iot.eclipse.org/ws”;
        var url = “ws://192.168.1.110/ws”;
        mosq.connect(url);

        tenho como resposta: A conexão com o broker foi perdida.
        No que estou errando?

        Desde já agradeço!

  5. Diego Rodrigo Alves - 10 de fevereiro de 2017

    Boa noite Pedro

    Fantástico o blog eu gostaria de usar o seu projeto, para aprender mais sobre o iot porem sou novato no assunto, que IDE você usou para criar a pagina de web, como posso aprender mais sobre o passo a passo para que eu desenvolva o meu projeto sozinho.

    • Pedro Bertoleti - 12 de fevereiro de 2017

      Diego, boa tarde.

      Muito obrigado pela leitura e pelo feedback!
      Quanto à página web, eu a criei “na mão” mesmo (programei o HTML e JavaScript na mão). De coisa pronta, usei somente a biblioteca JavaScript do Paho-MQTT mesmo.
      Quando você diz aprender mais sobre o passo-a-passo, o que você quis dizer? Não entendi, desculpa.

      Atenciosamente,
      Pedro Bertoleti

  6. Washington Coutinho Corrêa Junior - 18 de janeiro de 2017

    É, a interface web não está funcionando (não conecta). Alguma dica do que fazer?

    Abraços!

  7. Alysson Borba - 28 de dezembro de 2016

    Excelente explicação sobre o MQTT e o uso com a NodeMCU!
    Estou fazendo um TCC no qual pretendo usar o MQTT para transmissão de informações para um site mas, no momento, estou com dificuldade para criar um websocket para receber e enviar as informações para a NodeMCU.
    Eu enviei o seu código para a NodeMCU e funcionou bem (com um LED externo e usando o programa Mosquitto), mas a sua Interface Web não funcionou aqui. Além disso, não entendi como funciona o teste disponibilizado pelo mosquitto.org (test.mosquitto.org).

    Se não for muito incômodo, gostaria que você me ajudasse nesses detalhes. Te agradeço desde já por ter feito este post sobre o MQTT pois realmente ajudou bastante.

    Vou deixar meu email caso queira entrar em contato: alyssonjmb@gmail.com

  8. Rangel - 20 de dezembro de 2016

    Olá Pedro,

    parabéns pelo site e pelo tópico, venho aprendendo muita coisa com vocês ultimamente.
    Entretanto estou com dificuldades de colocar a minha ESP8266 para funcionar. Estou com a mesma placa utilizada nesse tópico, inclusive comprada no site e, ao seguir esse passo a passo, no site aparece o seguinte erro:
    “A conexão com o broker foi perdida.”
    Como se não fosse possível se conectar com a placa.
    Qual erro está ocorrendo e como seria possível corrigir isso?
    Nas configurações deixei:
    Placa: “Node MCU 1.0 ESP-12E Module)
    CPU Frequency: 80MHz
    Flash Size: 4M(SPIFFS)
    UploadSpeed: 155200
    Porta COM4
    Programador: AVRISP mkll.

    Modifiquei o nome e a senha da minha internet, e não alterei o:
    #define TOPICO_SUBSCRIBE “MQTTFilipeFlopEnvia”
    #define TOPICO_PUBLISH “MQTTFilipeFlopRecebe”

    // WIFI
    const char* SSID = “GVT-73F0″; // SSID / nome da rede WI-FI que deseja se conectar
    const char* PASSWORD = “91DC114621″; // Senha da rede WI-FI que deseja se conectar

    A fim de poder testar o código diretamente como se encontra o seu site pre-definido.

    Agradeço desde já pela sua ajuda.

    • Pedro Bertoleti - 21 de dezembro de 2016

      Rangel, muito obrigado pela leitura e pelos elogios!

      Conforme mostra os comentários no código, além de alterar os nomes dos tópicos (para não ter risco de coincidir com o tópico de alguém), é preciso modificar o ID_MQTT. Experimente alterar o valor dele e tente de novo.

      Atenciosamente,
      Pedro Bertoleti

      • Rangel - 21 de dezembro de 2016

        Pedro Bertoleti,

        tentei fazer isso, deixei da seguinte forma:
        #define TOPICO_SUBSCRIBE “entdadosszillat”
        #define TOPICO_PUBLISH “saidadosszillat” .
        #define ID_MQTT “Szill”

        e atualizei esses dados interface web feita por ti e mesmo assim não consegui conectar a rede.

        Ao passar os dados ao controlador inicialmente veio os seguintes erros:

        warning: espcomm_sync failed
        error: espcomm_open failed
        error: espcomm_upload_mem failed
        error: espcomm_upload_mem failed

        mas logo após tentar de novo, consegui carregar o código, conforme mensagem a seguir:

        Uploading 235920 bytes from C:\Users\rafae\AppData\Local\Temp\buildb891e3416cb23136a7af03139c3527b8.tmp/rele-teste-2.ino.ino.bin to flash at 0x00000000
        …………………………………………………………………….. [ 34% ]
        …………………………………………………………………….. [ 69% ]
        …………………………………………………………….. [ 100% ]

        Entretanto a mensagem de erro:
        “A conexão com o broker foi perdida”
        Continua sendo repetida continuamente.

        O que pode ser isso ?

  9. Ricardo - 16 de dezembro de 2016

    O meu conecta-se ao broker pelo serial mas pela interface web diz que a conexão com o broker foi perdida, Alguma sugestão? Grato.

  10. Bruno Aguiar - 16 de dezembro de 2016

    Boa noite Pedro Bertoleti,

    Muito obrigado pelo trabalho e esforço dedicados em publicar artigos tão bem feitos e tão didáticos. Gostaria de saber se o protocolo MQTT serve para trabalhar de maneira local?

    • Pedro Bertoleti - 16 de dezembro de 2016

      Bruno, boa tarde.

      Agradeço muito a leitura e feedback! É muito bom saber que os artigos estão sendo úteis! =]

      O MQTT pode ser usado e forma local se você disponibilizar, na sua rede local, uma máquina/servidor com um broker instalado. Para baixar e ver como instala um broker, acessa esse site: https://mosquitto.org/download/

      Atenciosamente,
      Pedro Bertoleti

  11. Ricardo Luis Bonizzi - 8 de dezembro de 2016

    Olá, tenho uma dúvida sobre a placa, está descrito que tem 10 portas digitais e 1 analógica, certo? Mas, me informaram que não é possível utilizar todas?
    Obrigado

  12. Felipe - 7 de dezembro de 2016

    Parabéns pelo trabalho.
    Foi de grande valia este trabalho.
    Gostaria de saber se posso aplicar este método no shield Ethernet W5100, tem algum tutorial.
    E sobre algum tutorial para criação de um servidor mqtt, procuro e não acho nada falando a respeito. Gostaria de implementar o meu próprio servidor, poderia me dar uma ajuda?

    Obrigado.

    • Pedro Bertoleti - 16 de dezembro de 2016

      Felipe, boa tarde.

      Obrigado pela leitura e pelos elogios. Eu nunca usei este Shield, mas ACHO que pode aplicar o MQTT com ele sem problema algum (pois o MQTT utiliza recursos simples de rede / protocolo TCP, coisas que com toda a certeza o Shield suportará).
      Quanto a criar um servidor MQTT, você pode baixar o Broker Mosquitto no site https://mosquitto.org/download/ e instalar na sua máquina/servidor/VPS (e, por consequência, utilizá-la como seu servidor MQTT particular). Nesta página tem instruções de como se instala e tudo mais =]

      Atenciosamente,
      Pedro Bertoleti

  13. Augusto Soares - 23 de novembro de 2016

    Srs, o código funcionou bem no nodemcu, mas ainda não consegui entender pq temos 2 tópicos se estamos publicando/controlando apenas uma variável que é o estado do LED.
    Eu não deveria ter apenas um tópico onde eu publicaria o estado do LED e assinaria o mesmo pra saber em que estado o LED está?
    Alguém me explica por favor! hehehehe

    • Pedro Bertoleti - 16 de dezembro de 2016

      Augusto, boa tarde.

      O porque de ter dois tópicos é para facilitar o entendimento (ao menos foi o que planejei), pois dessa forma pode-se ver separadamente tudo o que sai e o que chega nos tópicos.
      Você pode fazer da maneira que sugeriu (usar um só tópico) sem prolemas também.

      Atenciosamente,
      Pedro Bertoleti

  14. Artur Felipe Veloso - 20 de novembro de 2016

    Cara, primeiramente meu PARABÉNS, BELO PROJETO!!! Eratudo que eu queria saber!!!

    Bom, eu to em processo de construção do meu TCC 1, e eu gostaria de saber como posso contribuir para / com esse tipo de projeto?

    Mias uma dúvida, eu posso construir meu próprio site MQTT? Ou seja, eu posso fazer um site em que eu possa tanto enviar como receber dados do node, e cadastra-los em um Banco de dados possibilitando assim acessos via REST por exemplo?? Isso seria possível? se sim, como?

    Qualquer coisa, entra em contato cmg : arturfdasveloso@gmail.com ou manda ai teus contatos.

    De já, super agradecido!!! Grande abraço.

    • Pedro Bertoleti - 22 de novembro de 2016

      Arthur, boa tarde.

      Muito obrigado pelo feedback! Fico feliz em saber que te ajudei de alguma maneira.
      Quanto a contribuir com o projeto, o que você quis dizer? Evoluir o projeto e compartilhar conosco? Desculpa, é que não entendi muito bem.

      Quanto a sua segunda pergunta, sim, você pode construir seu próprio broker MQTT. Para fazer o que você deseja (broker, banco de dados e tudo mais), você precisará instalar em sua máquina todas essas coisas e disponibiliza-las em rede (dica: pesquise por broker Mosquitto e um pack de software/serviços chamado XAMPP) ou até mesmo comprar acesso a uma VPS (máquina virtual na Internet) instalar as coisas nela e deixar tudo remoto. Se não fui claro, é só falar que explico novamente.

      Atenciosamente,
      Pedro Bertoleti

  15. Michel Martinez - 18 de setembro de 2016

    Boa tarde, muito obrigado pelo post!
    Consegui rodar e o serial consta como conectado ao MQTT, mas utilizando a página HTML não consigo conectar/controlar o projeto, alguma dica?

  16. Erick Vilela - 15 de setembro de 2016

    Excelente material, entretanto estou com algumas dificuldades na conexão com o servidor. Verifiquei pelo serial monitor se a conexão com a placa foi bem sucedida, também vi que a conexão com o Broker MQTT do iot.eclipse.org também ocorreu normalmente, fiquei apenas tendo a mensagem de “- Estado da saida D0 enviado ao broker!” na serial, mas quando executo o .html, não tenho resposta do servidor. Já fiz as alterações de tópico de publish e subscribe, inseri um ID MQTT aleatório, inclusive alterei até a interface html o preenchimento dos tópicos e o problema permanece. Como proceder?

  17. Planta IoT com ESP8266 NodeMCU - Parte 1 | Blog FILIPEFLOP - 24 de agosto de 2016

    […] mais populares para prototipação de soluções IoT. Conforme já mostrado neste blog, o NodeMCU funciona perfeitamente integrado ao MQTT, possibilitando controle e monitoramento remoto. Neste post, será mostrado como integrar o NodeMCU […]

  18. Diego Nunes - 23 de agosto de 2016

    Primeiramente, Parabéns pelo trabalho Pedro Bertoleti. Gostaria de saber se eu consigo ter acesso ao broker, ou existe alguma ferramenta que me possibilite monitorar os dados recebidos no broker do Nodemcu em tempo real? Desde já agradeço.

    • Pedro Bertoleti - 24 de agosto de 2016

      Diego, boa noite.

      Primeiramente, muito obrigado pela leitura e pelo elogio.
      Quanto a acesso de dados ao broker, o que pode ser feito neste caso é você utilizar um cliente MQTT para computador (MQTTLens, por exemplo), dar subscribe / se subescrever em um determinado tópico que deseja obter informações e monitorar.
      Isso é possível pois no MQTT não há limites teóricos de número de clientes subescritos a um determinado tópico (da mesma forma que não há limites de clientes publicando em um mesmo tópico).

      Se você não entendeu, avise novamente por favor que explicarei de outra forma.

      Atenciosamente,
      Pedro Bertoleti

      • Diego Nunes - 24 de agosto de 2016

        Prezado Pedro,

        Perfeito, consegui exatamente o que queria. Desconhecia essa ferramenta MQTTlens, simples porém, robusta para testes. Mais outra coisa amigo, teu websocket não executa na minha máquina, o mesmo não consegue conectar ao servidor, nem mesmo exibe mensagem, existe algum plugin ou app que deva estar instalado na máquina para o mesmo conseguir conectar. Mais uma vez, parabéns pelo artigo e pelo respaldo para com os comentários.

        • Pedro Bertoleti - 24 de agosto de 2016

          Diego, este problema relatado com o websocket no seu caso está me parecendo algum bloqueio de firewall ou algo do gênero.
          Você está com acesso a porta 1883 liberado no computador que está utilizando?

          Atenciosamente,
          Pedro Bertoleti

          • Diego Nunes - 24 de agosto de 2016

            Pedro,

            O Firewall está desativado, já havia instalado o Mosquitto anteriormente, serviço está rodando, o netstat -an retorna que a porta 1883 (TCP), está LISTENING (Aberta para receber conexões), acredito que não seja firewall, alguma outra sugestão? Obrigado pela atenção.

    • Pedro Bertoleti - 25 de agosto de 2016

      Diego, você está tentando acessar um broker que está rodando na sua máquina ou o broker iot.eclipse.org? Se está tentando acessar um broker que está rodando na sua máquina, o websocket (mais precisamente, o arquivo tmo.js dele) precisa ser modificado.

  19. Alex Muniz - 18 de agosto de 2016

    Bom dia. Gostaria de agradecer a sua boa vontade em compartilhar o seu conhecimento com todos. Suas publicações sempre tem me ajudado muito. Amigo eu programei o nodeMCU, porém não consegui me conectar ao servidor. Eu apenas executei a página que está em anexo e tentei me conectar para depois poder ligar e desligar o led. Eu deveria fazer algo mais? desde já muitooooooo obrigado.

    • Pedro Bertoleti - 18 de agosto de 2016

      Alex, boa tarde.

      Primeiramente, muito obrigado pelo feedback. É uma satisfação saber que minhas publicações te ajudaram!
      Quanto ao erro ocorrido, há algumas possibilidades. Vou listá-las abaixo:

      – Verifique se seu nodemcu se conectou corretamente a rede wifi (esta informação aparece no Serial Monitor)
      – Verifique se seu nodemcu se conectou corretamente ao broker MQTT (esta informação aparece no Serial Monitor)
      – Se você alterou os tópicos de publish e subscribe, verifique se na página os tópicos estão iguais aos do código gravado no NodeMCU
      – O ID MQTT precisa ser alterado 9coloque algo único pra você ou “aleatório”. Se deu ID MQTT coincidir com algum outro já conectado ao Broker, haverá problemas.

      Por favor, verifique estas questões e retorne dizendo se conseguiu fazer funcionar.

      Atenciosamente,
      Pedro Bertoleti

  20. Carlos Kwiek - 26 de julho de 2016

    No meu canal do youtube fiz um vídeo usando esta aplicação https://www.youtube.com/watch?v=y5fWZvFVfxQ&feature=youtu.be

    Usei um modulo rele, e uma lâmpada de LED para a aplicação, tanto na descrição como no vídeo deixei claro de quem são os créditos e a autoria, bem como o link para baixar a aplicação.

    Abs.

    Carlos Kwiek.

  21. Carlos Kwiek - 25 de julho de 2016

    Parabéns Pedro,

    Praticamente foi baixar a interface, copiar e colar o código, e colocar pra funcionar, tanto na rede local como na rede externa funcionou sem problemas.

    Sobre o fato da logica invertida da porta, não tem como editar o arquivo para que os botões fiquem com nome liga e desliga inversos na interface para não ficar ligando quando se desliga e vice versa?

    Obrigado.

    Grande abraço!

    Eng. Carlos Kwiek.

    • Pedro Bertoleti - 26 de julho de 2016

      Carlos, bom dia.

      Primeiramente, muito obrigado pelo feedback!
      Quanto a sua resposta, sim, é possível. Acredito até que a melhor solução é dessa forma que você disse (ou seja, alterando na interface os botões).

      Atenciosamente,
      Pedro Bertoleti

  22. Fabricio - 17 de julho de 2016

    Eu tenho uma dúvida, se eu quisesse fazer isso também de forma local? teria como eu ter um servidor, que no caso seria um broker, localmente, sou iniciante e se eu estiver falando besteira, perdoe-me.. Por algum motivo perca a conexão com a internet, eu localmente conseguiria ainda assim ver as mensagens postadas..

  23. Como controlar motor dc com ESP8266 NodeMCU | Blog FILIPEFLOP - 22 de junho de 2016

    […] Arduino convencional, conforme mostrado no post Como Programar o NodeMCU com IDE Arduino e no post NodeMCU com MQTT. Sendo assim, neste post iremos abordar como ler Inputs e como escrever em Outputs, e você […]

  24. Ismael - 9 de junho de 2016

    Boa tarde a todos sou novo aki.

  25. Christian D'Aquino - 31 de maio de 2016

    Pedro,

    Realmente muito bom o tutorial. Como você disse acima, eu espero ver novos posts sobre MQTT. Muito interessante o tema. Mas fiquei com uma dúvida: onde é definido o “ID” do nodeMCU que está enviando/recebendo as mensagens? Isso seria o TOPICO_SUBSCRIBE e o TOPICO_PUBLISH? Minha dúvida é, onde eu faço a definição de um cliente específico, de modo que eu saiba que está enviando ou recebendo a mensagem, caso eu tenha mais de um cliente conectado?

    • Christian D'Aquino - 31 de maio de 2016

      Outra coisa, no código você definiu o led azul embutido no NodeMCU como sendo o D0. No NodeMCU que eu tenho aqui o led azul está ligado ao D4 (GPIO2). Troquei no código e funcionou.

      • Pedro Bertoleti - 31 de maio de 2016

        Christian, boa tarde.

        Primeiramente, muito obrigado pelo feedback. Sobre o ID do MQTT, este está definido no código em:

        #define ID_MQTT “HomeAut”

        Este ID serve para o broker gerenciar sua conexão / conexão de qualquer cliente com ele. Ou seja, cada cliente deve ter um ID único no broker. Se isso não for obedecido, um dos clientes (no caso, o que já estava conectado) será desconectado do servidor abruptamente.

        Quanto aos tópicos, via de regra estes podem se repetir, pois o MQTT funciona de forma que pode-se haver N publishers e N subscribers para um mesmo tópico.
        PORÉM, se você publicar informação em um tópico “alheio” (diferente do seu), quem subescreve este tópico irá “escutar” sua mensagem. No caso do projeto deste post em específico, isso significa que se você usar o mesmo nome de tópico de publish que outra pessoa, poderá controlar o LED da placa dela.

        Portanto, para rodar o exemplo com segurança:
        – Alterar o ID MQTT (de preferencia para algo aleatório ou incomum
        – Alterar os tópicos de publish e subscribe na interface web e no sketch

  26. Angelo José Roncali da Silva - 31 de maio de 2016

    Excelente artigo!!
    Bem didático!!
    Não vejo a hora de ter novos artigos sobre MQTT!!!

  27. Joao Goris - 30 de maio de 2016

    Parabéns pelo belo tutorial. Muito didático e esclarecedor. São pessoas como você que nos dão animo a proseguir neste ramo. Me abriu um belo caminho.

    • Pedro Bertoleti - 30 de maio de 2016

      João, boa noite.

      Seu comentário me motiva cada vez mais a continuar este trabalho de escrever e ensinar o pouco que sei. É muito gratificante mesmo ler isso! Muito obrigado!

  28. Franklin Bonfim - 30 de maio de 2016

    Artigo muito bom!
    Estava procurando por algo assim.

  29. Adriano Czocher - 30 de maio de 2016

    Parabéns pela iniciativa, estava lendo sobre o assunto, que ao meu ver achei muito interessante.

  30. Pedro Correia - 30 de maio de 2016

    Bom post. Sabe me dizer se existe uma quantidade máxima de mensagens que eu posso mandar diariamente ?

    • Pedro Bertoelti - 30 de maio de 2016

      Pedro, bom dia.

      Primeiramente, obrigado por ler e pelo comentário.
      O protocolo MQTT em si não coloca limites (tanto de conexões ao broker por device quanto em tópicos subescritos / publicados e número de mensagens). Portanto, fica a cargo do broker (o servidor MQTT) gerenciar este tipo de coisa (pois ele é quem gerenciará as conexões e “sabe até onde aguenta”).
      Sendo assim, o limite deve ser consultado / buscado no broker (cada broker tem o seu limite).

      Porém, sendo prático, eu já deixei sistemas embarcados enviando dados segundo a segundo no broker iot.eclipse.org por dias e não tive problemas (portanto, se pretende algo similar, não encontrará problemas).

Deixe uma resposta