Produto final com ESP8266 - Electro Dragon

produto final com esp8266

Você pode ser mestre em ESP8266, compila seu próprio firmware, escreve seu próprio programa e faz seu próprio circuito, mas seu ponto fraco pode ser justamente onde se tem que investir muito; o acabamento. Como tornar um ESP8266 em um produto de prateleira?

Pense em um ESP8266 12F controlando 2 relés. Claro, não é difícil, mas as coisas começam a complicar conforme se necessita integração. Você vai corroer o circuito em casa? Vai mandar fazer sua placa na china e esperar voltar depois de um tempão? Vai interligar o ESP8266 a um módulo relé com jumpers? E a caixa disso? Vai usar as Patolas quadradonas? - Aí que entra o Electro Dragon.

Mesmo que você não seja um especialista, mesmo que seja apenas um curioso desejando automatizar alguma coisa em sua casa, você não terá problemas em fazê-lo com a Electro Dragon. E melhor, é um produto com case bonito que pode ser exposto na sua casa sem que você passe vergonha. Além disso , ele garante a segurança contra choque elétrico, uma vez que tem uma bela proteção na borda, mas suas características são muitas, então entremos em detalhes.

Onde comprar

Esse produto é mais uma novidade trazida pela MASUGUX (clique aqui para ver a lista de produtos) e você tem acesso direto a ele através desse link.

Características da Electro Dragon

Como você pode ver na foto, o dispositivo é pequeno e bonito, não dando a menor ideia do que se trata até que se veja dentro. Só que dentro tem mais coisas interessantes.

Para mim, a alegria começa na beleza da conexão. O módulo possui uma fonte interna, portanto você entra direto com AC, tirando da tomada para a placa, sem precisar de fonte externa. Isso é ótimo pois facilita a instalação em qualquer lugar que não tenha tomada.

Na pinagem da imagem da esquerda estão dispostos ADC para leitura analógica (até o máximo de 1V de tensão) e os pinos para que se possa gravar um novo firmware no ESP8266. Acima os botões para entrar no modo de gravação. Dos GPIO, utiliza-se apenas o 12 e o 13 para os relés, conforme você pode ver na imagem da direita.

Na board você vê também um lugar para o DHT22, cujo módulo já está ativo por padrão, portanto você não precisa programar nada até aqui e ainda obterá temperatura e umidade se dispuser de um DHT22 por ai.

Atenção: O pinout do header próximo à tensão AC varia conforme o modelo, mas está silkado sobre a placa, não tem erro.

Cuidado ao manipular o dispositivo

A tensão de entrada está correndo livre pela fonte aberta e por baixo do circuito. Não me envergonho em dizer que tomei uma série de choques e já perdi as contas de quantos foram, além do show pirotécnico que desligou meu disjuntor. Se for manipular o dispositivo aberto, mantenha-o sobre a plataforma como um bumper e não toque na fonte a não ser que esteja sofrendo uma parada cardíaca.

Firmware

O firmware original é NodeMCU, portanto qualquer programação será em LUA. Nesse caso, você pode usar o ESPlorer IDE para subir seus programas e arquivos nele. Se não conhece o ESPlorer, recomendo esse artigo onde brinco com NodeMCU e MQTT. O ESPlorer serve também para MicroPython e todos os próximos tutoriais com MicroPython será nessa IDE.

Claro que você pode subir seu próprio firmware, mas se você não quer ter nenhum trabalho, esse módulo vem pronto para uso. Inclusive para configuração pelo smartphone.

Conexão FTDI

Primeira coisa que tenho a citar é que você não precisa e não deve estar com a board ligada na corrente alternada para programá-la. Apenas os 5V do FTDI já é o suficiente para alimentar o ESP8255 e bater o relay. Evite sustos, choques e curtos enquanto desenvolve.

Na verdade é uma mera conexão serial. Para essa conexão você não precisa ligar na alimentação AC, basta que seu FTDI ofereça 5V para bater os relés e de resto é tranquilo. Com 3V3 Não dá pra gravar o ESP8266 porque ele fica resetando, então atente-se em colocar seu FTDI em 5V e conectá-lo ao pino de 5V, não ao de 3V3!

Os pinos de comunicação são comumente invertidos, portanto atente-se que TX--->RX e RX-----TX. T de "transmitter" e R de "receiver". Um envia e o outro recebe. O caminho reverso funciona do mesmo modo; um envia e o outro recebe. Capiche?

A conexão está na velocidade de 9600, portanto não esqueça de configurar adequadamente seu programa de comunicação serial, seja a IDE ESPlorer, GTKTerm, CuteCom, minicom, screen...

IoT Espressif

Vá ao Play Store e procure por "IoT Espressif". Instale o programa e ignore as telas em chinês. No final do artigo tem um video mostrando a configuração do app para controlar o módulo utilizando Smartconfig e então colocá-lo em uma nuvem com MQTT. Eu tenho meu próprio broker, mas vou colocá-lo na nuvem sugerida para ter controle pela internet.

MQTT com MyMQTT ou MQTT Dashboard

Esses são os dois apps que eu utilizo para gerenciar minha rede MQTT em casa. Sugiro que para maior conforto, utilize o MQTT Dashboard.

Esse é o conjunto de coisas que você precisa para brincar com esse dispositivo. Agora vamos ao passo-a-passo.

Teste inicial

A primeira coisa que você "deve" fazer é conectá-lo à tomada tão logo tenha colocado um cabo de energia nele. Não se preocupe, não precisa comprar um cabo novo, basta cortar o cabo daquele seu eletrodoméstico velho que está pegando poeira. Depois, ligando-o à tomada você verá o self test dele. Ele baterá duas vezes os relés e então apenas o LED vermelho na lateral continuará intermitente.

Configuração

Primeiro passo, ligar o dispositivo na rede; elétrica e WiFi, claro. Assim, procure fazer a ligação do dispositivo à rede elétrica e então instale os aplicativos descritos acima. Após os dois blinks, o dispositivo entra em modo de espera pelo smart config. Após configurá-lo pelo smartconfig, você poderá utilizar MQTT para fazer seu controle. Se você não tem (e não pretender ter) um broker configurado em casa, ainda resta a opção de utilizar a nuvem.

Conectado ao console serial, consegui ver o que o dispositivo estava fazendo, então ficou mais claro pra mim que quando o dispositivo começa a piscar o LED de forma lenta, ele já conseguiu conexão. Mas é bom estar fazendo o debug pra entender, porque o dispositivo não apareceu no smartconfig, mas o smartconfig funcionou mesmo assim.

Quando vi o IP, tive que confirmar na página do meu roteador wifi (que usa o DDWRT que eu instalei e me dá uma ótima página de gerenciamento da minha rede. Se quiser trocar o firmware do seu roteador, veja esse tutorial).

Nas próximas inicializações do módulo o IP já estará atribuido, então você não precisa mais se preocupar em repetir a configuração.

Agora entra o aplicativo que fará a conexão com o broker. Não se preocupe com os conceitos de MQTT agora, mas se quiser, dê uma olhada no site que você encontrará tudo o que precisa sobre MQTT. Para agora, apenas siga o tutorial.

MQTT Dashboard

É um dos aplicativos que utilizo para gerenciar minha rede IoT em casa e é o que utilizarei nesse passo a passo. Pegue-o nesse link do Play Store.

Meu corretor ortográfico "corrigiu" cloudmqtt para "cliente", mas é só você não deixar que isso aconteça, veja o video.

As credenciais são:

No campo "client ID" normalmente pode ser qualquer coisa, mas é possível configurar para aceitar apenas um determinado client ID. Eu coloquei a meu critério, mas a conexão em hipótese alguma se estabeleceu. Então fui trocando o client ID (porque era a única coisa que não estava conforme esperado) até que coloquei por última opção ESP_ABD123 (ABD123 é fictício, coloquei o final do MAC, o nome do dispositivo foi formado por ESP e sufixo, parte do MAC). Não funcionou também. Não acredito que eu tenha errado em nada porque eu tenho um broker em minha casa e até minha porta eu abro por MQTT. Provavelmente alguma credencial desse servidor deve ter se modificado ou talvez no dia de hoje esteja dando algum problema.

Logo após a conexão, você precisará ainda subscrever-se a um tópico. Então subscreva-se ao tópico "Light1" para interagir com seu dispositivo, enviando para o tópico o final do MAC conforme disponibilizado pelo seu dispositivo (só aquela parte ABD123, mas que realmente seja do seu dispositivo, não vá mandar "ABD123"!). Feito isso, sua board reiniciará e mudará para o modo de controle MAC. Tendo acontecido, use essa parte de MAC como tópico agora. No seu aplicativo você poderá então criar os botões para manipular os relés. Os comandos para publicar são:

"1ON", "1OFF", "2ON" e "2OFF". Simples assim.

Usando MQTT

Porém, vou dar meus 2 centavos de opinião. Se você colocar esse dispositivo na nuvem, certamente sera hackeado pois a conexão não usa SSL. É tudo aberto pra você e para o mundo, é facílimo interceptar o que seu dispositivo está fazendo e a que comandos ele reage, por isso minha sugestão é que se você for usar o NodeMCU que está nele, que não seja para conectar com o MQTT na nuvem. Faça seu próprio broker ou então contrate um serviço de MQTT na nuvem.

Para configurar o servidor é simples, ainda mais se você tem um Raspberry por aí (meu broker está configurado no Raspberry). Para isso, siga esse tutorial que escrevi mostrando como configurar um broker MQTT.

Já escrevi também como configurar o NodeMCU para se conectar a seu broker, então deixo esse link do artigo que escrevi para que você possa configurar seu Electro Dragon ao seu próprio broker.

GitHub MASUGUX

Antes de seguir, gostaria de deixar aqui o repositório git criado para nosso parceito MASUGUX, onde códigos dos artigos relacionados ao parceiro estarão disponíveis, portanto, não será necessário que você copie os códigos abaixo.

Alguns exemplos com LUA

Não escondo o quanto gosto de MicroPython e confesso que só não fico com NodeMCU porque não gosto da sintaxe da linguagem LUA, mas se você não se opõe a utilizá-lo, fique com ele. É uma linguagem fácil como Python e de quebra o NodeMCU tem muito mais bibliotecas prontas do que o MicroPython. Se precisar, consulte aqui a documentação. Vou deixar uns dois ou três exemplos programando através da IDE ESPlorer.

Hierarquia dos scripts de inicialização

Para evitar que tenha problemas e para iniciar seu código em tempo de boot, existem alguns arquivos no sistema de arquivos do NodeMCU que você deve levar sempre em consideração. Outra coisa que pode ser ideal é digitar o código diretamente no terminal ou então subir um script e executá-lo, porque se seu programa entrar em modo de bloqueio, bastará reiniciar o ESP8266 e apagar ou substituir o script problemático. A Ordem de inicialização é a seguinte:

config.lua

Esse arquivo conterá apenas constantes que serão utilizadas nos demais scripts. Por exemplo:

-- WiFi setup
MySSID    = "DobitAoByte"
MyPASSWD  = "http://www.manualdomaker.com"
STATION   = wifi.STATION


-- MQTT
MQTT_CLIENTID = "ElectroDragon"
MQTT_HOST     = "192.168.1.230"
MQTT_PORT     = 1883

-- LED
LED_PIN = 2
ON      = 1
OFF     = 0

print("Global vars loaded")

Como você pode ver "-- qualquer coisa" é um comentário. As demais são variáveis simples.

init.lua

O arquivo init.lua apenas fará o start do programa. É o último a subir, porque se você cometer um erro agora, pode dar mais trabalho que eventualmente você teria fazendo na ordem descomplicada. Quando você garantir que seu script está devidamente funcional, simplesmente inclua-o nesse script. e ele iniciará junto com o sistema, se for o caso.

print("http://www.manualdomaker.com")
dofile("init_man.lua")

Um simples print seguido da inclusão de um arquivo que está no filesystem. Ou você poderia incluir código diretamente nele, mas não é o propósito desse arquivo.

init_main.lua

O init.lua fará a chamada desse script, como você pode notar. Fazê-lo desse modo lhe permite testar fazendo dofile() na caixa de comando do ESPlorer ou Ctrl+S para subir-e-executar. Nesse arquivo você escreve tudo o que quiser, inclusive o que deseja que fique em loop. Ou ainda, pode incluir nele outro ou outros arquivos que compuram funções específicas, inclusive o que prende em um loop.

Blink inicial do ElectroDragon

Esse blink do LED é feito com algo parecido com esse código (que modifiquei do original, porque você não ficaria motivado a programar em Lua vendo o código original, acredite).

dofile("config.lua")

local M = {}

function M.fast()
    gpio_16    = 0
    gpio_blink = false

    gpio.mode(gpio_16,gpio.OUTPUT)

    function toBlink()
        if not gpio_blink then
            gpio_blink = true
            gpio.write(gpio_16,gpio.HIGH)
        else
            gpio_blink = 0
            gpio.write(gpio_16.gpio.LOW)
        end
    end

    tmr.alarm(2,500,1,toBlink())

end

return M

Repare que no código acima está sendo utilizado um timer que chama uma função, de modo que não interfere no fluxo do código. Depois esse script é inserido no init.lua, que contém esse código:

LED = require "LEDblink"

print("set up wifi mode")
wifi.setmode(wifi.STATION)
wifi.sta.autoconnect(0)

-- se quiser testar o smartconfig, desconecte a board primeiro

wifi.sta.disconnect()

tmr.alarm(1,600,1,function()
    if wifi.sta.getip() == nil then
        print("Waiting for smartconfig, IP unabailable...")
        
        wifi.startsmart(0, 
            function(ssid,password)
            print(string.format("Sucess. SSID: %s; PASSOWRD: %s, ssid,password))
        end)
        LED.fast()
    else
        tmr.stop(1)
        tmr.stop(2)
        print("Config done, IP is" ..wifi.sta.getip())
 
        wifi.stopsmart()
 
        dofile("mqtt2.lua")    
    end
end)

Eu sei, é horrível criar um timer e declarar a função dentro dele. Depois no outro timer, o cara ainda quebra mais uma vez a linha pra ficar mais feio ainda, mas enfim, esse é o código que ele escreveu no init.lua.

Repare também que o smartconfig é um recurso disponível de forma explícita no Lua, então se gostar de brincar com o smartconfig, pode ser uma boa forma de iniciar o dispositivo em um rede qualquer, já que a configuração ficará genérica, bastará que o cliente instale o programa IOT Espressif no celular e adicionar de forma transparente o ElectroDragon à sua respectiva rede WiFi.

No final do init.lua ele faz o include do MQTT, mas esse vai buscar um servidor na nuvem. Está bem simples reconfigurá-lo para conectar ao seu próprio broker ou então a outro endereço desejado na nuvem.

print("Running file mqtt")
tmr.delay(100000)

gpio12 = 6

gpio.mode(gpio12,gpio.OUTPUT)
gpio.write(gpio12,gpio.LOW)

gpio13 = 7
gpio.mode(gpio13,gpio.OUTPUT)
gpio.write(gpio13.gpio.LOW)

--mqtt.Client(clientid, keepalive secs [, username, password, cleansession])
m = mqtt.Client("nodemcu",120,"swqzxzhr","9JMcxVeUNz3t")

-- last will e testamento, blabla, nao se incomode:
m:lwt("/lwt","offline",0,0)

m:on("connect",function(client)print("connected")end)
m:on("offline",function(client)print("offline")end)

-- evento do on_publish recebido...
m:on("message",function(conn,topic,data)
    print(topic..":")
    if topic == "light1" then
        if data == "ON" then
            print("received message: ON@light1")
            gpio.write(gpio12,gpio.HIGH)
        else
            print("receive OFF liked data in light1")
            gpio.write(gpio12,gpio.LOW)
        end
    else
        if topic == "Light2" then
            print("received message: ON@light2")
            gpio.write(gpio13.gpio.HIGH)
        else
            print("received OFF liked data in light2")
            gpio.write(gpio13,gpio.LOW)
        end
    end
  end
end)

m:connect("m11.cloudmqtt.com",19311,0,funtion(conn)
    print("connected")
    m:subscribe({["Light1"]=0,["Light2"]=0},function(conn)
        print("subscribe Light 1 and 2 sucess")
    end)
end)

Me perdoem os amantes de Lua, mas acho o código muito incomum. De qualquer modo, aqui podemos ver que os dados de conexão MQTT diferem dos dados de conexão citados mais acima e nem um e nem outro funcionam. Logo, descarte esses dados de conexão, faça seu broker ou conecte  a uma outra nuvem, caso queira deixar isso de forma pública e acessível ao mundo. Mas dos males, o menor. Por aí já vemos quais os GPIO utilizados para ativar os relés, de forma que agora ficou fácil você manipular os relés e o LED em qualquer outro ambiente.

Mais sobre MQTT com Lua, você pode ver diretamente na documentação clicando aqui.

Trocando o firmware NodeMCU por MicroPython

Para gravar um novo firmware até que é bastante prático. Basta que você pressione o BTN2 e ligue a board (segurando-o, claro). Depois é só fazer o upload do firmware com seu flasher preferido. Se for subir outro firmware NodeMCU, seu flasher utiliza a velocidade de 115200 e se encontra nesse link.

O firmware MicroPython que compilei também está no repositório git MASUGUX (clique para ir ao repositório).

O ideal é que antes de subir o firmware, você formate o ESP8266. Instale a ferramenta esptool.py e siga essas linhas de exemplo:

1 - Limpar o firmware atual.

Reinicie a board tirando o FTDI. Novamente aperte o BTN2 antes de reconectar o USB, então conecte o cabo e solte o botão para entrar em modo de gravação (o mesmo processo para a limpeza).

2 - Escreva o novo firmware. Especialmente para essa board foi um pouco complicado encontrar a configuração correta e tive que fazer várias vezes o processo até encontrar o formato. Enfim, o comando ficou assim:

sudo apt-get install esptool

#supondo /dev/ttyUSB0 - veja qual a sua porta
esptool.py --port /dev/ttyUSB0 erase_flash

#agora fazendo o flashing
esptool.py --port /dev/ttyUSB0 --baud 115200 write_flash --flash_size=detect -ff 40m -fm qio 0x0 firmware-combined.bin

Reinicie a board e voilá! MicroPython, pronto para ser programado.

Alguns exemplos com MicroPython

E já que trocamos o firmware, vamos ver como controlar esse hardware com MicroPython.

Configurar WiFi

Faça a conexão e siga o procedimento para configurar seu ESP8266 para conectar-se à sua rede WiFi. Vou descrever o processo, mas já escrevi a respeito nesse artigo de dicas sobre MicroPython.

import network

sta_if = network.WLAN(network.STA_IF)

sta_if.active(True)

if sta_if.active():
    sta_if.connect('SuaRede','SuaSenha')
    sta_if.ifconfig()

if not sta_if.isconnected():
    print("Ops...")

Desculpe o preciosísmo, mas estou deveras viciado em tratamento de erro, também o propósito é permitir que você crie uma função para configuração de rede no ESP8266.

Blink do LED (blink_led.py)

Repare que ao subir o firmware MicroPython, o LED vermelho fica aceso direto, só que invés de manipular esse LED, vamos brincar com o LED azul do ESP8266.

from machine import Pin
from time import sleep_ms
ledBlue = Pin(2,Pin.OUT) # ja vai acender

def myBlink(ledToBlink):
    ledToBlink.high() #apagou
    #use apenas para teste
    sleep_ms(1000)
    ledToBlink.low()
    sleep_ms(1000)

for i in range(5):
    myBlink(ledBlue)

É um exemplo ordinário, se precisar fazer algo do tipo, use uma função com ticks, como eu fiz nesse artigo na sessão "Evite o uso de delays".

Bater os relés (relays.py)

Não vamos reescrever a rotina do fabricante, não é mesmo? Apenas um teste de como bater os relés e depois fica por sua criatividade.

Tomando o exemplo em LUA, já sabemos que os pinos de GPIO são os gpio 12 e 13. No microPython é um pouco mais direta a configuração. Vou exemplificar apenas batendo o relé, que é basicamente o que você precisará para utilizar esse dispositivo.

from machine import Pin
from time import sleep_ms

relay_one = Pin(12,Pin.OUT)
relay_two = Pin(13,Pin.OUT)

relays = [relay_one,relay_two]

for relay in relays:
    relay.high()
    sleep_ms(1000)
    relay.low()

Flashing pela IDE do Arduino

E como não poderia faltar nessa IDE feia, porém funcional, eis que o suporte estará lá, desde que você inclua as boards do ESP8266.

Na seleção de board escolha:

• Generic ESP8266 Module
• Flash Mode "QIO"
• Flash Frequency: "40MHz"
• Upload Using: "Serial"
• CPU Frequency: "80 MHz"
• Flash Size: "512K (no SPIFFS)"
• Reset Method: "ck"
• Upload Speed: "115200"
• Port: "a porta depende do sistema, etc"

E um código para fazer o blink:

void setup(){
    pinMode(BUILTIN_LED,OUTPUT);
}

void loop(){
    digitalWrite(BUILTIN_LED,LOW);
    delay(1000)
    digitalWrite(BUILTIN_LED,HIGH);
    delay(1000);
}

Mas sério, em Examples-->ESP8266 você encontra o código do blink, só coloquei alguma coisa aqui de cabeça, abra o exemplo e veja como está.

Com todos esses exemplos, não há razão para você não ter um desses, hum? Afinal, o ESP8266 te dá além da rede WiFi, a possibilidade de rodar NodeMCU, MicroPython, Sming, programar na IDE ESPlorer ou na IDE do Arduino, Atom etc. E olhe que nem falei do slot para DHT11/22...

Inscreva-se no nosso canal Manual do Maker no YouTube.

Também estamos no Instagram.