ESP8266: Controle o NodeMCU com um App (IOS e Android)

O NodeMCU é uma placa muito prática. Com ela vem tudo que é necessário para conectar o ESP8266 ao computador e fazer seu protótipo sem complicações.

“Tudo” significa um conversor Serial USB, um regulador de tensão com corrente suficiente para o ESP8266, circuito que configura automaticamente o modo de programação – quem já usou o ESP8266 sabe como pode ser chato isso – e conectores com espaçamento padrão para protoboard.

Recentemente fiz um projeto em que precisava enviar texto para o ESP8266 a partir do celular. Entre as alternativas acabei encontrando um app chamado Blynk.

O Blynk tem um monte de elementos (widgets) que podem ser selecionados e adicionados à tela. Tem até uma Zebra que é usada para controlar leds RGB!!

Para completar, é necessário importar na IDE do Arduino a biblioteca fornecida aqui. A forma mais rápida é usar o menu do Arduino para “importar biblioteca ZIP”. O Blynk pode funcionar com diversas placas, mas só testei com o NodeMCU.

 

Enviando texto

Vamos usar um widget chamado terminal, nele podemos digitar comandos e textos que serão “entregues” no ESP8266 e também ver as respostas enviadas pelo programa.

 

 

No App é tudo muito rápido e fácil. O que precisa ser configurado é o canal virtual de comunicação. Na tela de ajustes vá onde está marcado PIN. Para meu programa usei o canal V1. (existem 128 canais virtuais, acho que é suficiente para a maioria das necessidades)

 

No microcontrolador

Para este artigo fiz um sketch de demonstração que recebe o texto do terminal, faz um eco pra tela do app para confirmar que recebeu e – se o texto recebido for equivalente a um comando válido – liga ou desliga um de três leds.

O sketch completo é assim:

const int pinoVM = 14; // pino onde está ligado o led vermelho (D5)
const int pinoAM = 12; // pino onde está ligado o led amarelo  (D6)
const int pinoVD = 13; // pino onde está ligado o led verde    (D7)

#define BLYNK_PRINT Serial    // Manda debug para a porta Serial

#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>

// Pegue o Auth Token no App Blynk.
// Em Project Settings (icone da "porca").
char auth[] = "CODIGO OBTIDO DENTRO DO APP";

// conecte o terminal serial virtual em Pin V1
WidgetTerminal terminal(V1);


void setup()
{
  // configura os pinos como saida
  pinMode(pinoVM, OUTPUT);
  pinMode(pinoAM, OUTPUT);
  pinMode(pinoVD, OUTPUT);

  // configura a porta Serial
  Serial.begin(9600);

  // configura a conexão do NodeMCU com
  // o App Smart Config
  WiFi.mode(WIFI_STA);
  int cnt = 0;
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    if (cnt++ >= 10) {
      WiFi.beginSmartConfig();
      while (1) {
        delay(1000);
        if (WiFi.smartConfigDone()) {
          Serial.println();
          Serial.println("SmartConfig: Successo");
          break;
        }
        Serial.print("|");
      }
    }
  }

  WiFi.printDiag(Serial);

  Blynk.config(auth);
}

// adaptado do exemplo do blynk
// Esta função conecta o pino virtual aos dados
BLYNK_WRITE(V1) // estamos usando o pino V1
{
  // Manda dados de volta para o terminal no App
  terminal.print("Recebido: ");
  terminal.write(param.getBuffer(), param.getLength());
  terminal.println();
  // para garantir que tudo seja enviado:
  terminal.flush();

  // faz um eco do que foi recebido na Serial
  String recebido = param.asStr();
  Serial.print("\nRecebido: ");
  Serial.println(recebido);

  // transforma em minúsculas para facilitar a comparação
  recebido.toLowerCase();

  // compara recebido com comandos esperados
  if (recebido.equals("liga vm")) digitalWrite(pinoVM, HIGH);
  if (recebido.equals("desl vm")) digitalWrite(pinoVM, LOW);

  if (recebido.equals("liga am")) digitalWrite(pinoAM, HIGH);
  if (recebido.equals("desl am")) digitalWrite(pinoAM, LOW);

  if (recebido.equals("liga vd")) digitalWrite(pinoVD, HIGH);
  if (recebido.equals("desl vd")) digitalWrite(pinoVD, LOW);
}

void loop()
{
  // aqui é importante chamar a função abaixo com frequência
  // se o seu código for mais complexo, evite o uso de "delay"
  Blynk.run();
}

Vamos por partes!

O Sketch tem uma estrutura modular. Boa parte do que está nele veio dos exemplos da biblioteca.

Ele começa “combinando” em que pinos cada led está ligado. Eu tenho um NodeMCU (compre aqui)

Os pinos do ESP8266 estão ligados nele assim:

 

Por facilidade de acesso ao pino GND, escolhi os pinod D5, D6 e D7 para ligar os leds. Usei un resistor de 470 ohms em cada saída e liguei ao positivo dos leds. todos os negativos liguei ao GND

(falta fazer diagrama)

No programa, fica definido assim:

const int pinoVM = 14; // pino onde está ligado o led vermelho (D5)
const int pinoAM = 12; // pino onde está ligado o led amarelo  (D6)
const int pinoVD = 13; // pino onde está ligado o led verde    (D7)<br>

Note que usei os números de GPIO. Fazendo assim fica muito mais prático para alterar os pinos usados no programa, basta mudar aqui e tudo pronto!

Agora vem a parte que configura a biblioteca do Blynk e define que vamos usar um widget de terminal:

#define BLYNK_PRINT Serial    // Manda debug para a porta Serial

#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>

// Pegue o Auth Token no App Blynk.
// Em Project Settings (icone da "porca").
char auth[] = "CODIGO OBTIDO DENTRO DO APP";

// conecte o terminal serial virtual em Pin V1
WidgetTerminal terminal(V1);

Dentro do setup (aquela parte do código que é executada só quando a placa é energizada) configuramos os pinos dos leds como saídas, inicializamos a serial e em seguida configuramos e fazemos a conexão com o WIFI.

Primeiro os pinos como saída e a Serial:

  // configura os pinos como saida
 pinMode(pinoVM, OUTPUT);
 pinMode(pinoAM, OUTPUT);
 pinMode(pinoVD, OUTPUT);

 // configura a porta Serial
 Serial.begin(9600);

Agora a parte que já veio pronta no exemplo de SmartConfig do Blynk:

  // configura a conexão do NodeMCU com
  // o App Smart Config
  WiFi.mode(WIFI_STA);
  int cnt = 0;
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    if (cnt++ >= 10) {
      WiFi.beginSmartConfig();
      while (1) {
        delay(1000);
        if (WiFi.smartConfigDone()) {
          Serial.println();
          Serial.println("SmartConfig: Successo");
          break;
        }
        Serial.print("|");
      }
    }
  }

  WiFi.printDiag(Serial);

  Blynk.config(auth);

Esta parte começa dizendo ao ESP8266 que ele vai se conectar a uma rede WIFI e não gerar sua própria rede (WIFI_STA).

Em seguida define uma variável para contar o número de tentativas de conexão (cnt).

Dentro do loop while – quer dizer “enquanto” – o codigo é executado até que o status do wifi seja WL_CONNECTED – conectado.

Para não fazer tentativas consecutivas muito rapidamente e para evitar travar a rede, existe um delay de meio segundo entre cada tentativa (500 milisegundos).

Se a contagem for maior que 10, ou seja, 10 intervalos de meio segundo = 5 segundos, e o wifi não estiver conectado ainda a alguma rede que possa já estar armazenada na memória, o programa entra em outro loop while, do qual ele só sai pela instrução “break”  quando o SmartConfig for feito com sucesso.

SmartConfig é um jeito de configurar a rede wifi ESP8266 através de seu celular com um app.

Finalmente, após conectar, o programa manda para o terminal Serial as informações da conexão feita (inclusive senha usada) e chama o função que autentica o Blynk usando a chave gerada dentro do app do Blynk.

Temos então uma declaração retirada diretamente do exemplo do terminal. Pode parecer estranho que esta função não começa com “void” ou “int”, porém ela já vem pré-definida desta forma na biblioteca (é de fato uma macro do pré compilador, coisa um pouco avançada)

// adaptado do exemplo do blynk
// Esta função conecta o pino virtual aos dados
BLYNK_WRITE(V1) // estamos usando o pino V1

Dentro desta “função” colocamos tudo que vai acontecer quando chegar algum texto.

Fazemos o eco no terminal dentro do App, enviando também a palavra “Recebido”:

  // Manda dados de volta para o terminal no App
 terminal.print("Recebido: ");
 terminal.write(param.getBuffer(), param.getLength());
 terminal.println();
 // para garantir que tudo seja enviado:
 terminal.flush();

E também para a porta Serial, para nos ajudar a fazer o debug do sketch:

 // faz um eco do que foi recebido na Serial
 String recebido = param.asStr();
 Serial.print("\nRecebido: ");
 Serial.println(recebido);

E finalmente comparamos com os 6 comandos que inventei para os leds e se coincidir, liga ou desliga os leds. tudo recebido é transformado em letras minúsculas antes para evitar confusão na comparação (tem gente que gosta de BERRAR quando digita…)

  // transforma em minúsculas para facilitar a comparação
 recebido.toLowerCase();

 // compara recebido com comandos esperados
 if (recebido.equals("liga vm")) digitalWrite(pinoVM, HIGH);
 if (recebido.equals("desl vm")) digitalWrite(pinoVM, LOW);

 if (recebido.equals("liga am")) digitalWrite(pinoAM, HIGH);
 if (recebido.equals("desl am")) digitalWrite(pinoAM, LOW);

 if (recebido.equals("liga vd")) digitalWrite(pinoVD, HIGH);
 if (recebido.equals("desl vd")) digitalWrite(pinoVD, LOW);

Por fim, o loop que todo programa da IDE Arduino precisa ter. Como todo o código é tratado somente no evento de mensagem que chega, não é necessário colocar nenhuma instrução dentro dele além de  Blynk.run();

Em programas mais complexos, pode ser necessário colocar código ou chamar funções aqui.

Neste caso, evite usar a função delay e ficar sem chamar  Blynk.run(); por muito tempo. Não sei dizer quanto tempo, mas quanto mais rapidamente, melhor a resposta da comunicação com o app.

void loop()
{
 // aqui é importante chamar a função abaixo com frequência
 // se o seu código for mais complexo, evite o uso de "delay"
 Blynk.run();
}

Este exemplo pode ser um bom ponto de partida para projetos mais complexos.

Se tiver alguma dúvida, chame nos comentários que vamos complementar a informação.

 

Saudações, Fazedores!

 

Onde comprar?

Compre Arduino, componentes eletrônicos e ferramentas na FilipeFlop. Os preços são ótimos, a agilidade é matadora e as entregas são feitas para todo o Brasil. O Fazedores e a FilipeFlop estão juntos para fomentar a cultura maker no Brasil.