Você está na página 1de 43

Qual módulo ESP8266 comprar?

ESP8266, Wireless 11 de abril de 2016 Adilson Thomsen


Os módulos com chip ESP8266 estão se popularizando rapidamente e são uma ótima alternativa para
seu projeto de IoT (Internet of Things, ou Internet das Coisas), pelo tamanho e praticidade. Neste post
vamos ajudar você a escolher qual módulo ESP8266 comprar, mostrando os principais modelos e
características.

Internamente os módulos utilizam o mesmo controlador, o ESP8266 (datasheet), e o número de portas


GPIO varia conforme o modelo do módulo. Dependendo do modelo, você pode ter interfaces I2C, SPI e
PWM, além da serial. A alimentação de todos eles é de 3.3V, assim como o nível de sinal nos pinos. Os
módulos tem uma CPU de 32Bits rodando a 80MHz, suportam internet nos padrões 802.11 b/g/n e vários
protocolos de segurança como WEP, WPA, WPA2, etc. A programação pode ser feita via comandos AT
ou usando a linguagem LUA. São ideais para projetos de IoT pois possuem pouquíssimo consumo de
energia em modo sleep.

Módulo ESP8266 ESP-01

O módulo ESP8266 ESP-01 é o módulo mais comum da linha ESP8266. Ele é compacto (24,8 x 14,3
mm), e possui dois pinos GPIO que podem ser controlados conforme a programação. O ESP-01 pode ter
o firmware regravado e/ou atualizado, conforme mostramos no post Upgrade de Firmware do Módulo
ESP8266, utilizando interface serial. Uma pequena desvantagem desse tipo de módulo é a disposição
dos pinos, que dificultam a utilização em uma protoboard, mas você pode facilmente utilizar
um adaptador para módulo wifi ESP8266 ESP-01 ou jumpers macho/fêmea, por exemplo.

Módulo ESP8266 ESP-05


O módulo wifi ESP8266 ESP-05 é um módulo um pouco diferente das outras placas da linha ESP8266,
pois não possui portas que podemos usar para acionar dispositivos ou ler dados de sensores. Por outro
lado, é uma alternativa interessante para projetos de IoT quando você precisa de uma boa conexão de
rede/internet por um baixo custo. Pode ser utilizado, por exemplo, para montar um web server com
Arduino ou efetuar uma comunicação de longa distância entre placas como Arduino/Arduino,
Arduino/Raspberry, etc. Não possui antena onboard, mas tem um conector para antena externa onde
podemos usar um cabo pigtail U.FL e uma antena SMA, aumentando consideravelmente o alcance do
sinal wifi.

Módulo ESP8266 ESP-07

O módulo ESP8266 ESP-07 também é um módulo compacto (20 x 16mm), mas com um layout
diferente, sem os pinos de ligação. O módulo conta com uma antena cerâmica embutida, e também um
conector U-Fl para antena externa. Esse módulo tem 9 GPIOS, que podem funcionar como pinos I2C,
SPI e PWM. O layout do módulo permite que ele seja integrado facilmente à uma placa de circuito
impresso, muito utilizada em projetos de automação residencial.

Módulo ESP8266 ESP-12E


O módulo ESP8266 ESP-12E é muito semelhante ao ESP-07, mas possui apenas antena interna (PCB).
Tem 11 pinos GPIO e é muito utilizado como base para outros módulos ESP8266, como o NodeMCU,
que veremos mais adiante. No blog temos um interessante post ensinando a utilizar o módulo com
display Oled. Esse post usa especificamente o ESP-12E, mas você pode usar o mesmo princípio para
ligar o display em outros módulos ESP8266.

Módulo ESP8266 ESP-201

O módulo ESP8266 ESP-201 é um módulo um pouco mais fácil de usar em termos de prototipação, pois
pode ser montado em uma protoboard. Os 4 pinos laterais, que são responsáveis pela comunicação
serial, atrapalham um pouco esse tipo de montagem, mas você pode soldar esses pinos no lado oposto
da placa, ou utilizar algum tipo de adaptador. O ESP-201 possui 11 portas GPIO, antena embutida e
conector U-FL para antena externa. A seleção da antena é feita modificando um jumper (um resistor de 0
(zero) ohms) na parte superior da placa, ao lado do conector U-FL.

NodeMCU ESP8266 ESP-12E

O Módulo ESP8266 NodeMCU ESP-12E é uma placa de desenvolvimento completa, que além do chip
ESP8266 conta com um conversor TTL-Serial e um regulador de tensão 3.3V. É um módulo que pode
ser encaixado diretamente na protoboard e dispensa o uso de um microcontrolador externo para operar,
já que pode ser facilmente programado utilizando LUA. Possui 11 pinos de GPIO (I2C, SPI, PWM),
conector micro-usb para programação/alimentação e botões para reset e flash do módulo. Como
podemos ver na imagem, o NodeMCU vem com um ESP-12E com antena embutida soldado na placa.

Para ver como dar os primeiros passos com o NodeMCU, veja o post Como programar o módulo
ESP8266 NodeMCU.

Como programar o módulo

ESP8266 NodeMCU

ESP8266, Wireless 18 de fevereiro de 2016 Adilson Thomsen


O módulo Wifi ESP8266 NodeMCU ESP-12E é uma das placas mais interessantes da família ESP8266,
já que pode ser facilmente ligada à um computador e programada com a linguagem Lua e também
utilizando a IDE do Arduino. Neste post vamos mostrar como utilizar Lua para programar o módulo.

Essa placa possui 10 pinos GPIO (entrada/saída),


suportando funções como PWM, I2C e 1-wire. Tem
antena embutida, conversor USB-TLL integrado e o
seu formato é ideal para ambientes de
prototipação, encaixando facilmente em uma
protoboard.
Hardware Módulo Wifi ESP8266 NodeMCU
O módulo Wifi ESP8266 NodeMCU tem dois botões, conforme mostrado na imagem
abaixo: Flash (utilizado na gravação do firmware) e RST (Reset). No mesmo lado temos o conector
micro usb para alimentação e conexão com o computador.

No lado oposto, temos o ESP-12E e sua antena embutida, já soldado na placa. Nas laterais temos os
pinos de GPIO, alimentação externa, comunicação, etc.

No Windows 7, a instalação e download de drivers foi feita de forma automática, e um dispositivo USB-
TTL CH340 foi adicionado ao gerenciador de dispositivos. No nosso caso, foi atribuida a porta COM29:

Vamos programar o módulo utilizando o Lua, e isso pode ser feito, à princípio, de duas maneiras.
Programando o ESP8266 NodeMCU pela serial
Nesse método, vc pode utilizar um programa de terminal, como o Termite (download), para enviar os
comandos diretamente para o módulo. Vamos montar primeiro um pequeno circuito para teste, que
servirá para todos os exemplos deste post:

Conecte o módulo ao computador utilizando o cabo USB e entre no Termite (ou outro programa à sua
escolha), selecionando a velocidade de 9600. Pressione o botão de reset no módulo e aguarde a
exibição das informações sobre o firmware da placa:
Em seguida, digite no terminal o seguinte comando, que vai definir a porta 5 como saída. Pressione
ENTER após cada comando para que ele seja enviado ao NodeMCU:

gpio.mode(1, gpio.OUTPUT)

Para acender o led, envie o comando

gpio.write(1, gpio.HIGH)

Para piscar o led, crie um pequeno loop com essa série de comandos:

while 1 do
gpio.write(1, gpio.HIGH)
tmr.delay(1000000)
gpio.write(1, gpio.LOW)
tmr.delay(1000000)
end

Essa rotina vai fazer com que o led pisque a cada 1 segundo. Você logo vai notar que não é possível
parar o programa por meio de comandos, e essa rotina vai rodar continuamente. Para parar o loop e
reiniciar o módulo, pressione o botão RST.

Programando o Nodemcu utilizando ESPlorer


Programar o módulo pela serial pode ser interessante, mas podemos melhorar esse processo utilizando
um programa como o ESPlorer (download).

Com o ESPlorer você pode abrir diversas abas e programas ao mesmo tempo, salvar os programas em
disco, formatar (zerar) o módulo, e muitas outras funções.

Ao abrir o ESPlorer, temos no lado esquerdo uma área onde vamos escrever o(s) programa(s), e na
direita o/a console, onde podemos acompanhar em tempo real a comunicação com o NodeMCU:
Utilizando o exemplo do loop feito anteriormente, copie os comandos para a janela do lado esquerdo da
tela, e em seguida clique no botão Send to ESP para enviar a programação para o NodeMCU:

Agora além de controlar o módulo, você tem a opção de salvar o programa para uso posterior.

Conectando o NodeMCU na rede wireless


Até agora só vimos como acionar as portas do NodeMCU por meio de programas, e já que temos um
chip wireless ESP8266 no módulo, nada melhor do que acionar as portas do Nodemcu utilizando a rede
sem fio. Para isso, carregue o programa abaixo no ESPlorer, colocando o nome da sua rede wifi e a
senha nos campos NOME_DA_REDE e SENHA_DA_REDE, respectivamente:

-- Programa: Web Server com ESP8266 Nodemcu


-- Autor: FILIPEFLOP

-- Conexao na rede Wifi


wifi.setmode(wifi.STATION)
wifi.sta.config("NOME_DA_REDE","SENHA_DA_REDE")
print(wifi.sta.getip())
-- Definicoes do pino do led
led1 = 1
gpio.mode(led1, gpio.OUTPUT)
-- Definicoes do Web Server
srv=net.createServer(net.TCP)
srv:listen(80,function(conn)
conn:on("receive", function(client,request)
local buf = "";
local _, _, method, path, vars = string.find(request, "([A-Z]+) (.+)?(.+) HTTP");
if(method == nil)then
_, _, method, path = string.find(request, "([A-Z]+) (.+) HTTP");
end
local _GET = {}
if (vars ~= nil)then
for k, v in string.gmatch(vars, "(%w+)=(%w+)&*") do
_GET[k] = v
end
end
buf = buf.."<h1><u>FILIPEFLOP</u></h1>";
buf = buf.."<h2><i>ESP8266 Web Server</i></h2>";
buf = buf.."<p><a href="?pin=LIGA1"><button><b>LED 1 LIG</b></button></a> <br/><br/><a
href="?pin=DESLIGA1"><button><b>LED 1 DES</b></button></a></p>";
local _on,_off = "",""
if(_GET.pin == "LIGA1")then
gpio.write(led1, gpio.HIGH);
elseif(_GET.pin == "DESLIGA1")then
gpio.write(led1, gpio.LOW);
end
client:send(buf);
client:close();
collectgarbage();
end)
end)

O programa configura o módulo para o modo station (estação) na linha 5, depois configura a GPIO como
saída utilizando o comando gpio.mode. Para acessar a página web, você vai precisar do endereço IP
atribuído ao módulo. No nosso caso o IP foi o 192.168.0.25.

Para descobrir o endereço IP, acesse o ESPplorer , selecione a opção =wifi.sta.getip() conforme a
imagem abaixo e clique em SEND para que o endereço IP do módulo seja mostrado na console.
Acesse então o browser, digite o endereço IP e a página web do ESP8266 será exibida:
Guia completo do NodeMCU – ESP12 – Introdução

Nesse tutorial NodeMCU – ESP12 – Introdução,


você verá :
 O que é o Módulo NodeMCU-ESP12 ?
 A pinagem do Módulo NodeMCU-ESP12.
 Funções dos pinos do NodeMCU ESP12.
 Conectando o NodeMCU ESP12 no seu computador.
 Informações adicionais do NodeMCU ESP12

O que é o Módulo NodeMCU-ESP12 ?


Módulo NodeMCU é uma placa que foi criada para facilitar o desenvolvimento
de aplicações para o módulo ESP8266 ESP-12. Como é possível ver na foto,
existe um módulo ESP-12 soldado na placa. Nessa placa já existem todos os
circuitos necessários para fazer o ESP-12 funcionar – interface Serial-USB,
regulador de tensão, leds indicadores, botões de controle (Reset e Flash) e
barramentos de pinos para permitir o uso em Protoboards. A grande vantagem
dessa placa NodeMCU é que ela funciona como se fosse um Arduino. Você
conecta o cabo USB, e com a IDE Arduino você carrega seus programas na
placa. Nem precisa pressionar os botões !
Esse são os modelos de NodeMCU-ESP12 mais comuns, atualmente :
NodeMCU ESP12-N
NodeMCU ESP12-E
Para a alimentação do ESP-12, existe um regulador de 3,3V AMS1117
(corrente max 1A). Considerando que o consumo máximo de um ESP-12 é de
aproximadamente 200 mA, sobra uma corrente disponível de 800 mA. Mas se
for usar a tensão de 3,3V do próprio regulador para alimentar um outro
dispositivo externo, recomendo que nunca ultrapasse os 500 mA.

Link do Datasheet do regulador AMS1117


A alimentação dessa placa pode ser feita através do próprio conector USB
(5,0V) ou então através do pino VIN (EXT) , com uma alimentação regulada de
5,0V . Apesar do Regulador AMS1117 aceitar tensões de até 9V na entrada,
recomendo que se for alimentar a placa através desse pino, use sempre uma
fonte regulada de 5V, pois assim nunca sobre-aquecerá o regulador ! Evitando
um possível defeito no mesmo. Não recomendo que use opino 3,3V REG para
a entrada de alimentação da placa. Esse pino é a saída do regulador e não a
entrada. Mas no site da ESPRESSIF, tem a informação de que a alimentação
possa ser também através do pino 3,3V REG. Uma observação importante: as
opções de alimentação são mutuamente exclusivas, isto é, somente poderá
usar uma opção (USB, 5V ou 3,3V) . Não use mais de uma opção, pois poderá
danificar algum componente da placa. Não se esqueça de conectar o GND da
fonte no GND da placa.
O Chip da interface Serial-USB é o CP2102 da Silicon Labs. Ele suporta USB
2.0. (não suporta USB 3.0). Baud Rates até 1 MBps. Na placa NodeMCU, a
alimentação 3,3V do CP2102 é feita através do regulador AMS1117. Consumo
máximo de corrente desse chip é de apenas 26 mA. O CP2102 possui um
regulador interno de 3,3V, mas nessa placa NodeMCU, esse regulador não é
usado.

Link do Datasheet do CP2102

Para fazer a comunicação serial-USB com o seu computador é necessário que,


antes de conectar o cabo USB, instale os drivers do CP2102. Para fazer o
download desses drivers para Windows, Macintosh OSX, Linux e Android , use
o link abaixo:

Link dos Drivers CP2102


A pinagem do Módulo NodeMCU-ESP12

Imagem : NodeMCU ESP-12 (www.arduining.com)


 Led indicador Azul – esta conectado no pino GPIO_16. Um pulso
LOW(0V) acionará o led.
 Led Indicador ESP-12 – pisca quando a memória Flash esta sendo gravada
 Botão de RST – dá um pulso LOW (0V) no pino -RST (reset) reboot no
módulo ESP-12.
 Botão de FLASH – dá um pulso LOW (0V) no pino GPIO_0 – permite a
gravação do programa no ESP-12.
Observação interessante : Os pinos DTR e RTS do Chip CP2102, controlam o
pino ENA (reset chip ESP-12) e o pino GPI_0 (Load program). Portanto, ao
gravar um programa com a IDE Arduino, não é necessário pressionar o botão
de BOOT (Load).

Funções dos pinos do NodeMCU ESP12 :


Todos os pinos GPIOs, podem ser entradas ou saídas dependendo da
configuração dos mesmos. Não ultrapasse a corrente de 12 mA em cada porta
dessas, pois poderá danificar o chip. O recomendado é 6 mA. O nível de tensão
a ser usado nessas portas não deverá ultrapassar os 3,3V. Se for necessário
conectar o NodeMCU à outro dispositivo de tensão maior, como um Arduino ou
módulos de 5V, use conversores bidirecionais de tensão como o do link abaixo
ou use divisores resistivos de tensão.

Conversor Bidirecional de tensão


Essas são as dimensões do módulo NodeMCU ESP-12:

Imagem : User Manual for ESP12 Kit


O NodeMCU ESP12 tem duas fileiras de 15 pinos (total 30 pinos). A distância
entre as duas fileiras é grande (2,30 cm), mas poderá inseri-lo em
um Protoboard padrão. Os pinos RESERVED não deverão ser usados, como o
nome já diz, são reservados.

 VIN – Esse é o pino de alimentação externa ( recomendo 5,0V / 1A). Pode


usar até 9V, mas o regulador da placa deverá esquentar. Não use-o se
estiver usando a USB.
 GND– Esse é o terra da placa. Não se esqueça de conectá-lo ao terra de
outros dispositivos.
 RST – Reset do módulo ESP-12. Nível LOW(0V) dá um reboot na placa.
 EN – (Enable) ativa o módulo ESP-12 quando o nível for HIGH(3,3V).
 3.3V – saída do regulador interno 3,3V – Para alimentar outro dispositivo,
não use mais do que 500 mA de corrente.
 CLK – interface SPI (clock) – pino SCLK (GPIO_6)
 SD0 – interface SPI (master in serial out) – pino MISO (GPIO_7)
 CMD – interface SPI (chip select) – pino CS (GPIO_11)
 SD1 – interface SPI (master out serial in) – pino MOSI (GPIO_8)
 SD2 – pino GPIO_9 pode ser usado também para comunicação com SD
Card (SDD2)
 SD3 – pino GIPO_10 – pode ser usado também para comunicação com SD
Card (SDD3)
 RSV – reservado (não use).
 ADC0– pino de entrada do conversor analógico digital ADC de 10 bits.
Tensão máxima de 1,1V (variação do valor digital – 0 a 1024).

 D0 – pino GIPO_16 pode ser usado para acordar (WAKE UP) o ESP8266
em modo sono profundo (Deep sleep mode).
 D1 – pino GPIO_5 – entrada ou saída.
 D2 – pino GIPO_4 – entrada ou saída.
 D3 – pino GPIO_0 é usado também para controlar o upload do programa
na memória Flash. Esta conectado no botão FLASH.
 D4 – pino GPIO_2 – UART_TXD1 quando carregando o programa na
memória FLASH
 D5 – pino GPIO_14 pode ser usado em SPI de alta velocidade (HSPI-
SCLK)
 D6 – pino GPIO_12 pode ser usado em SPI de alta velocidade (HSPI-
MISO)
 D7 – pino GPIO_13 pode ser usado em SPI de alta velocidade (HSPI-
MOSI) ou UART0_CTS.
 D8 – pino GPIO_15 pode ser usado em SPI de alta velocidade (HSPI-CS)
ou UART0_RTS.
 RX – pino GPIO_3 – U0RXD quando carregando o programa na memória
FLASH.
 TX – pino GIPO_1 – U0TXD quando carregando o programa na memória
FLASH.

Conectando o NodeMCU ESP12 no seu


computador :
A Placa NodeMCU ESP12 deve ser conectada no seu computador, usando um
cabo USB com conector micro-USB. Qualquer porta USB poderá ser usada,
mas dê a preferência para uma porta USB que suporte a corrente de 500 mA ou
mais. Antes de conectar o cabo, como eu já informei, instale os drivers do chip
Serial-USB. Aguarde o reconhecimento da placa pelo Windows. Para descobrir
qual porta COM será usada pela Plataforma de Desenvolvimento (IDE) do
ESP8266, acesse o Gerenciador de dispositivos e identifique a COM
configurada. Digite Gerenciador de dispositivos na caixa de pesquisa do
Windows e selecione-o. No meu PC, a porta configurada foi a COM3.
Informações adicionais do NodeMCU ESP12:
Link GitHub do NodeMCU DevKit V1.0
Esse é o manual da placa NodeMCU ESP-12 :
ESP8266 ESP12E DevKit user manual
E esse é o manual do módulo ESP-12E :
ESP8266 ESP-12E module User manual
Esse é o datasheet do Chip ESP8266 :
Esp8266ex_datasheet_en

Esse é o diagrama eletrônico (esquemático) da placa NodeMCU ESP-12 .


Infelizmente, a imagem está com baixa definição.
Imagem : User Manual for ESP12 Kit
Se tiver alguma dúvida, deixe um comentário!

Guia completo do NodeMCU – ESP12 –


Usando Arduino IDE
Nesse tutorial NodeMCU – ESP12 – Usando Arduino
IDE (2), você verá :
 Porque programar NodeMCU com Arduino IDE ?
 Procedimentos para instalar NodeMCU na Arduino IDE
 Programando o NodeMCU ESP12 com a Arduino IDE
 NodeMCU ESP-12 acessando o relógio da WEB

Porque programar NodeMCU com Arduino IDE ?


No primeiro Tutorial sobre NodeMCU ESP-12 , eu já havia informado que
a grande vantagem dessa placa NodeMCU é que ela funciona como se fosse
um Arduino. Você conecta o cabo USB, e com a IDE Arduino você carrega seus
programas na placa. Nem precisa pressionar os botões !
Mas porque usar Arduino IDE ? A ESPRESSIF (fabricante do
ESP8266) disponibiliza no site, alguns firmwares para serem usados no módulo
ESP8266 ( Microcontrolador da placa NodeMCU).
 ESP8266 SDK
 ESP8266 AT
 ESP8266 Touch
 ESP8266 NOW
Esses firmares são específicos para o módulo ESP8266. Usam muitos recursos
do Chip, mas são complicados de usá-los. Para programá-los são necessários
conhecimentos de programação orientada a objetos e da Linguagem C++. Além
disso, a documentação não é bem clara para iniciantes em programação de
Microcontroladores. Se você já tem esses pré-requisitos, sugiro que estude os
links acima.
O grande sucesso do Arduino no mundo inteiro, foi por causa da grande
facilidade em usá-lo e programá-lo. Todo mundo sabe disso. E sabiamente, um
dos funcionários da ESPRESSIF, Ivan Grokhotkov iniciou a adaptação da
Arduino IDE para o ESP8266 em 2016. Hoje já são inúmeros contribuidores, e
posso dizer que a Arduino IDE já esta madura para o ESP8266. Muitas
bibliotecas já foram adaptadas e muitas aplicações já estão disponíveis.
Contando com a grande facilidade de programação ! Por isso, vamos usar a
IDE do Arduino.
Esse link abaixo é muito importante, pois é o Repositório
para ESP8266/Arduino, onde estão as Bibliotecas, códigos de exemplos e todos
outros arquivos necessários para usar a Arduino IDE com o ESP8266.
GitHub ESP8266 Arduino
Um comentário eu devo fazer sobre o firmware LUA. Na verdade, o módulo
NodeMCU foi criado por um idealista que adaptou o firmware do ESP8266 para
rodar a linguagem LUA. Mas infelizmente, o projeto NodeMCU LUA não foi
muito difundido, apesar dos esforços feitos até hoje .
 NodeMCU LUA
Procedimentos para instalar NodeMCU na Arduino
IDE
Existem alguns procedimentos para a instalação do NodeMCU na Arduino IDE.
Mas usarei o mais simples.
Primeiro passo é atualizar a Arduino IDE. Algumas IDEs antigas não suportam o
NodeMCU ESP8266, por isso é necessário que atualize para a versão mais
recente. Atualmente a versão mais nova é a 1.8.5.
Baixe a Arduino IDE e instale no seu computador Windows. Existem versões
para MacOS e Linux também.
 Download Arduino IDE
Inicie o programa Arduino IDE. Clique na barra superior em Arquivos e depois
em Preferências .
Dentro da janela de Preferências , copie o link abaixo no campo URLs adicionais
para Gerenciadores de Placas e depois clique em OK.
http://arduino.esp8266.com/stable/package_esp8266com_index.json

Na barra superior novamente, clique em Ferramentas e depois


em Gerenciamento de Placas.
Obs: na minha IDE, o ESP8266 já estava instalado.
Na janela do Gerenciador de Placas, refine a sua pesquisa com
: ESP8266 . Clique em More Info e depois em Instalar. Lembre-se que o seu
computador deve estar conectado na Internet. Após alguns segundos
aparecerá INSTALLED. Isto é, instalado. Feche essa janela.

Para a escolher o modelo da sua placa, isto é NodeMCU ESP12 , clique


novamente em Ferramentas e depois em Gerenciamento de Placas. Na janela
das Placas, escolha NodeMCU 1.0 (ESP12E Module) . Não altere os outros
parâmetros da Placa NodeMCU. Somente altere a porta COM da interface
serial-USB. No meu caso a porta é a COM3 . O procedimento para identificar
qual porta COM é usada no Windows está no Tutorial :
NodeMCU – ESP12 – Introdução (1)
Saiba que a velocidade padrão da Console da IDE Arduino para o ESP8266 é
de 115200 Bps.
IMPORTANTE : Após tudo configurado com sucesso, feche e abra o programa
Arduino IDE novamente, para que todas as configurações sejam efetivadas. Se
não fizer isso, poderá ter problemas ao usá-la.

Programando o NodeMCU ESP12 com a Arduino


IDE
Vamos começar os testes do ESP8266 com a Arduino IDE do modo mais
simples. Usando exemplos do site Arduino_ESP8266. Escolhi o Sketch Scan
WIFI, pois com ele, podemos testar o circuito WIFI do ESP8266, sem ter que
montar nada além do NodeMCU. Recomendo que insira a Placa NodeMCU em
um Protoboard, pois assim seus pinos ficarão protegidos (evitando um possível
curto-circuito).
 Conecte o NodeMCU com o cabo USB na porta USB do seu Computador
PC,
 Abra a Arduino IDE e verifique se a porta COM do NodeMCU foi
reconhecida ,
 Copie o programa abaixo na Arduino IDE, compile-o e grave-o no
ESP8266 (clique no botão Carregar).
OBS: Quando o programa estiver sendo carregado no ESP8266, o led azul
ficará piscando.
Sketch para pesquisar Redes WIFI (próximas do NodeMCU) :

Sketch ESP8266_ScanWIFI.ino
NodeMCU-ESP12 scan WIFI

Arduino
/* Pesquisa de Redes WIFI usando o NodeMCU-ESP12
1 Arduino IDE 1.8.5 - ESP8266
2 Gustavo Murta 07/mar/2018
3 baseado em
4 https://arduino-esp8266.readthedocs.io/en/2.4.0/esp8266wifi/scan-class.html
5 Blog Eletrogate http://blog.eletrogate.com/nodemcu-esp12-usando-arduino-ide-2/
6*/
7#include "ESP8266WiFi.h"
8
9 void setup()
10 {
11 Serial.begin(115200); // configura monitor serial 115200 Bps
12 Serial.println(); // imprime uma linha
13 WiFi.mode(WIFI_STA); // configura rede no modo estacao
14 WiFi.disconnect(); // desconecta rede WIFI
15 delay(100); // atraso de 100 milisegundos
16 }
17
18 void prinScanResult(int networksFound)
19 {
20 Serial.printf("\n"); // imprime uma linha
21 Serial.printf("%d redes encontradas\n", networksFound); // imprime numero de redes
22 encontradas
23 for (int i = 0; i < networksFound; i++) // contagem das redes encontradas
24 {
25 Serial.printf("%d: %s, Ch:%d (%ddBm) %s\n", i + 1, WiFi.SSID(i).c_str(), WiFi.channel(i),
26 WiFi.RSSI(i), WiFi.encryptionType(i) == ENC_TYPE_NONE ? "aberta" : "");
27 }
28 }
29
30 void loop()
31 {
32 WiFi.scanNetworksAsync(prinScanResult); // imprime o resultado
33 delay(500); // atraso de 0,5 segundos
}
Console da Arduino IDE – ESP8266 (115200 Bps) :
(clique no botão Monitor serial e altere a velocidade para 115200 Bps na barra
inferior da janela) )
Exemplo – redes encontradas em minha residência .
Nomes das Redes, canal WIFI usado e o nível de transmissão em dBms.

Para entender alguns detalhes do uso do ESP8266 com a Arduino IDE,


recomendo que leia essa documentação:
Documentação de Referência – ESP8266
Informações sobre as Bibliotecas já instaladas na IDE e mais algumas não
instaladas, poderá encontrar no Link:
Bibliotecas ESP8266 – Arduino IDE
Sobre a Biblioteca ESP8266WIFI :
Biblioteca ESP8266WiFi
Sobre o primeiro Sketch a ser rodado no NodeMCU ESP12 , veja as funções do
SCAN WIFI :
Biblioteca Arduino WIFI – classe SCAN
NodeMCU ESP-12 acessando o relógio da WEB
Mais um exemplo para você testar o WIFI do NodeMCU ESP-12, acessando a
rede WIFI do seu roteador. Eu escolhi um dos exemplos do GitHub Arduino
Libraries , um sketch para o ESP8266 acessar o relógio do servidor NTP do
Brasil.
GitHub Arduino-Libraries
NTP é um protocolo para sincronização dos relógios dos computadores
baseado no protocolo UDP da Internet. Ao acessar o servidor NTP, o
computador ou Microcontrolador poderá acertar o relógio. O horário padrão dos
servidores NTP é o UTC (Tempo Universal Coordenado). Portando ao acessá-
lo, é necessário ajustar a hora com o desvio da sua região.
Informações sobre NTP
Esses são os desvios de horário das regiões do Brasil :
Por exemplo = horário de Brasília (inverno) UTC – 3 Horas

Imagem : Fusos Horários no Brasil – Wikipedia


No Brasil , os relógios podem ser sincronizados através de alguns servidores
que estão no site https://ntp.br/
Servidores NTP.br

a.st1.ntp.br 200.160.7.186 e 2001:12ff:0:7::186

b.st1.ntp.br 201.49.148.135
c.st1.ntp.br 200.186.125.195

d.st1.ntp.br 200.20.186.76

a.ntp.br 200.160.0.8 e 2001:12ff::8

b.ntp.br 200.189.40.8

c.ntp.br 200.192.232.8

gps.ntp.br 200.160.7.193 e 2001:12ff:0:7::193

Para rodar o Sketch, será necessário instalar uma Biblioteca que não esta
instalada na Arduino IDE. Boa oportunidade para aprender como instalar uma
nova Biblioteca !
Conecte o NodeMCU ESP-12 no seu computador. Abra a Arduino IDE e veja se
a configuração da placa esta correta. Para instalar a nova Biblioteca, clique
em Sketch > Incluir Biblioteca > Gerenciar Bibliotecas .

Após abrir a janela do Gerenciador de Biblioteca, refine a busca digitando ntp.


Na biblioteca NTPClient, clique em More Info e depois em Instalar. Após alguns
segundos, ela será automaticamente instalada. Na imagem abaixo essa
biblioteca já esta instalada. Lembre-se que o seu computador precisa estar
conectado na internet. Após a instalação da Biblioteca, é necessário que feche
e abra novamente o programa Arduino IDE.
Tudo pronto para você carregar o exemplo. Fiz algumas alterações no exemplo
da Biblioteca NTPClientdo GitHub Arduino Libraries, alterando o nome para
o servidor NTP do Brasil e ajustando o relógio para o horário de Brasília (UTC –
3).
Exemplo Advanced NTPClient
Esse é o Sketch já configurado para o Brasil .
IMPORTANTE : No sketch abaixo, você deverá alterar o nome do seu roteador
WIFI (ssid) e a senha do roteador (password) também. Digite entre as aspas,
exemplo = “eletrogate”.
Sketch ESP8266_NTPclock.ino
NodeMCU ESP-12 acessando o relógio da WEB
Arduino
1 /* NodeMCU ESP-12 acessando o relógio da WEB
2 Arduino IDE 1.8.5 - ESP8266
3 Gustavo Murta 08/mar/2018
4 baseado em
5 https://github.com/arduino-libraries/NTPClient/blob/master/examples/Advanced/Advanced.ino
6 Blog Eletrogate http://blog.eletrogate.com/nodemcu-esp12-usando-arduino-ide-2/
7 */
8
9 #include <NTPClient.h>
10 // Biblioteca https://github.com/arduino-libraries/NTPClient
11 #include <ESP8266WiFi.h>
12 // Biblioteca https://github.com/esp8266/Arduino/tree/master/libraries/ESP8266WiFi
13 #include <WiFiUdp.h>
14 // Biblioteca https://github.com/esp8266/Arduino/tree/master/libraries/ESP8266WiFi
15
16 const char *ssid = "roteador WIFI"; // nome do seu roteador WIFI (SSID)
17 const char *password = "senha do WIFI"; // senha do roteador WIFI
18
19 WiFiUDP ntpUDP;
20 // Definindo o Servidor de relogio NTP Brasil, ajusta relogio UTC -3 horas, intervalo de atualizacao em milisegundos
21 NTPClient timeClient(ntpUDP, "gps.ntp.br", -3 * 3600, 60000);
22
23 void setup()
24 {
25 Serial.begin(115200); // print no Serial Monitor da IDE
26 WiFi.begin(ssid, password); // acessando a rede WIFI
27
28 while ( WiFi.status() != WL_CONNECTED ) // aguardando a conexão WEB
29 {
30 delay ( 500 ); // aguarda 0,5 segundos
31 Serial.print ( "." );
32 }
33 timeClient.begin();
34 }
35
36 void loop()
37 {
38 timeClient.update(); // atualiza o relogio
39 Serial.println(timeClient.getFormattedTime()); // print do relogio da WEB
40 delay(1000); // atraso de um segundo
41 }
Após compilar e carregar o programa no NodeMCU (clique no botão Carregar),
abra a janela da console (Serial Monitor) da IDE. Clique no botão Monitor
serial e altere a velocidade para 115200 Bps na barra inferior da janela. O
horário atual deverá aparecer na tela, a cada segundo .

Guia completo do NodeMCU – ESP12 –


Alarme Residencial IOT
Nesse tutorial NodeMCU – ESP12 – Alarme
Residencial IOT (3), você verá :
 O que é IOT – Internet das Coisas ?
 Aplicativo TELEGRAM.
 Instalando o TELEGRAM.
 Configurando o BOT do TELEGRAM.
 Instalando Bibliotecas Arduino para o TELEGRAM.
 Testando o NodeMCU-ESP12 com o TELEGRAM.
 Projeto Alarme Residencial IOT.

O que é IOT – Internet das Coisas ?


Para quem nunca ouviu falar em Internet das Coisas – IOT (Internet of Things) é
uma nova tecnologia que interliga aparelhos às pessoas, através da internet e
que esta se tornando muito popular. Os aparelhos ou dispositivos podem enviar
ou receber dados e comunicar-se com os usuários . A Internet das Coisas
emergiu dos avanços de várias áreas como sistemas embarcados,
comunicação e sensoriamento. Os estudos indicam que tudo e todos estarão
interconectados através da Internet em um breve futuro.
Muita gente no Brasil já tem o seu Smartphone. Os aplicativos como todo
mundo sabe, tem facilitado muito a nossa vida. Várias empresas tem criando
aplicativos para se aproximarem dos clientes e facilitar a comunicação com os
mesmos.
IOT faz a conexão entre aparelhos e pessoas, pode ser através de aplicativos,
Plataformas IOT ou mesmo através de paginas da WEB. Muitas Plataformas
IOT estão sendo criadas para servirem de link entre as pessoas e os seus
dispositivos. Grandes empresas como a Google, IBM e Microsoft já criaram
suas plataformas IOT. A previsão é de que bilhões de dispositivos sejam
interligados e essas empresas estão de olho nesse mercado. Veja que algumas
plataformas são grátis e outras são pagas para uso, além de um limite
determinado. Para você ter uma ideia das Plataformas IOT hoje existentes, veja
essa lista :
Lista de Plataformas IOT – 2018
Eu imagino aplicações práticas e úteis para IOT, como :
– Monitoramento de alarme residencial – imagine você receber uma mensagem
no Smartphone – alguém tentou invadir a sua casa – veja a foto do invasor.
Pode ficar tranquilo, o invasor desistiu e foi embora.
– Porteiro residencial remoto – Você esta no trabalho e recebe essa mensagem
no Smartphone- O entregador do correios esta na sua porta – quer falar com ele
? Posso autorizar o recebimento ? Ai abre uma caixa grande automática, para o
carteiro deixar a encomenda.
– Monitoramento de água em casa – Você recebe essa mensagem no
smartphone e no email – Sr morador, baseando-se em gastos mensais de água
em sua residência, existe uma possibilidade de vazamento. Sugiro que faça
uma verificação.
– Monitoramento de energia : Você recebe essa mensagem no smartphone – Sr
morador, a casa esta vazia e o ferro de passar continua ligado. Deseja que ele
seja desligado ?
Acho que é por aí ! Usem a criatividade e façam projetos úteis que possam
facilitar as nossas vidas.

Aplicativo TELEGRAM:
Ao estudar sobre IOT para desenvolver esse tutorial, fiquei em dúvida sobre
qual plataforma IOT eu usaria. Existem centenas de Plataformas IOT, e cada
uma tem um jeito de usá-la. Não existe ainda uma Plataforma muito popular ou
padrão. Essa Tecnologia é nova e está em pleno desenvolvimento.
Por isso escolhi usar o TELEGRAM . TELEGRAM é um aplicativo de troca de
mensagens concorrente do Whatsapp. Você pode usar o aplicativo no
smartphone (Android e IOS) e também no seu PC (Windows, MAC ou Linux) !
O uso é grátis e muito simples ! E para ajudar na escolha, o TELEGRAM tem
um BOT que permite fazer a conexão IOT . É muito legal e fácil de usar.
Definição de BOT – Wikipedia:
“Bot, diminutivo de robot, também conhecido como Internet bot ou web robot, é
uma aplicação de software concebida para simular ações humanas repetidas
vezes de maneira padrão, da mesma forma como faria um robô.”
Plataforma TELEGRAM BOT
Com o BOT do TELEGRAM , você poderá receber mensagens dos dispositivos
(nesse caso, o NodeMCU) e enviar comandos, através do seu Smartphone ou
PC !

Instalando o TELEGRAM:
Se você usa um Smartphone Android ou um IPHONE, instale o aplicativo
através da Google Play ou da Apple Store:
TELEGRAM na Google Play
TELEGRAM na Apple Store
Após a instalação do TELEGRAM, se preferir usar a língua portuguesa, entre
em Configurações > Idioma e altere para Portugês (Brasil). O Menu fica na parte
superior lado esquerdo ( três riscos). Crie o seu usuário – o uso é grátis.
Para facilitar a instalação e configuração do TELEGRAM BOT , instale o
Aplicativo Desktop também no seu PC :
TELEGRAM para Windows, MAC e LINUX
No Telegram Desktop para alterar para português, entre em Configurations>
change language.
Após a instalação e configuração do TELEGRAM , vai descobrir que muitos
amigos e conhecidos seus já são usuários do TELEGRAM. Da forma que você
pode conversar com os seus amigos, você poderá “conversar” também com
o BOT, através de comandos. No link abaixo, você poderá entender melhor
como funciona o BOT.
BOTs – introdução para desenvolvedores

Configurando o BOT do TELEGRAM :


Para poder criar um novo usuário BOT , é necessário acessar o usuário BOT
Pai (BotFather) . Sugiro que faça todo esse procedimento no TELEGRAM
Desktop no seu PC. Pois assim ficará mais fácil, copiar as informações
necessárias.
Na janela do TELEGRAM Desktop, procure o usuário BotFather. Veja que
existem outros usuários com nomes similares. Clique no usuário BotFather.

Na janela do BotFather, na linha de comandos (parte inferior) clique


em Começar. Vai aparecer uma lista de comandos do BotFather. Digite /help se
precisar de ajuda. Todos os comandos do BOT devem começar com uma
barra /. Veja alguns comandos :
 /newbot – para criar um novo BOT
 /mybots – para editar seus BOTs
 /setcommands – criar e alterar os comandos
 /deletebot – para apagar um BOT
Para criar o seu BOT , digite o comando /newbot . Após a primeira
pergunta, insira o nome do seu BOT. Se o seu nome já existir, use um outro
nome , como por exemplo (no meu caso):
GustESP8266
Na segunda pergunta, digite o nome do seu novo usuário. O nome do usuário
deve terminar com bot. Se o seu nome já existir, use um outro nome , como por
exemplo :
GustESP8266bot
Se o usuário foi criado com sucesso, aparecerá a mensagem ” Done!” . Veja
que uma chave TOKEN foi criada. Essa chave deverá ser copiada, pois será
inserida no Sketch do NodeMCU ESP12 !
Use this token to access the HTTP API (exemplo):
123456789:ABCDEFGHIJKLMOPQRST-ABCDEFGHIJKLMNO

OK ! Já criamos o BOT e o usuário no TELEGRAM.

Instalando as Bibliotecas Arduino para o


TELEGRAM:
Obs importante = antes de fazer esses procedimentos, execute todos os
procedimentos do Tutorial :
NodeMCU – ESP12 – Usando Arduino IDE (2)
Dessa forma, a biblioteca ESP8266 e a conexão WIFI deverão ser testadas
antes.
Para usar o NodeMCU-ESP12 com o TELEGRAM, será necessário a
instalação de duas Bibliotecas na Arduino IDE:
 ArduinoJson
 Universal Arduino Telegram Bot
Vamos instalar essas duas Bibliotecas, usando o Gerenciador de Bibliotecas.
Abra a Arduino IDE, já configurada para o NodeMCU-ESP12. Se ainda não
configurou, veja o segundo tutorial :
NodeMCU – ESP12 – Usando Arduino IDE (2)

Para instalar a nova Biblioteca, clique em Sketch > Incluir Biblioteca > Gerenciar
Bibliotecas . Na janela do Gerenciador de Bibliotecas, refine a busca
digitando arduinojson. Clique em more info e depois em instalar.

Vamos instalar agora a segunda biblioteca UniversalTelegramBot com o mesmo


procedimento acima. Refine a busca digitando telegram. Clique em more info e
depois em instalar.
Após a instalação das duas Bibliotecas, é necessário que feche e abra novamente o
programa Arduino IDE, para efetivar as Bibliotecas.

Pronto, Arduino IDE preparada !

Testando o NodeMCU-ESP12 com o TELEGRAM:


Para testarmos a comunicação do Aplicativo TELEGRAM com o NodeMCU-
ESP12, usaremos um Sketch baseado em um exemplo da Biblioteca Universal
Arduino Telegram Bot. Sabemos que o Led azul da placa NodeMCU está
conectado no pino GPIO_16. Um pulso LOW(0V) acionará esse led. Portanto,
através de comandos no TELEGRAM, faremos o Led azul acender e apagar.
Sketch exemplo – Flash Led

Programa de teste do NodeMCU-ESP12 com o TELEGRAM :


Sketch Flash Led Telegram.ino
IMPORTANTE : No sketch abaixo, você deverá alterar o nome do seu roteador
WIFI (ssid) e a senha do roteador (password) também. Digite entre as aspas,
exemplo = “eletrogate”.
Na linha do programa #define BOTtoken, insira a chave Token (entre aspas) que
foi copiada quando gerou o seu usuário BOT através do BotFather. Exemplo:
“123456789:ABCDEFGHIJKLMOPQRST-ABCDEFGHIJKLMNO”
ESP822 - Flash LED com Telegram
C++
1 /* ESP822 - Flash LED com Telegram
2 Arduino IDE 1.8.5 - ESP8266
3 Gustavo Murta 13/mar/2018
4 baseado em https://github.com/witnessmenow/Universal-Arduino-Telegram-
5 Bot/blob/master/examples/ESP8266/FlashLED/FlashLED.ino
6 Blog Eletrogate http://blog.eletrogate.com/nodemcu-esp12-alarme-residencial-iot-3/
7 */
8
9 #include <ESP8266WiFi.h>
10 #include <WiFiClientSecure.h>
11 #include <UniversalTelegramBot.h>
12
13 // Inicializando a conexao WIFI com o Roteador
14 char ssid[] = "beloca"; // nome do seu roteador WIFI (SSID)
15 char password[] = "a1b2c3d4e5"; // senha do roteador WIFI
16
17 // Inicializa o BOT Telegram - copie aqui a chave Token quando configurou o seu BOT - entre aspas
18 #define BOTtoken "528420337:AAHLwwVuklQ2P8mbUh5-7CdIgq7mSzy5uYI" // sua chave Token Bot
19
20 WiFiClientSecure client;
21 UniversalTelegramBot bot(BOTtoken, client);
22
23 int Bot_mtbs = 1000; // tempo entre a leitura das mensagens
24 long Bot_lasttime; // ultima mensagem lida
25 bool Start = false;
26
27 const int ledPin = 16; // GPIO_16 do LED azul
28 int ledStatus = 0;
29
30 void handleNewMessages(int numNewMessages)
31 {
32 Serial.print("Mensagem recebida = ");
33 Serial.println(String(numNewMessages));
34
35 for (int i = 0; i < numNewMessages; i++)
36 {
37 String chat_id = String(bot.messages[i].chat_id);
38 String text = bot.messages[i].text;
39
40 String from_name = bot.messages[i].from_name;
41 if (from_name == "") from_name = "Guest";
42
43 if (text == "/ledon") // comando Ledon
44 {
45 digitalWrite(ledPin, LOW); // acende LED azul
46 ledStatus = 1;
47 bot.sendMessage(chat_id, "LED esta aceso", ""); // envia mensagem
48 }
49
50 if (text == "/ledoff") // comando Ledoff
51 {
52 ledStatus = 0;
53 digitalWrite(ledPin, HIGH); // apaga LED azul
54 bot.sendMessage(chat_id, "LED esta apagado", ""); // envia mensagem
55 }
56
57 if (text == "/status") // comando estado do LED
58 {
59 if (ledStatus) {
60 bot.sendMessage(chat_id, "LED esta aceso", "");
61 } else {
62 bot.sendMessage(chat_id, "LED esta apagado", "");
63 }
64 }
65
66 if (text == "/start") // comando comeca
67 {
68 String welcome = "Bem-vindo a Biblioteca Universal Arduino Telegram Bot, " + from_name + ".\n";
69 welcome += "Esse é um exemplo de controle do Led.\n\n";
70 welcome += "/ledon : para acender o LED\n";
71 welcome += "/ledoff : para apagar o LED\n";
72 welcome += "/status : mostra o estado do LED\n";
73 bot.sendMessage(chat_id, welcome, "Markdown");
74 }
75 }
76 }
77
78 void setup() {
79 Serial.begin(115200);
80
81 WiFi.mode(WIFI_STA); // Configura o WIFI do NodeMCU para modo estação
82 WiFi.disconnect(); // desconecta o WIFI
83 delay(100); // atraso de 100 milisegundos
84
85 Serial.print("Conectando Wifi: ");
86 Serial.println(ssid);
87 WiFi.begin(ssid, password);
88
89 while (WiFi.status() != WL_CONNECTED) // aguardando a conexão WEB
90 {
91 Serial.print(".");
92 delay(500); // atraso de 0,5 segundos
93 }
94 Serial.println("");
95 Serial.println("WiFi conectado"); // WIFI conectado
96 Serial.print("IP address: ");
97 Serial.println(WiFi.localIP());
98
99 pinMode(ledPin, OUTPUT); // configura o pino do LED como saida
100 delay(10);
101 digitalWrite(ledPin, HIGH); // inicializa o LED como apagado
102 }
103
104 void loop()
105 {
106 if (millis() > Bot_lasttime + Bot_mtbs) // controlando as mensagens
107 {
108 int numNewMessages = bot.getUpdates(bot.last_message_received + 1);
109
110 while (numNewMessages) // numero de novas mensagens
111 {
112 Serial.println("Resposta recebida do Telegram");
113 handleNewMessages(numNewMessages);
114 numNewMessages = bot.getUpdates(bot.last_message_received + 1);
115 }
116
117 Bot_lasttime = millis();
118 }
}
Copie o Sketch acima na Arduino IDE. Conecte a placa NodeMCU no seu PC.
Certifique-se que ela foi reconhecida. Após compilar e carregar o programa
no NodeMCU-ESP12 (clique no botão Carregar), abra a janela da console
(Serial Monitor) da IDE. Clique no botão Monitor serial e altere a velocidade
para 115200 Bps na barra inferior da janela.
No aplicativo TELEGRAM (poderá testar no seu PC ou no seu Smartphone) ,
procure pelo nome do seu usuário BOT . No meu caso GustESP8266. Clique no
nome para abrir a janela de comunicação. Clique em Começar para iniciar os
testes. Sempre que executar algum comando, aguarde alguns segundos para
obter a resposta !
Comandos para teste (pode clicar em cima dos comandos já digitados) :
 /ledon – para acender o LED
 /ledoff – para apagar o LED
 /status – para mostrar o estado do LED
 /start – para inciar a comunicação

Projeto NodeMCU ESP-12 – Alarme Residencial


IOT:
Esse projeto de Alarme Residencial IOT é experimental. Verifique questões de
segurança, e crie soluções se houver necessidade.
Nesse projeto, a placa NodeMCU ESP-12 será transformada em um Alarme
Residencial IOT. Será usado somente um sensor de disparo, no caso um botão
(conectado no pino D5 / GPIO_14). Mas esse botão poderá ser substituído por
um outro tipo de sensor, como um sensor Infra-vermelho de movimento ou um
sensor com contato magnético, etc. É possível acrescentar um número maior de
sensores, para isso deverá fazer a implementação dos mesmos no programa. O
LED Azul da placa NodeMCU será usado para visualização do alarme
disparado. Quando o alarme for disparado, o LED azul acenderá. O projeto é o
mais básico possível para facilitar o entendimento do mesmo. Mas à partir dele,
poderá incluir um buzzer sonoro e muito mais outros recursos! Use sua
criatividade.
Esse Alarme NodeMCU poderá ser controlado remotamente através do
aplicativo TELEGRAM, tanto pelo smartphone como pelo seu PC. Você
receberá uma mensagem, quando o Alarme for disparado. Poderá desativá-lo
ou ativá-lo também através de comandos no TELEGRAM. É claro, para que ele
possa enviar as mensagens, deverá ter acesso à internet (NodeMCU deverá
estar conectado através do roteador WIFI).
Veja a foto do NodeMCU-ESP12 montado em Protoboard:
 Alimentação 3,3V – fio amarelo => fileira superior do Protoboard
 Terra(GND) – fio preto => fileira inferior do Protoboard
 Botão (sensor) – fio preto => fileira inferior do Protoboard
 Botão (sensor) – fio azul => pino D5 do NodeMCU
 Resistor 10K ohms – fileira superior do Protoboard => botão

Foto : Gustavo Murta


Esse é o Sketch de exemplo que eu me baseei para fazer uma parte do
programa que eu desenvolvi para o Alarme. A outra parte eu me baseei no
exemplo anterior – Flash Led.
Sketch exemplo – Push-notifications-Arduino-ESP8266
Programa Alarme Residencial IOT – NodeMCU-ESP12 / TELEGRAM :
ESP8266AlarmeIOT.INO
IMPORTANTE : No sketch abaixo, você deverá também alterar o nome do seu
roteador WIFI (ssid) e a senha do roteador (password) . Digite entre as aspas,
exemplo = “eletrogate”.
Na linha do programa #define BOTtoken, insira a chave Token (entre aspas) que
foi copiada quando gerou o seu usuário BOT através do BotFather. Exemplo:
“123456789:ABCDEFGHIJKLMOPQRST-ABCDEFGHIJKLMNO”
Você deverá preencher o CHAT ID na linha de programa #define CHAT_ID
“123456789”. Insira o número entre as aspas. Para obter o CHAT ID, acesse o
usuário IDBot no Telegram e digite /getid.

ESP822 - NodeMCU Alarme Residencial IOT


C++

1 /* ESP822 - NodeMCU Alarme Residencial IOT


2 Arduino IDE 1.8.5 - ESP8266
3 Gustavo Murta 14/mar/2018
4 Baseado em:
5 https://github.com/witnessmenow/push-notifications-arduino-esp8266/blob/master/PushNotificaitonDemo.ino
6
7 https://github.com/witnessmenow/Universal-Arduino-Telegram-Bot/blob/master/examples/ESP8266/FlashLED/FlashLED.ino
8
9 Blog Eletrogate:
10 http://blog.eletrogate.com/nodemcu-esp12-alarme-residencial-iot-3/
11
12 Você pode copiar, distribuir e modificar o software desde que as modificações sejam descritas e licenciadas gratuitamente em
13 LGPL-3.
14 As obras derivadas (incluindo modificações ou qualquer coisa vinculada estaticamente à biblioteca) só podem ser
15 redistribuídas no LGPL-3,
16 mas as aplicações que utilizam a biblioteca não precisam ser.
17 */
18
19
20 #include <UniversalTelegramBot.h>
21 #include <ESP8266WiFi.h>
22 #include <WiFiClientSecure.h>
23
24 // Configurando a conexao WIFI com o Roteador
25 char ssid[] = "beloca"; // nome do seu roteador WIFI (SSID)
26 char password[] = "a1b2c3d4e5"; // senha do roteador WIFI
27
28 #define TELEGRAM_SENSOR_PIN D5 // Sensor de disparo do alarme => D5 = GPIO_14
29
30 // Inicializa o BOT Telegram - copie aqui a chave Token quando configurou o seu BOT - entre aspas
31 #define BOT_TOKEN "528420337:AAHLwwVuklQ2P8mbUh5-7CdIgq7mSzy5uYI" // sua chave Token Bot
32
33 #define CHAT_ID "157461061" // Para obter o Chat ID, acesse Telegram => usuario IDBot => comando /getid
34
35 // cliente SSL necessario para a Biblioteca
36 WiFiClientSecure client;
37
38 UniversalTelegramBot bot(BOT_TOKEN, client);
39
40 String ipAddress = "";
41 volatile bool telegramSensorPressedFlag = false;
42 const int ledPin = 16; // GPIO_16 do LED azul
43 int alarmeAtive = 0; // Alarme Ativado
44 int alarmeTriggered = 0; // Alarme disparado
45 int Bot_mtbs = 1000; // tempo entre a leitura das mensagens
46 long Bot_lasttime; // ultima mensagem lida
47 //bool Start = false;
48
49 void setup()
50 {
51 Serial.begin(115200);
52
53 // Inicializa o botao e o LED
54 pinMode(TELEGRAM_SENSOR_PIN, INPUT); // define o Sensor de disparo como entrada
55 pinMode(ledPin, OUTPUT); // configura o pino do LED como saida
56 delay(10);
57 digitalWrite(ledPin, HIGH); // inicializa o LED como apagado
58
59 // interrupcao no Sensor pino D5 dispara Alarme
60 attachInterrupt(TELEGRAM_SENSOR_PIN, telegramSensorPressed, RISING);
61
62 WiFi.mode(WIFI_STA); // Configura o WIFI do NodeMCU para modo estação
63 WiFi.disconnect(); // desconecta o WIFI
64 delay(100); // atraso de 100 milisegundos
65
66 Serial.print("Conectando no Wifi: ");
67 Serial.println(ssid);
68 WiFi.begin(ssid, password);
69 while (WiFi.status() != WL_CONNECTED) // aguardando a conexão WEB
70 {
71 Serial.print(".");
72 delay(500); // atraso de 0,5 segundos
73 }
74 Serial.println("");
75 Serial.println("WiFi conectado !"); // WIFI conectado
76 Serial.print("IP address: ");
77 IPAddress ip = WiFi.localIP();
78 Serial.println(ip); // imprime Endereco IP
79 ipAddress = ip.toString();
80
81 }
82
83 void telegramSensorPressed()
84 {
85 if (alarmeAtive) // Se o alarme estiver ativado
86 {
87 Serial.println("Alarme disparado!");
88 int sensor = digitalRead(TELEGRAM_SENSOR_PIN); // verifica estado do sensor
89 if (sensor == HIGH)
90 {
91 telegramSensorPressedFlag = true; // Sensor do Alarme foi acionado
92 digitalWrite(ledPin, LOW); // acende LED azul do Alarme
93 alarmeTriggered = 1; // Alarme disparado
94 }
95 }
96 return;
97 }
98
99 void sendTelegramMessage() {
100 String message = "Alarme Residencial disparado !";
101 message.concat("\n");
102 message.concat("Zona 1 - portão da garagem");
103 message.concat("\n");
104 message.concat("SSID: ");
105 message.concat(ssid);
106 message.concat(" IP: ");
107 message.concat(ipAddress);
108 message.concat("\n");
109 if (bot.sendMessage(CHAT_ID, message, "Markdown"))
110 {
111 Serial.println("Mensagem Telegram enviada com sucesso");
112 }
113 telegramSensorPressedFlag = false;
114 }
115
116 void handleNewMessages(int numNewMessages)
117 {
118 Serial.print("Mensagem recebida = ");
119 Serial.println(String(numNewMessages));
120
121 for (int i = 0; i < numNewMessages; i++)
122 {
123 String chat_id = String(bot.messages[i].chat_id);
124 String text = bot.messages[i].text;
125
126 String from_name = bot.messages[i].from_name;
127 if (from_name == "") from_name = "Guest";
128
129 if (text == "/alarmeon") // comando Ativa Alarme
130 {
131 alarmeAtive = 1; // ativa alarme
132 alarmeTriggered = 0; // desliga disparo do Alarme
133 bot.sendMessage(chat_id, "Alarme foi Ativado !", ""); // envia mensagem
134 }
135
136 if (text == "/alarmeoff") // comando Desativa Alarme
137 {
138 alarmeAtive = 0; // desativa alarme
139 alarmeTriggered = 0; // desliga disparo do Alarme
140 digitalWrite(ledPin, HIGH); // apaga LED azul Alarme
141 bot.sendMessage(chat_id, "Alarme foi Desativado !", ""); // envia mensagem
142 }
143
144 if (text == "/status") // comando estado do Alarme
145 {
146 if (alarmeAtive) // Se o alarme estiver ativado
147 {
148 bot.sendMessage(chat_id, "Alarme está Ativado", "");
149 }
150 else
151 {
152 bot.sendMessage(chat_id, "Alarme está Desativado", "");
153 }
154 if (alarmeTriggered) bot.sendMessage(chat_id, "Alarme está Disparado !", "");
155 }
156
157 if (text == "/start") // comando comeca
158 {
159 alarmeAtive = 1; // ativa alarme
160 String welcome = "Alarme Residencial IOT operacional, " + from_name + ".\n";
161 welcome += "Alarme foi Ativado!\n\n";
162 welcome += "/alarmeon : para ativar Alarme\n";
163 welcome += "/alarmeoff : para desativar Alarme\n";
164 welcome += "/status : mostra o estado do Alarme\n";
165 bot.sendMessage(chat_id, welcome, "Markdown");
166 }
167 }
168 }
169
170 void loop()
171 {
172 if ( telegramSensorPressedFlag )
173 {
174 sendTelegramMessage();
175 }
176 if (millis() > Bot_lasttime + Bot_mtbs) // controlando as mensagens
177 {
178 int numNewMessages = bot.getUpdates(bot.last_message_received + 1);
179
180 while (numNewMessages) // numero de novas mensagens
181 {
182 Serial.println("Mensagem recebida do Telegram");
183 handleNewMessages(numNewMessages);
184 numNewMessages = bot.getUpdates(bot.last_message_received + 1);
185 }
186 Bot_lasttime = millis();
}
}

Copie o Sketch acima na Arduino IDE. Conecte a placa NodeMCU no seu PC.
Certifique-se que ela foi reconhecida. Após compilar e carregar o programa
no NodeMCU-ESP12 (clique no botão Carregar), abra a janela da console
(Serial Monitor) da IDE. Clique no botão Monitor serial e altere a velocidade
para 115200 Bps na barra inferior da janela.
No aplicativo TELEGRAM, procure pelo nome do seu usuário BOT . No meu
caso GustESP8266. Clique no nome para abrir a janela de comunicação. Clique
em Começar para inicializar o Alarme. Sempre que executar algum comando,
aguarde alguns segundos para obter a resposta !
Comandos do Alarme Residencial IOT (pode clicar em cima dos comandos já
digitados) :
/alarmeon : para ativar Alarme
/alarmeoff : para desativar Alarme
/status : mostra o estado do Alarme
/start : para reiniciar o Alarme
Essa é uma tela do TELEGRAM para exemplificar o uso do Alarme. Ativei o
Alarme clicando em Começar. Apertei o botão do sensor – Alarme foi
disparado e o LED azul acendeu. Dei o comando de /status e apareceu as
mensagens : Alarme Ativado e Alarme Disparado ! Dei o
comando /alarmeoff para desativar o alarme. Para ativar novamente o alarme,
dê o comando /alarmeon.
Através da Console da Arduino IDE (Monitor Serial), poderá monitorar todas as
atividades do Alarme Residencial IOT (fase de testes).