3 Formas de configurar o Wi-Fi no ESP8266
O nosso famoso ESP8266 veio para ficar, cada
vez mais este microcontrolador é utilizado para desenvolver dispositivos
fantásticos, é verdade que o ESP pode ser utilizado como um simples MCU, mas é a sua capacidade de se ligar
a uma rede Wi-Fi, faz dele a escolha perfeita no que toca dipositivos IoT.
Este artigo tem foco em três diferentes
soluções que permitem programar o ESP de forma a que este se consiga ligar a
uma rede Wi-Fi. É sabido que da primeira vez que o ESP é energizado este tem de
conhecer ou vir a conhecer o SSID e a Password configurada no Access Point ao qual o queremos conectar
de forma a fazer para da rede e ter acesso à Internet se assim for necessário.
Vamos então ver como implementar as três soluções,
analisar cada uma delas e ponderar os prós e contras e cada uma delas.
Passemos ao caso mais simples, ao qual
denomino de “Hard Coded”, esta é a forma mais utilizada por quem começa a
utilizar o ESP nos seus projetos “caseiros”, é simples de implementar porque
apenas temos que escrever diretamente no código o SSID e a Password da nossa
rede Wi-Fi.
Bem se me perguntarem se seria um método que
utilizasse, eu responderia que já utilizei, mas sempre procurei outras formas
de tornar a configuração dinâmica.
Se olharmos para o código vamos perceber a
simplicidade do mesmo:
Apenas temos de incluir a biblioteca que nos
permite utilizar a Wi-Fi através de funções de alto nível <ESP8266WiFi.h>, no método setup que apenas corre uma vez no arranque do nosso ESP utilizamos a função WiFi.begin que recebe o SSID da rede à qualquer queremos ligar
e a Password, a partir daqui a magia
acontece e o nosso pequeno microcontrolador de 2 euros começa a tentar ligar-se
ao Wi-Fi.
Podemos verificar no código, que existe um
ciclo while que faz com que o processo de arranque não continue até que o WiFi.status seja igual a WL_CONNECTED.
Em relação ao espaço ocupado, verificamos no
output da consola do IDE do Arduino que utiliza 248631 bytes, isto num ESP versão 01 com apenas 512K seria 49%
do espaço disponível, felizmente existe a versão ESP12 que já trás 4M neste
apenas estaríamos a consumir 23% do espaço disponível.
Em relação ao tempo que demora a ligar-se a
uma rede Wi-Fi com uma força de sinal a rondar os 60%, aqui é gasto cerca de 14 segundos em média.
Passamos agora à segunda
implementação, esta é uma das mais utilizadas em produtos IoT sejam protótipos ou
versões comerciais.
Apareceu como uma forma
“Easy” de configuração e utiliza técnicas avançadas que exploram as capacidades
do sistema operativo no que toca a autoconfiguração (easy-conf).
O Wi-Fi
Manager (https://github.com/tzapu/WiFiManager) é uma biblioteca open-source
desenvolvida pelo Tzapu, esta transforma o nosso ESP num verdadeiro produto comercial capaz de ser configurado para
se ligar a uma rede Wi-Fi sem grande dificuldade, permitindo assim ao
consumidor final escolher a rede a que se quer ligar de uma forma simples sem
ter que escrever uma única linha de código.
Vamos olhar para o código e perceber o que é
possível fazer com esta maravilhosa biblioteca:
Neste exemplo começamos claro por utilizar
novamente biblioteca <ESP8266WiFi.h>,
pois é ela que contêm toda a lógica para utilizar o Wi-Fi, de seguida adicionamos duas bibliotecas de requisito obrigatório para que o Wi-Fi Manager compile corretamente,
por fim adicionamos a biblioteca que nos irá facilitar a configuração <WiFiManager.h>.
Fazendo uma explicação superficial de cada uma
das bibliotecas:
<DNSServer.h>, ativa serviços de DNS para que seja mais simples encontrar o nosso ESP
na rede, os DNS apareceram para facilitar o acesso a dispositivos ligados uma
rede TCP/IP, em vez de termos que decorar um IP 192.168... ou passar a rede a
pente fino para descobrir que IP foi atribuído ao nosso ESP, com esta biblioteca podemos simplesmente aceder ao ESP
utilizando o nome que que definimos no código seguido de .local, utilizando o código acima como exemplo vemos que na função wifiManager.autoConnect(“OMEUESP”),
passamos a String OMEUSESP caso
queiramos saber o IP dele ou verificar se está ativo na rede podemos fazer um
ping a omeuesp.local e será
devolvido o resultado do ping que contem o tempo que demorou e o IP do ESP.
Mais informações sobre o comando ping em https://pt.wikipedia.org/wiki/Ping.
<ESP8266WebServer.h>, como o nome indica esta biblioteca ativa funcionalidades de um Web Server, sim um Web Server a correr
num chip que custa menos que um pastel de nata.
Este Web Server vai disponibilizar uma bela
interface onde um utilizador que nada entende de linguagens de programação possa
de forma simples escolher uma das redes detetadas pelo ESP e configurar a sua
Password.
<Wi-FiManager.h>, por fim a biblioteca Wi-FiManager trata da inicialização de um Captive Portal para configurar e pesquisar
redes disponíveis, também é esta biblioteca que decide se o ESP entra em Modo ACCESS POINT ou em Modo CLIENT, sendo que o modo AP
serve para nos ligar a uma rede criada pelo nosso ESP com o nome que definimos,
com base no exemplo acima seria OMEUESP.
Ao ligarmo-nos o nosso computador ou
smartphone a essa rede, é automaticamente aberta uma janela de configuração (Captive Portal), por outro lado caso o
ESP já se tenha ligado com sucesso a uma rede, esta deixa de aparecer e passa a
funcionar apenas como se fosse mais um cliente na nossa rede.
Com uma breve explicação das bibliotecas
passamos à parte interessante, o que acontece depois de termos carregado o
código com o Wi-Fi Manager no nosso
ESP8266.
Bem se ainda tivermos o nosso ESP ligado ao
USB do nosso computador, podemos carregar na Serial Console do Arduino e “cuscar”
o que está a acontecer.
Analisando o log vemos que existe uma
tentativa de se ligar como cliente, mas como é normal ele ainda não tem nenhuma
rede gravada e o resultado é 1, o que quer dizer que falhou a ligação, em
consequência disso ele inicializa-se em modo Access Point e cria uma rede chamada OMEUESP no caso do nosso exemplo, o IP 192.168.4.1 é sempre o mesmo
e apenas existe para o caso de algum sistema operativo não suportar Captive
Portal, fazendo com que tenhamos em alternativa usar esse IP no nosso browser
para configurar o ESP, bem aqui já vemos um pequeno contratempo mas por
experiência própria o Captive Portal abre em 99% das vezes.
Então se o nosso ESP está em modo Access Point
é possível detetar o mesmo e ligarmos-mos a ele através do nosso smartphone ou
portátil.
Após uma conexão à rede criada é
automaticamente aberto um portal no nosso computador, para quem já se ligou a
Hot-spots públicos vai reconhecer o método.
Depois basta clicarmos no botão Configure WiFi e escolher a rede.
Resumindo a partir daqui o nosso ESP fica
ligado a rede Wi-Fi configurada e pode ser reiniciado que não perde as
configurações, caso a Rede deixe de existir ou a password altere ele entra em
modo de configuração automaticamente.
Comparando com o método HardCoded, este utiliza mais 15% do espaço do nosso ESP em relação
a anterior, a velocidade de ligação pós configuração ronda em média os 16
segundos face aos anteriores 14 segundos, no entanto tudo isso compensa porque
oferece uma forma muito versátil de configurar e disponibiliza documentação
bastante detalhada.
Se és
programador e estas a pensar se é possível alterar o Captive Portal de forma a
espelhar a tua marca, a resposta é sim claro, o código fonte está disponível no
GitHub e só tens de fazer HTML simples J.
Agora perto do fim deixamos o melhor para terminar
em grande.
A ultimo método que vou demonstrar utiliza um
protocolo nativo da EspressIf, os
construtores do ESP8266.
Só agora é que se começa a falar mais nele,
pois a documentação acerca do ESP8266 começa a ser mais rica e escrita em
Inglês, quando este foi lançado apenas existia pouca coisa, o que se encontrava
estava em chinês, por isso como qualquer grande programador a malta deixou a
documentação de lado e começou a criar formas de configurar o ESP vimos a
versão HardCoded e outra utilizando
a biblioteca Wi-Fi Manager, bom mas
quem desenvolveu este fabuloso microcontrolador com Wi-Fi, pensou muito bem
como é que este podia ser configurado de forma simples e é aqui que entra o
protocolo ESP-TOUCH.
Este protocolo é desenvolvido diretamente pela
ExpressIf e é suportado nativamente
pelos ESP8266, permite uma rápida configuração de um ou milhares de ESP’s ao
mesmo tempo e não obriga a termos de nos ligar a ele para o configurar... sim
podes estar a achar estranho, mas no fim do ESP entrar em modo SmartConfig,
fica a escuta de uma ligação UDP que
trás a configuração cifrada para o acesso à rede Wi-Fi.
Para implementarmos este protocolo a EspressIf
disponibiliza o SDK para criarmos
aplicações capazes de criar essa ligação UDP
e cifrar o conteúdo de forma a que
apenas o ESP o entenda.
A documentação oficial pode ser encontrada em https://www.espressif.com/sites/default/files/30b-esp-touch_user_guide_en_v1.1_20160412_0.pdf
Os SDK para desenvolver aplicações para IOS ou
Android podem ser encontradas em
Se não quiserem desenvolver a vossa própria
App, existem disponíveis na App Store ou na Play Store, basta pesquisar por “ESP Smart Config” estas são free.
Imagem retirada da documentação oficial que
exemplifica a arquitetura de comunicação utilizada pelo protocolo ESP-TOUCH, podemos constatar que não
existe ligação direta entre o smartphone e o ESP, o que torna este método
maravilhoso face ao anterior que tinhamos de andar a trocar de Redes Wi-Fi,
confundindo assim o utilizador menos experiente.
Com o ESP-TOUCH o utilizador não tem de se
desligar da sua rede Wi-Fi já configurada no seu smartphone, apenas tem de
abrir a App SmartConfig e digitar a Password da sua Rede Wi-Fi.
Deixando então a parte a configuração, vamos
analisar o código que temos de colocar no ESP para ter o ESP-TOUCH a bombar.
Nesta versão voltamos apenas a necessitar da
biblioteca base do <ESP8266WiFi.h>,
o que é ótimo para uma otimização de espaço utilizado, com o ESP-TOUCH
utilizamos 7% a mais face à versão HardCoded
e menos 8% face ao WiFiManager.
Para este modo funcionar o ESP tem de estar em
Modo Station e isso é conseguido
utilizando a função WiFi.mode(WIFI_STA),
após isso damos inicio à configuração “Smart” com a função WiFi.beginSmartConfig(), o ciclo while
já é conhecido do método HardCoded e serve apenas para não deixar o
processamento avançar até que o ESP tenha ligação ao Wi-Fi.
Notas importantes sobre o código acima, da
forma que está sempre que o ESP fizer
restart fica em modo SmartConfig, para isso é necessário implementar algum
código extra de forma a detetar se já existe alguma configuração prévia, e se
sim então tentar usar primeiro a mesma, caso esta falhe ai sim colocamos em modo
SmartConfig.
Deixo apenas um exemplo de como seria uma
implementação com time out e reciclagem de configurações prévias.
Concluindo, a versão HardCoded é ótima para
quando estamos a desenvolver algo que queremos apenas testar naquele instante,
isto porque não consome nenhum tempo de configuração extra, o WiFi Manager é
ótimo para desenvolvermos um produto que possa ser configurado de forma
minimamente simples, no entanto sofre de alguns Bugs, algumas vezes após ser
configurado com sucesso não desativa o modo AP, criando alguma entropia no
nosso router/ap, o facto de termos que trocar de rede para o configurar baralha
utilizados menos experientes e temos de configurar um ESP de cada vez, por fim
o ESP-TOUCH é uma forma mais simples de configurar mas obrigada o utilizador a
instalar um APP no seu smartphone, no entanto podemos configurar dezenas ao
mesmo tempo com um só clique na App.
Com todos estes prós e contras penso que a
escolha do método tem de ir de encontro ao que queremos desenvolver, por isso
nenhum deles deve ser deixado ao acaso.
Fica uma tabela que tenho alimentado ao longo
das minhas experiências com alguns comparativos de cada um deles.
Espero que isto tenha ajudado :), alguma duvida é só perguntarem. Um Grande Abraço e grandes engenhocas :).
Segue-me no Youtube ----> http://youtube.com/brunohorta
Muito bom, parabéns pela paciência e pelo capricho!
ResponderEliminarExcelente conteúdo, obrigado por compartilhar, sucesso!
ResponderEliminarVlw ai!!! Muito bom o material!!!
ResponderEliminarBom dia. não tenho muita experiência mas fiz funcionar serial telnet com o esp8266 através dos exemplos mas gostaria de por o wifimanager para configurar o ssid e a senha através dele pois toda vez que preciso mudar de local tenho de gravar ele com os dados novos...Poderia me ajudar ou mostrar o caminho...sou hobista e gosto muito de mecher com isto mas tem horas que falta conhecimento.
ResponderEliminarsegue o código que uso hoje e gostaria de usar o wifimanager para configurar o usuário e senha da rede via navegador.
//******************************************************************************
// WiFiUartTransparentBridge
// Version 1.1.0
// Note
// Este esboço é baseado em "WiFiTelnetToSerial - Exemplo de UART transparente para servidor Telnet para esp8266"
//******************************************************************************
#include
#include
#include
#include "config.h"
#include
#define STATIC_IP_ADDR
WiFiServer localServer(networkport);
WiFiClient localClient;
// Variable to store the HTTP request
String header;
#ifdef STATIC_IP_ADDR
IPAddress staticIP(192,168,1,150);
IPAddress gateway(192,168,1,1);
IPAddress subnet(255,255,255,0);
#endif
void setup() {
WiFiManager wifiManager;
Serial.begin(baudrate);
WiFi.begin(ssid, password);
#ifdef STATIC_IP_ADDR
WiFi.config(staticIP, gateway, subnet);
#endif
Serial.print("\nConectando à "); Serial.println(ssid);
uint8_t i = 0;
while (WiFi.status() != WL_CONNECTED && i++ < 20) delay(500);
if(i == 21){
Serial.print("Não pôde se conectar ao"); Serial.println(ssid);
while(1) delay(500);
}
//start UART and the server
localServer.begin();
localServer.setNoDelay(true);
Serial.print("Ready! Use 'Itaju Peixe Bom ");
Serial.print(WiFi.localIP());
Serial.println(" to connect");
}
void loop() {
//check if there are any new clients
if (localServer.hasClient()){
if (!localClient.connected()){
if(localClient) localClient.stop();
localClient = localServer.available();
}
}
//check a client for data
if (localClient && localClient.connected()){
if(localClient.available()){
size_t len = localClient.available();
uint8_t sbuf[len];
localClient.readBytes(sbuf, len);
Serial.write(sbuf, len);
}
}
//check UART for data
if(Serial.available()){
size_t len = Serial.available();
uint8_t sbuf[len];
Serial.readBytes(sbuf, len);
if (localClient && localClient.connected()){
localClient.write(sbuf, len);
}
}
}