Robô IoT com ESP8266 NodeMCU

Robô IoT com ESP8266 NodeMCU

Nosso projeto de Robô IoT com ESP8266 NodeMCU vai juntar os tópicos que foram vistos nos posts NodeMCU com MQTT e Como controlar motor dc com ESP8266 NodeMCU. O NodeMCU é uma placa / plataforma muito boa para prototipação rápida de soluções IoT.

Detalhe NodeMCU

Junto com o MQTT, vamos construir um robô totalmente controlado pela Internet à partir de um navegador web comum!

Descrição do projeto Robo IoT com ESP8266 NodeMCU

O projeto deste post consiste em um robô equipado com um módulo ESP8266 NodeMCU, controlado via Internet por MQTT. Tal robô utilizará duas rodas para locomoção, sendo capaz de se movimentar em três direções: para frente, para a esquerda e para a direita.

Utilizar MQTT para este controle permitirá:

  • Controle do robô IoT com ESP8266 NodeMCU a partir de uma página web
  • Controle do robô de qualquer lugar do planeta que possua conexão com a Internet
  • Possibilidade de controlar o robô a partir de qualquer dispositivo conectado à Internet(exemplo: smartphones, tablets e computadores), com qualquer sistema operacional.

O diagrama de como o robô IoT com ESP8266 NodeMCU será controlado pode ser visto na figura abaixo:

 Esquema Robô IoT com ESP8266 NodeMCU

Na comunicação MQTT para controle do robô, o payload da mensagem informará qual ação o robô deve tomar. As ações possíveis podem ser visualizadas na tabela abaixo:

Tabela Ações Robô IoT

A forma de execução de um comando / ação é a seguinte: o robô vai executar indefinidamente o último comando recebido até que seja recebido um novo comando válido.

Material utilizado no projeto Robô IoT com ESP8266 NodeMCU

Para construir este robô, será necessário o seguinte material:

 

Esquema elétrico do Robô IoT com ESP8266 NodeMCU

Na figura abaixo está o esquema elétrico do Robô IoT:

Esquemático Robô IoT com ESP8266 NodeMCU

Programação do ESP8266 NodeMCU

Abaixo, segue o código-fonte completo do projeto.
Importante: leia atentamente os comentários do código!

#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 "MQTTRoboIoTFilipeFlopEnvia"     //tópico MQTT de escuta
#define TOPICO_PUBLISH   "MQTTRoboIoTFilipeFlopRecebe"    //tópico MQTT de envio de informações para Broker
#define ID_MQTT  "RoboIotFilipeFlop01"     //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

//defines - motores
#define MOTOR_DIRETO     D0
#define MOTOR_ESQUERDO   D1

// WIFI
const char* SSID = " ";     //Coloque aqui o SSID / nome da rede WI-FI que deseja se conectar
const char* PASSWORD = " "; //Coloque aqui a 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 EstadoMotorDireto = '0';  //variável que armazena o estado atual do motor da direita
char EstadoMotorEsquerdo = '0';  //variável que armazena o estado atual do motor da esquerda
 
//Prototypes
void initSerial();
void initWiFi();
void initMQTT();
void reconectWiFi(); 
void mqtt_callback(char* topic, byte* payload, unsigned int length);
void VerificaConexoesWiFIEMQTT(void);
void InitOutputs(void);

/* 
 *  Implementações das funções
 */
void setup() 
{
    //inicializações:
    InitOutputs();
    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- Robo IoT com NodeMCU -----");
    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:
    //-----------------------------------------------------
    //     Mensagem recebida       |       Ação tomada
    //-----------------------------------------------------
    //             F               | O robô vai para frente
    //             D               | O robô vai para a direita
    //             E               | O robô vai para a esquera
    //             P               | O robô para imediatamente
    
    if (msg.equals("F"))
    {
        //para ir para frente, os dois motores são ligados
        digitalWrite(MOTOR_DIRETO, HIGH);
        digitalWrite(MOTOR_ESQUERDO, HIGH);
 
        EstadoMotorDireto = '1';
        EstadoMotorEsquerdo = '1';
    }

    if (msg.equals("D"))
    {
        //para ir para a direita, somente o motor da esquerda é ligado
        digitalWrite(MOTOR_DIRETO, LOW);
        digitalWrite(MOTOR_ESQUERDO, HIGH);
 
        EstadoMotorDireto = '0';
        EstadoMotorEsquerdo = '1';
    }

    if (msg.equals("E"))
    {
        //para ir para a esquerda, somente o motor da direita é ligado
        digitalWrite(MOTOR_DIRETO, HIGH);
        digitalWrite(MOTOR_ESQUERDO, LOW);
 
        EstadoMotorDireto = '1';
        EstadoMotorEsquerdo = '0';
    }

    if (msg.equals("P"))
    {
        //para parar, os dois motores são desligados
        digitalWrite(MOTOR_DIRETO, LOW);
        digitalWrite(MOTOR_ESQUERDO, LOW);
 
        EstadoMotorDireto = '0';
        EstadoMotorEsquerdo = '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)
{
    char EstadosMotores[3];

    EstadosMotores[0] = EstadoMotorDireto;
    EstadosMotores[1] = '-';
    EstadosMotores[2] = EstadoMotorEsquerdo;

    MQTT.publish(TOPICO_PUBLISH, EstadosMotores);
    Serial.println("- Estados dos motores enviados ao broker!");
    delay(1000);
}

//Função: inicializa os outputs em nível lógico baixo (desliga os dois motores)
//Parâmetros: nenhum
//Retorno: nenhum
void InitOutputs(void)
{
    pinMode(MOTOR_DIRETO, OUTPUT);
    pinMode(MOTOR_ESQUERDO, OUTPUT);
    
    digitalWrite(MOTOR_DIRETO, LOW);          
    digitalWrite(MOTOR_ESQUERDO, LOW);          
}

//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();
}

Interface web

Para controlar o robô IoT com ESP8266 NodeMCU por MQTT, foi desenvolvida uma interface web. Você pode baixá-la clicando aqui.

Assim como foi feito no artigo sobre MQTT no NodeMCU, 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:

Interface Web NodeMCU

Monte também o seu robô IoT e boa diversão!

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

7
Robô IoT com ESP8266 NodeMCU
10 votos, 4.60 classificação média (92% 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

17 Comentários

  1. anderson - 11 de fevereiro de 2017

    Vc usou esse programa na IDE do arduino?

  2. Joel Ribeiro - 12 de novembro de 2016

    Boa noite, topei fazer esse projeto . Achei bem interessante, agradeço por terem disponibilizado. Gostaria de saber quais os resistores (intensidades) deverão ser utilizadas !

  3. Pedro Meirelles - 2 de novembro de 2016

    Olá, Pedro!
    Observando o código do projeto, creio que houve uma pequena inversão na definição dos tópicos para publicação e subscribe. Nas linhas 6 e 7, está assim:
    #define TOPICO_SUBSCRIBE “MQTTRoboIoTFilipeFlopEnvia” //tópico MQTT de escuta
    #define TOPICO_PUBLISH “MQTTRoboIoTFilipeFlopRecebe” //tópico MQTT de envio de informações para Broker

    Pergunto eu: não seria o contrário?

    #define TOPICO_SUBSCRIBE “Recebe” //tópico MQTT de escuta
    #define TOPICO_PUBLISH “Envia” //tópico MQTT de envio de informações para Broker

    Ou seja, “Recebe” para o SUBSCRIBE e “Envia” para o PUBLISH ?

    Sei que o que está entre aspas pode ser alterado na interface web (vc até recomenda isso), mas a lógica não seria essa?

    Parabéns pelo seu trabalho na FilipeFlop! Estou começando com um Arduino (comprei um Mega2560 exatamente hoje) e gosto muito dos seus posts aqui no Blog.

    Atenciosamente,

    Pedro

    • Pedro Bertoleti - 3 de novembro de 2016

      Pedro, boa noite.

      Primeiramente, muito obrigado pela leitura e pelos elogios! Fico feliz que você curtiu o projeto!

      No caso dos tópicos, a “referência” de nome dos mesmos é a interface web (ou seja, quando a interface web envia algo, o nodemcu deve escutar e vice-versa). Por isso, no programa do NodeMCU, já esta impressão de que as coisas estão ao contrário.
      Ficou claro? Se não ficou, me avisa que explico de outra forma.

      Atenciosamente,
      Pedro Bertoleti

  4. Paulo Silveira - 5 de setembro de 2016

    Olá, comprei o esp8266 e fiz a conexão conforme o post e ocorreu tudo bem, só que na interface aparece somente a roda esquerda e centralizada. Não passei o pente fino no código ainda, mas fica o comentário construtivo e se rodar certinho com vocês me avisa.
    Parabéns pelo material e pela entrega também que foi muito rápida.

    • Pedro Bertoleti - 24 de outubro de 2016

      Paulo, boa tarde.

      Muito obrigado pelo elogio, pela leitura e desculpe pela demora. Eu verifiquei novamente aqui e a interface rodou sem problemas.
      Para melhor entender o problema, por favor responda:
      1) Qual navegador utilizou?
      2) Abriu no celular ou computador?

      Atenciosamente,
      Pedro Bertoleti

    • Ronaldo - 3 de março de 2017

      Após executar no navegador (Safari ou Chrome) em ambos não aparecem as 2 rodas realmente!

  5. Augusto Fernandes Vellozo - 25 de agosto de 2016

    Parabéns Pedro pelo post. Vc sabe se dá para colocar mais um sensor de distância e dois leds neste robô? Ou seja, qtos GPIOs tem disponíveis ainda neste robô?
    Grato,
    Augusto

    • Pedro Bertoleti - 26 de agosto de 2016

      Augusto, boa tarde.

      Obrigado pela leitura e pelo elogio. Quanto às suas perguntas:

      – Dois LEDs com certeza é possível colocar
      – O sensor de distância eu nunca utilizei com o NodeMCU. Sendo assim, infelizmente não sei te dizer se funcionaria 100%.
      – Ainda há 9 GPIOs disponíveis. Ou seja, dá pra acrescentar algumas funcionalidades neste robô sem problemas.

      Atenciosamente,
      Pedro Bertoleti

  6. Guilherme - 17 de agosto de 2016

    Boa noite!

    Gostaria de saber qual é o comando para utilizar o Motor de vibração no arduino uno? (comando para fazer ele vibrar)
    esse motor = http://www.filipeflop.com/pd-361d89-motor-de-vibracao-1027.html?ct=&p=1&s=1

    Obrigado

    • Adilson Thomsen - 17 de agosto de 2016

      Boa tarde Guilherme,

      Esse motor não tem comando, você aplica tensão nos terminais e ele começa a vibrar. No Arduino, você pode controlar a vibração ligando e desligando uma porta digital, por exemplo.

      Abraço!

      Adilson – Equipe FILIPEFLOP

  7. Filipe Macedo - 15 de agosto de 2016

    Ótima série de posts Pedro, vai agregar bastante a comunidade!

Deixe uma resposta