Sinalizador - Parte 4

Vamos agora estudar como colocar um ESP8266 dentro do sinalizador, permitindo controlá-lo sem fios. Como ainda não providenciei um novo sinalizador, vou usar quatro LEDs.

Do ponto de vista de hardware, o nosso problema é apenas ligar quatro LEDs ao ESP8266. Cada pino de GPIO do  ESP é capaz de gerar correntes de até 12mA e absorver correntes de até 20 mA. Algo mais que suficiente para um teste, portanto basta colocar um resistor em série com o LED. Se quisermos usar um LED com uma corrente maior, podemos colocar um transistor (ou usar um driver integrado como o ULN2803).

A coisa é mais interessante do ponto de vista de software. Como queremos comandar via WiFi, é necessário configurar o ESSID e senha da rede. Uma solução elegante é o WiFi Manager. De forma resumida, ao inciar ele tenta se reconectar à última rede utilizada. Se não conseguir, o ESP se comporta como um ponto de acesso (com ESSID e senha que você definiu) mais um mini servidor web; basta você conectar um PC ou o seu celular nele e usar o browser para configurar a rede à qual você quer se conectar.

Conectado à rede WiFi, o meu programa espera uma conexão TCP na porta 23 (telnet). Ao receber a conexão ele espera sequências de letras R, G, Y, B finalizadas por LF. Estas sequências indicam quais LEDs (Vermelho, Verde, Amarelo e Azul, respectivamente) devem ser acesos. Rudimentar, mas permite fazer um teste rápido com um cliente telnet.

O software fica assim, lembrando que você precisa de uma versão atual da IDE do Arduino com a placa ESP8266 e a biblioteca WiFi Manager instaladas:

view plaincopy to clipboardprint?

1. /* 
2.  * Sinalizador WiFi 
3.  * DQ - 27/09/16 
4.  *  
5.  */  
6.   
7. #include <ESP8266WiFi.h>          //ESP8266 Core WiFi Library  
8.   
9. #include <DNSServer.h>            //Local DNS Server used for redirecting all requests to the configuration portal  
10. #include <ESP8266WebServer.h>     //Local WebServer used to serve the configuration portal  
11. #include <WiFiManager.h>          //https://github.com/tzapu/WiFiManager WiFi Configuration Magic  
12.   
13.   
14. // Conexão dos LEDs  
15. static const int ledY = D8;  
16. static const int ledR = D7;  
17. static const int ledB = D6;  
18. static const int ledG = D5;  
19.   
20. // Servidor TCP na porta 23  
21. WiFiServer server(23);  
22. static bool conectado = false;  
23. static char cmd[10];  
24. static int iCmd = 0;  
25.   
26. void setup() {  
27.   // Inicia as saídas ligadas aos leds  
28.   pinMode(ledY, OUTPUT);  
29.   pinMode(ledR, OUTPUT);  
30.   pinMode(ledB, OUTPUT);  
31.   pinMode(ledG, OUTPUT);  
32.   
33.   // Executa a conexão à rede WiFi  
34.   // Se não conseguir conectar à rede anterior, cria  
35.   // um ponto de acesso para configuração  
36.   WiFiManager wifiManager;  
37.   wifiManager.autoConnect("ESP8266-DQ", "abcdefgh");  
38.   
39.   // Inicia nosso servidor TCP  
40.   server.begin();  
41. }  
42.   
43. void loop() {  
44.   // Verifica se tem um cliente conectado  
45.   WiFiClient client = server.available();  
46.   if (client == NULL) {  
47.     return;  
48.   }  
49.   
50.   // Trata a conexão  
51.   client.println ("Sinalizador pronto");  
52.   iCmd = 0;  
53.   while (client.connected()) {  
54.   
55.     // Recebe próximo byte  
56.     if (client.available() > 0) {  
57.       char c = client.read();  
58.   
59.       // ^D encerra  
60.       if (c == 0x04) {  
61.         client.stop();  
62.         continue;  
63.       }  
64.   
65.       // Coloca no buffer  
66.       if (iCmd < sizeof(cmd)) {  
67.         cmd[iCmd++] = c;  
68.       }  
69.   
70.       // Testa fim de linha  
71.       if (c == '\n') {  
72.         // Recebeu um comando  
73.         digitalWrite (ledY, LOW);  
74.         digitalWrite (ledR, LOW);  
75.         digitalWrite (ledB, LOW);  
76.         digitalWrite (ledG, LOW);  
77.         for (int i = 0; i < iCmd; i++) {  
78.           switch (cmd[i]) {  
79.             case 'y': case 'Y':  
80.               digitalWrite (ledY, HIGH);  
81.               break;  
82.             case 'r': case 'R':  
83.               digitalWrite (ledR, HIGH);  
84.               break;  
85.             case 'b': case 'B':  
86.               digitalWrite (ledB, HIGH);  
87.               break;  
88.             case 'g': case 'G':  
89.               digitalWrite (ledG, HIGH);  
90.               break;  
91.           }  
92.         }  
93.         iCmd = 0;  
94.       }  
95.     }  
96.   }  
97. }  

/*
 * Sinalizador WiFi
 * DQ - 27/09/16
 * 
 */

#include <ESP8266WiFi.h>          //ESP8266 Core WiFi Library

#include <DNSServer.h>            //Local DNS Server used for redirecting all requests to the configuration portal
#include <ESP8266WebServer.h>     //Local WebServer used to serve the configuration portal
#include <WiFiManager.h>          //https://github.com/tzapu/WiFiManager WiFi Configuration Magic


// Conexão dos LEDs
static const int ledY = D8;
static const int ledR = D7;
static const int ledB = D6;
static const int ledG = D5;

// Servidor TCP na porta 23
WiFiServer server(23);
static bool conectado = false;
static char cmd[10];
static int iCmd = 0;

void setup() {
  // Inicia as saídas ligadas aos leds
  pinMode(ledY, OUTPUT);
  pinMode(ledR, OUTPUT);
  pinMode(ledB, OUTPUT);
  pinMode(ledG, OUTPUT);

  // Executa a conexão à rede WiFi
  // Se não conseguir conectar à rede anterior, cria
  // um ponto de acesso para configuração
  WiFiManager wifiManager;
  wifiManager.autoConnect("ESP8266-DQ", "abcdefgh");

  // Inicia nosso servidor TCP
  server.begin();
}

void loop() {
  // Verifica se tem um cliente conectado
  WiFiClient client = server.available();
  if (client == NULL) {
    return;
  }

  // Trata a conexão
  client.println ("Sinalizador pronto");
  iCmd = 0;
  while (client.connected()) {

    // Recebe próximo byte
    if (client.available() > 0) {
      char c = client.read();

      // ^D encerra
      if (c == 0x04) {
        client.stop();
        continue;
      }

      // Coloca no buffer
      if (iCmd < sizeof(cmd)) {
        cmd[iCmd++] = c;
      }

      // Testa fim de linha
      if (c == '\n') {
        // Recebeu um comando
        digitalWrite (ledY, LOW);
        digitalWrite (ledR, LOW);
        digitalWrite (ledB, LOW);
        digitalWrite (ledG, LOW);
        for (int i = 0; i < iCmd; i++) {
          switch (cmd[i]) {
            case 'y': case 'Y':
              digitalWrite (ledY, HIGH);
              break;
            case 'r': case 'R':
              digitalWrite (ledR, HIGH);
              break;
            case 'b': case 'B':
              digitalWrite (ledB, HIGH);
              break;
            case 'g': case 'G':
              digitalWrite (ledG, HIGH);
              break;
          }
        }
        iCmd = 0;
      }
    }
  }
}

No código acima, atenção que a senha usada em autoConnect precisa ter pelo menos oito caracteres (conforme indicado na documentação).