Tutorial: Controlando Relés via Wi-Fi e pela Internet

Olá Garagistas,

Dando prosseguimento à nossa série de tutoriais de automação utilizando a placa AutomationBoard, iremos mostrar neste tutorial como utilizar o módulo ESP8266 para incluir a comunicação via Wi-Fi com a placa. A conexão é bem fácil e a instalação dispensa a utilização de cabos de rede ou outros módulos. Outra vantagem dessa configuração é que o acesso pode ser feito através de celulares, tablets ou PCs, sem a necessidade de instação de programas ou aplicativos.

Por que usar a AutomationBoard para sistemas de automação?

A AutomationBoard facilita muito o trabalho, pois traz algumas vantagens importantes:

- Dispensa o uso de fontes porque pode ser alimentada direto da rede elétrica

- Já vem com relés na própria placa, facilitando a montagem e instalação

- Permite o uso de shields, conexão de sensores e módulos com facilidade

- Placa protegida contra ruídos e interferências

Em especial, a vantagem que usaremos nesse tutorial:

- Permite a conexão de dispositivos 3.3V sem a necessidade de reguladores ou conversores de nível lógico

Ou seja, o módulo ESP8266 precisa ser alimentado com 3.3V, e a comunicação com ele não pode ser feita diretamente porque ele não é tolerante a 5V. Mas a AutomationBoard já tem conversores e regulador na placa (nos headers para XBee), permitindo que o módulo seja conectado diretamente, bastando para isso, alguns jumpers.

Então, vamos colocar a mão na massa!

Materiais

1x Placa AutomationBoard (incluir conversor e cabo com plug de tomada)

1x Módulo ESP8266-01

5x Jumpers M/F

Abaixo, você poderá conferir como as ligações devem ser feitas. Veja como é simples.

Utilizamos pinos da AutomationBoard que já possuem conversor de nível lógico (5V-3.3V), e que estão conectados aos pinos RX/TX do Arduino UNO montado internamente na placa. Assim, não é possível utilizar o módulo conversor USB/Serial e o ESP8266 ao mesmo tempo. Você precisa passar a programação para a placa e depois conectar o ESP8266. Se desejar, você pode manter todas as ligações, mas desligar o Vcc do módulo ESP8266 sempre que enviar um novo código à placa.

Abaixo segue o código para este tutorial. Ele cria um webserver utilizando comandos AT do firmware que já vem de fábrica com o ESP8266-01.

Programação

  1. #include <SoftwareSerial.h>
  2.  
  3. #define DEBUG false        // Se "true" o codigo printa a resposta do modulo a cada operacao
  4. #define rele1_pino 5       // Pino conectado ao rele 1
  5. #define rele2_pino 6
  6. #define rele3_pino 7
  7. #define rele4_pino 8
  8.  
  9.  
  10. //########## MUDE AQUI PARA OS PARAMETROS DA SUA REDE WIFI #################
  11. String meu_IP = "192.168.0.142"; // Escolha um IP compativel com sua rede local
  12. String minha_SSID = "MinhaRedeWiFi"; // SSID da sua rede wifi
  13. String minha_senha = "MinhaSenhaWiFi"; // senha da sua rede wifi
  14. //##########################################################################
  15.  
  16.  
  17. SoftwareSerial Debug(10, 11); // Cria serial em 10 e 11 para debug. Permite leitura das respostas do modulo
  18.  
  19. bool rele1 = false;        // Estado do rele. true/ligado ou false/desligado
  20. bool rele2 = false;
  21. bool rele3 = false;
  22. bool rele4 = false;
  23.  
  24.  
  25. void setup()
  26. {
  27.   pinMode(rele1_pino, OUTPUT);      // Define pino como saida
  28.   pinMode(rele2_pino, OUTPUT);
  29.   pinMode(rele3_pino, OUTPUT);
  30.   pinMode(rele4_pino, OUTPUT);
  31.  
  32.   Debug.begin(115200);
  33.   Serial.begin(115200); // your esp's baud rate might be different
  34.  
  35.   sendData("AT+RST\r\n", 3000, DEBUG); // reseta o modulo
  36.   sendData("AT+CWMODE=1\r\n", 1000, DEBUG); // configura o modulo como station
  37.   sendData("AT+CWJAP=\"" + minha_SSID + "\",\"" + minha_senha + "\"\r\n", 10000, DEBUG); // loga na rede wifi
  38.   sendData("AT+CIPSTA=\"" + meu_IP + "\"\r\n", 1000, DEBUG); // Define um endereco de IP para o modulo
  39.   sendData("AT+CIFSR\r\n", 3000, DEBUG); // Informa endereco de IP
  40.   sendData("AT+CIPMUX=1\r\n", 1000, DEBUG); // Configura para aceitar mais de uma conexão por vez.
  41.   sendData("AT+CIPSERVER=1,80\r\n", 1000, DEBUG); // Habilita servidor na porta 80. O modulo passa a responder nessa porta
  42. }
  43.  
  44.  
  45. void loop()
  46. {
  47.   if (Serial.available()) // Se o ESP8266 estiver mandando caracteres para a AutomationBoard
  48.   {
  49.  
  50.     if (Serial.find("+IPD,")) // Se encontrou "+IPD," o proximo caracter sera o ID da conexao
  51.     {
  52.       delay(1000);
  53.       int connectionId = Serial.read() - 48; // subtrai 48 porque a funcao read() retorna um caracter ASCII, subtraindo 48 teremos um int correspondente (primeiro decimal comeca em 48)
  54.  
  55.       int muda_rele = 0; // Variavel que define qual rele sera alterado, de acordo com o link que o usuario clicou
  56.       if (Serial.find("rele")) {
  57.         muda_rele = Serial.read() - 48;
  58.       }
  59.       if (muda_rele == 1) {
  60.         digitalWrite(rele1_pino, !rele1);  // Se usuario clicou no 1o link, muda estado do rele1
  61.         rele1 = !rele1;
  62.       }
  63.       if (muda_rele == 2) {
  64.         digitalWrite(rele2_pino, !rele2);  // Se usuario clicou no 2o link, muda estado do rele2
  65.         rele2 = !rele2;
  66.       }
  67.       if (muda_rele == 3) {
  68.         digitalWrite(rele3_pino, !rele3);  // Se usuario clicou no 3o link, muda estado do rele3
  69.         rele3 = !rele3;
  70.       }
  71.       if (muda_rele == 4) {
  72.         digitalWrite(rele4_pino, !rele4);  // Se usuario clicou no 4o link, muda estado do rele4
  73.         rele4 = !rele4;
  74.       }
  75.  
  76.  
  77.       // Monta a pagina que sera exibida para o usuario
  78.       String webpage = "";
  79.       webpage += "<html><head></head><body><center>";
  80.       webpage += "<img src=\"http://goo.gl/IoorRu\" width=\"250\">";
  81.       webpage += "<br><br><h2>Web Server com ESP8266 e AutomationBoard</h2><br>";
  82.       webpage += "<a href=\"http://";
  83.       webpage += meu_IP;
  84.       webpage += "/rele1\"><h2>Rele 1 ";
  85.       if (rele1) {
  86.         webpage += "ligado</h2></a>";
  87.       } else {
  88.         webpage += "desligado</h2></a>";
  89.       }
  90.       webpage += "<a href=\"http://";
  91.       webpage += meu_IP;
  92.       webpage += "/rele2\"><h2>Rele 2 ";
  93.       if (rele2) {
  94.         webpage += "ligado</h2></a>";
  95.       } else {
  96.         webpage += "desligado</h2></a>";
  97.       }
  98.       webpage += "<a href=\"http://";
  99.       webpage += meu_IP;
  100.       webpage += "/rele3\"><h2>Rele 3 ";
  101.       if (rele3) {
  102.         webpage += "ligado</h2></a>";
  103.       } else {
  104.         webpage += "desligado</h2></a>";
  105.       }
  106.       webpage += "<a href=\"http://";
  107.       webpage += meu_IP;
  108.       webpage += "/rele4\"><h2>Rele 4 ";
  109.       if (rele4) {
  110.         webpage += "ligado</h2></a>";
  111.       } else {
  112.         webpage += "desligado</h2></a>";
  113.       }
  114.       webpage += "</center></body></html>";
  115.  
  116.  
  117.       String cipSend = "AT+CIPSEND=";  // Variavel com o comando para enviar dados para o dispositivo que se comunica com o modulo
  118.       cipSend += connectionId;         // ID da conexao
  119.       cipSend += ",";                  // separacao
  120.       cipSend += webpage.length();     // tamanho do pacote de dados a ser enviado
  121.       cipSend += "\r\n";               // fim do comando
  122.  
  123.       sendData(cipSend, 1000, DEBUG);  // envia comando para o modulo
  124.       sendData(webpage, 3000, DEBUG);  // envia a pagina para responder ao acesso de algum dispositivo (ex: usuario)
  125.  
  126.       String closeCommand = "AT+CIPCLOSE=";   // Variavel com o comando para fechar a conexao
  127.       closeCommand += connectionId;           // ID da conexao
  128.       closeCommand += "\r\n";                 // fim do comando
  129.  
  130.       sendData(closeCommand, 1000, DEBUG);    // Envia comando para fechar a conexao
  131.     }
  132.   }
  133. }
  134.  
  135.  
  136. String sendData(String command, const int timeout, boolean debug)
  137. {
  138.   String response = "";  // variavel que armazena a resposta do modulo
  139.  
  140.   Serial.print(command); // envia o comando para o modulo
  141.  
  142.   long int tempo = millis();
  143.  
  144.   while ( (tempo + timeout) > millis())
  145.   {
  146.     while (Serial.available() > 0)
  147.     {
  148.       char c = Serial.read(); // le e armazena os caracteres da resposta do modulo
  149.       response += c;
  150.     }
  151.   }
  152.  
  153.   if (debug)    // Se debug estiver habilitado, imprime mensagens de resposta do modulo
  154.   {
  155.     Debug.print(response);
  156.   }
  157.  
  158.   return response;
  159. }

Como simplificação para os desenvolvedores mais iniciantes, este código que preparamos gera uma página com links, que ao serem acessados, recarregam a página e acionam os relés correspondentes, informando ainda o estado de cada relé. Você poderá substituir esses links por botões ou imagens, apenas alterando a forma como a página é gerada no código. Além disso, poderá utilizar "forms" com métodos POST ou GET.

Não esqueça de alterar o código na área indicada para os dados da sua rede. Coloque ali o SSID e senha da sua rede WiFi e escolha um endereço de IP compatível com sua rede local. Exemplo: Se o seu roteador responde no endereço 192.168.0.1, escolha um IP do tipo 192.168.0.XXX, onde o XXX está no range permitido nas configurações do seu roteador, exemplo: 192.168.0.99. No nosso caso, utilizamos 192.168.0.142, porque gostamos do número "42". ;-)

Depois de carregado o código e montado o circuito, abra um browser em qualquer dispositivo que esteja conectado à rede local, seja um tablet, celular (que estejam acessando a sua rede) ou PC e digite no lugar da URL o IP que você colocou no código acima. Você verá a seguinte página (que poderá ser personalizada posteriormente):

Agora, clique em um dos links e aguarde o completo carregamento da página. Você verá o relé correspondente na placa acionar e o link clicado mudar de "desligado" para "ligado", indicando o novo estado do relé.

Dica para programação

Os desenvolvedores mais avançados que desejarem implementar modificações no código acima, poderão alterar a definição "Debug" para "true" no início do código, e adicionar um segundo módulo conversor USB/Serial, ou Arduino sem o ATmega, aos pinos 10 e 11, onde criamos uma porta serial por software (SoftwareSerial) exclusiva para debug. Nesse caso, todas as respostas do módulo ESP8266 poderão ser acompanhadas nessa porta criada em qualquer terminal serial.

Como acessar o sistema de fora da rede local, pela internet? 

O dispositivo que você acaba de criar é acessível pela rede local, mas existe uma forma de torná-lo acessível de fora, via internet. Trata-se do "encaminhamento de porta" ou "port forwarding". 

Esse é um recurso disponível em praticamente todos os roteadores, e com certeza, o seu roteador também tem. Funciona da seguinte maneira: Cria-se uma porta, que tem um número, exemplo: 91. Essa porta corresponderá a um endereço de IP da sua rede local, exemplo 91 = 192.168.0.99. Quando algum dispositivo solicitar ao seu roteador o acesso a porta 91, ele automaticamente irá redirecionar o tráfego para o IP configurado, que será o do dispositivo de automação.

Assim, para acessar externamente, basta digitar no browser o endereço de IP (externo) do seu roteador seguido do número da porta. Exemplo: 201.AAA.BBB.CC:91. E quem irá responder é o módulo ESP8266 com a página que criamos na programação.

Para saber mais sobre encaminhamento de porta e entender como configurar o seu roteador, sugerimos uma busca no Google pelos termos "encaminhamento de porta" seguidos do modelo do seu roteador. É bem simples de fazer.

Lembramos que o firmware acima se dispõe apenas ao objetivo didático, e portanto, não possui qualquer proteção ou senha para acesso externo. Por segurança, sugerimos que este recurso seja implementado para uso residencial ou comercial.

Como conectar os relés às cargas como lâmpadas?

É muito simples. Os detalhes, inclusive com imagens podem ser conferidos neste tutorial:

http://labdegaragem.com/profiles/blogs/tutorial-sistema-de-automaca...

Referências

Sugerimos as seguintes leituras para o caso de dúvida:

http://labdegaragem.com/profiles/blogs/primeiros-passos-com-a-autom...

http://labdegaragem.com/profiles/blogs/tutorial-sistema-de-automaca...

http://forum.arduino.cc/index.php?topic=283043.0

http://wiki.iteadstudio.com/ESP8266_Serial_WIFI_Module#AT_Commands

http://allaboutee.com/2014/12/30/esp8266-and-arduino-webserver/

Exibições: 20381

Comentar

Você precisa ser um membro de Laboratorio de Garagem (arduino, eletrônica, robotica, hacking) para adicionar comentários!

Entrar em Laboratorio de Garagem (arduino, eletrônica, robotica, hacking)

Comentário de Marcelo Rodrigues em 29 março 2016 às 12:56

Cassio,

Não são erros, são alertas. Aparecem outros além desses na compilação. Não verifiquei esses alertas ainda.

Mas o código compila e executa normalmente. Testei novamente aqui.

Abraço!

Comentário de cassio murilo borges em 28 março 2016 às 22:51

root/Arduino/sketch_mar28a/sketch_mar28a.ino: In function 'void loop()':
/root/Arduino/sketch_mar28a/sketch_mar28a.ino:51:32: warning: deprecated conversion from string constant to 'char*' [-Wwrite-strings]
         if (Serial.find("+IPD,")) // Se encontrou "+IPD," o proximo caracter sera o ID da conexao
                                ^
/root/Arduino/sketch_mar28a/sketch_mar28a.ino:57:33: warning: deprecated conversion from string constant to 'char*' [-Wwrite-strings]
           if (Serial.find("rele")) {
                                 ^
Porque sempre apresenta estes erros?

Comentário de Marcelo Rodrigues em 15 março 2016 às 9:06

Josauro,

As ligações parecem ok. Mas você precisa corrigir os seguintes pontos:

- Desconecte o módulo conversor USB/Serial. Como dito no tutorial, ele usa os mesmos pinos do ESP (RX/TX) e com certeza não funcionará.

- Não copie e cole o código apenas. Procure entendê-lo, assim você dominará o projeto. Você precisa alterar o endereço IP para ser compatível com a sua rede.

- Essa saida COM4 que você postou é com um conversor auxiliar em uma softserial? Como existe o conflito de pinos informado acima, não é possível se comunicar com o módulo, por isso ele não está respondendo na serial com os "OK" depois de cada comando.

- Utilize o Ping para verificar se o módulo está respondendo na sua rede.

Reveja o tutorial com cuidado e mais os pontos acima. Se precisar de mais orientação, pode escrever para mim em mensagem privada. Ok?

Abraço!

Comentário de Josauro S.J. em 14 março 2016 às 21:58

Digitei o código do exemplo, mas não consigo conectar, tem algo errado nas ligações abaixo ?

Comentário de Marcelo Rodrigues em 10 março 2016 às 20:01

Cyberlacs,

Você pode ter um ESP para a casa toda e aumentar o número de relés na AutomationBoard adicionando módulos, mas aí cada carga precisará de um fio até o relé.

Pode ainda ter um ESP e uma AB para cada 4 cargas e distribuir as ABs pelos quadros de força ou no forro.

Pode ainda ter um ESP e alguns módulos de rádio, como o XBee, para eles se comunicarem. A placa que tem o ESP será master e as demais, slave.

Tem várias formas de fazer. Você deve pensar a que for mais fácil ou mais barata para você.

Boa sorte!

Comentário de Marcelo Rodrigues em 10 março 2016 às 19:58

Josauro,

Respondendo às suas questões:

1. Sim, é necessário um conector macho-macho, mas nós mandamos junto com a placa. Se você não recebeu, por favor entre em contato com a nossa loja.

2. Sim, o conector do XBee é mais raso que o header para shields. Mas ele fica fixo sim, basta encaixar um pouco mais. Ficará uma parte para fora, mas ele fica bem firme, sim.

Comentário de Eduardo castellani em 10 março 2016 às 18:52

OK. obrigado Marcelo

Comentário de Cyberlacs em 10 março 2016 às 18:22

Tenho uma dúvida em relação ao MÓDULO WIFI ESP8266-01

Para eu ter controle de todos os cômodos de uma casa, tenho que ter um ESP8266 em cada cômodo e ai pela internet acesso um dos ESP8266-01 configurado como master que envia instruções para os outros acionando a lampada.

Com o MÓDULO WIFI ESP8266-01 tem como fazer esta comunicação ?

Comentário de Josauro S.J. em 4 março 2016 às 14:03

Ola uma duvida sobre a placa, a 1a coisa que notei que a minha placa o conector do suporte da seria da USB na placa que tenho os conectores são tipo Femea e o conector USB também é então precisei usar jumper macho/macho para conectar.

2a estou tentando conectar os jumpers para conexão wi-fi e notei que os lugares para conectarem são muito rasos/baixo ou seja o macho não tem espaço para se fixar nesse local,  so fica a pontinha conectado sem suporte ou seja não fica fixo, isso esta certo ?

Comentário de Eduardo castellani em 3 março 2016 às 17:41

Obrigadão, Marcelo.

Por isso que eu as vezes penso em migrar para o A - NOVO  Raspberry Pi 3 traz Wi-Fi, Bluetooth e  quad-core ARM Cortex-A53 usado em Celulares

Mas agora tem tambem o A - Arduino  Due - com  ARM de 32 bits - um relógio 84MHz

Não fui ainda para o Raspberry Pi, por causa da linguagem de programação.

Destaques

Registre-se no
Lab de Garagem
Clicando aqui

Convide um
amigo para fazer
parte

curso gratis de arduino

© 2019   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço