Como instalei o firmware de desenvolvimento para extrair mais do ESP8266, exemplificando em um ESP01 e em uma placa industrial chinesa.

O ESP8266 é um versátil e barato chip que inclui um potente microcontrolador, generosa quantidade de RAM, suporte interno a serviços de comunicação serial como SPI, I2C e UART, 16 pinos GPIO digitais, uma entrada analógica, e seu grande diferencial para aplicações IoT: suporte a WiFi bastante completo e fácil de usar.

A foto acima mostra o popular módulo ESP01 (é a plaquinha verde – a vermelha é um adaptador USB-Serial FTDI Basic). O ESP01 custa poucos dólares lá fora, com alguma pesquisa pode ser encontrado por menos de R$ 20 para pronta entrega em pequenas quantidades no Brasil, e é uma das placas mais simples para começar a interagir com as plataformas baseadas no chip ESP8266.

Mesmo recente, o ESP8266 já está presente em uma série placas populares, e em algumas placas de desenvolvimento que vêm pipocando conforme a plataforma começa a atrair a atenção em cada vez mais grupos técnicos.

Acima você vê alguns dos modelos de ESP8266 que estão na minha bancada. Na fileira de cima, o da esquerda é o singelo ESP-01, com seus 8 pinos fáceis de manusear, e o da direita é uma placa industrial chinesa baseada no ESP12, que expõe 16 pinos – e eu usei ambas para os exemplos deste artigo de hoje.

Bem mais desempenho e memória do que você está acostumado no típico Arduino Uno.

Quando uso os adjetivos destacando a CPU do ESP8266, a comparação que me vêm à cabeça é com o Arduino Uno – que me atende muito bem, mas é bastante modesto¹. Vamos a um pequeno quadro comparativo com dados extraídos das especificações do ESP8266:

Toda essa capacidade adicional coloca os módulos ESP em uma categoria diferente, pois eles estão aptos a rodarem ambientes interativos com interpretadores e suporte incorporado a APIs de linguagens modernas, como o NodeMCU (relativamente maduro, e oferecendo a linguagem Lua) e o MicroPython (ainda em fase inicial de adaptação ao ESP). Desde o começo de 2015, é possível também desenvolver nativamente para o ESP8266 usando a IDE do Arduino.

Mas não me entenda mal: as diferenças em termos de recursos não são demérito ao Arduino, e essa nova série de aprendizados que estou tendo com o ESP em modo standalone não teria acontecido se antes eu não tivesse passado por várias rodadas em que me limitei a usar ESP8266 no papel de um mero acessório (ou seja, como módulo WiFi para um Arduino), como narrei nos artigos a seguir:

1. ESP8266 do jeito simples: conexão ao Arduino, acesso à rede WiFi e resposta a ping
2. Servidor web WiFi com Arduino e ESP8266
3. Melhor canal para o WiFi da sua casa: o Arduino e o ESP8266 indicam

Para uma breve introdução aos recursos desse hardware, recomendo uma visita a eles!

Entendendo o NodeMCU

A plataforma NodeMCU foi iniciada em 2014, menos de um ano após o começo das vendas do ESP8266, e é composta por um firmware que roda no ESP8266 transformando-o num ambiente de execução da linguagem Lua contendo uma série de recursos adicionais para uso embarcado, e uma placa de desenvolvimento (de uso opcional) baseada no popular módulo ESP-12.

A imagem acima mostra um dos modelos do módulo de desenvolvimento do NodeMCU – note que na sua parte superior está presente um módulo ESP-12 completo. Além de apresentar os pinos do ESP-12 em uma configuração fácil de plugar em protoboards ou outros recursos de prototipação, o módulo de desenvolvimento também oferece, entre outros confortos, a regulação de tensão, uma porta USB para a comunicação USB-serial, um botão de reset e um botão 'flash', cujo pressionamento coloca o ESP8266 no modo de upload de firmware.

Os módulos de desenvolvimento feitos para o NodeMCU são interessantes, mas você também pode usar uma placa ESP8266 “comum”.

Mas o uso desse hardware é opcional. Tendo alguns jumpers e um adaptador USB-serial à mão (até um Arduino Uno pode fazer esse papel!), é possível instalar o firmware NodeMCU na maioria dos módulos ESP8266, desde os modestos ESP01 até os avançados como o ESP12 e a cada vez maior gama de derivados e placas de desenvolvimento.

Lua no ESP8266 com o NodeMCU

O NodeMCU está intimamente ligado à linguagem Lua que, curiosamente, é um projeto brasileiro nascido em 1993 na PUC-Rio, criado para ser fácil de embutir em outros ambientes, exatamente como ocorre no NodeMCU.

Por ser uma linguagem de programação voltada a aplicações especiais, é possível que você nunca tenha ouvido falar nela – mas saiba que ela é popular em seu nicho, sendo a linguagem de extensão escolhida para softwares de grande popularidade, como o Adobe Lightroom, o World of Warcraft e o Angry Birds. Ela é frequentemente apontada como a mais rápida entre as linguagens interpretadas, é open source, pequena, altamente portável nas mais diversas plataformas, e tem um manual de referência gratuito e bastante completo.

A linguagem Lua foi criada no Brasil na década de 1990, e é popular para acrescentar recursos e expansibilidade em uma série de plataformas, incluindo softwares como o World of Warcraft e o Adobe Lightroom.

Uma API bastante completa, com suporte a WiFi, TCP/IP, UDP, MQTT, i2c, SPI, tratamento de arquivos, timer, gpio, socket, one-wire, JSON e mais, está disponível no NodeMCU e facilmente acessível pela Lua.

Para exemplificar a sintaxe, vou mostrar uma forma de lidar com pinos de I/O digitais no NodeMCU. As operações são similares às que ocorrem no Arduino: você define o modo do pino, e aí envia o estado HIGH ou LOW para ele:

gpio.mode(2,gpio.OUTPUT)
gpio.write(2,gpio.HIGH)
gpio.write(2,gpio.LOW)

Em seu modo mais simples, o firmware NodeMCU transforma o ESP8266 em um ambiente interativo que você acessa por meio de um terminal serial, digitando expressões e comandos em Lua e vendo seu resultado, on-line. A partir daí, é possível aumentar a complexidade transferindo programas em Lua para execução pelo NodeMCU, ou mesmo instalando uma IDE tradicional.

É interessante perceber uma das diferenças profundas entre o modelo de desenvolvimento do Arduino e do NodeMCU: no Arduino, o seu programa é transferido para o microcontrolador na forma de firmware, e no NodeMCU o próprio ambiente NodeMCU é o firmware, e o seu programa é enviado a esse firmware para ser executado por ele.

Instalando o NodeMCU num ESP-01 e numa placa de desenvolvimento

Ao contrário do que acontece na família Arduino, em que as placas têm diferenças profundas de configuração para transferência de firmwares, os variados módulos ESP até o momento são baseados em chips ESP8266 com pouca variação entre si, e a pinagem necessária para a transferência nas placas mais básicas é a mesma das placas mais avançadas.

Assim, o NodeMCU pode ser instalado em módulos ESP8266 comuns e em placas de desenvolvimento usando basicamente o mesmo procedimento. Para testar, eu o instalei no tradicional e básico ESP01 (foto acima) e em uma placa de desenvolvimento "industrial" chinesa como esta (ver foto abaixo), que é alimentada por 3 pilhas AA e remove um dos problemas mais comuns nos relatos de testes com o NodeMCU: as instabilidades causadas por eventual corrente insuficiente quando a alimentação é via USB.

A pinagem do ESP01 é bem conhecida e já a descrevi neste artigo, enquanto a placa de desenvolvimento veio com ZERO documentação, mas é bem simples – construídos ao redor de um ESP12E estão:

• 2 barras de terminais para acesso direto aos pinos originais do ESP12 (sem os adicionais da versão 12E),
• um led RGB com suas 3 cores controláveis via PWM conectadas aos pinos GPIO12, GPIO13 e GPIO15,
• um LDR conectado à porta de entrada analógica,
• leds controláveis via software (que acendem quando o respectivo pino está LOW) conectados aos pinos GPIO0, GPIO2, GPIO4, GPIO5, GPIO14 e GPIO16,
• um conjunto de 3 terminais (GND, TXD e RXD) que dá acesso direto à serial (UART), e que merecem atenção especial, porque as identificações estão trocadas, sendo que o pino marcado como TXD na verdade é o RXD, e vice-versa.
• um jumper que vem fechado de fábrica fazendo o pull-up do pino CH_PD

Como não havia documentação disponível, encontrei os detalhes acima sobre a minha placa específica observando screenshots do vendedor e depois testando continuidade com um multímetro...

São 3 passos para a instalação: obter o firmware, mais o hardware e software necessários para o upload, e transferir.

Para fazer a instalação do firmware do NodeMCU eu segui um roteiro com 3 passos principais, tanto no ESP01 quanto na placa de desenvolvimento descrita acima:

1. Obter uma versão atualizada e personalizada, já compilada, do firmware do NodeMCU
2. Instalar em meu computador o simplíssimo utilitário esptool.py
3. Usando o esptool.py e um módulo USB-Serial, transferir para a minha placa o firmware do NodeMCU

Apresentarei a seguir alguns detalhes de cada um dos 3 passos.

Download do nodemcu-master.bin

O firmware do NodeMCU pode ser compilado sob medida, incluindo apenas os elementos da API que você pensa em usar em cada projeto, liberando o restante do espaço para seus dados e programa.

Eu usei o site NodeMCU custom builds, no qual você preenche o seu e-mail e a lista de módulos que deseja incluir, e em alguns minutos recebe um e-mail indicando a URL de onde pode baixá-lo – o serviço se encarrega de compilar, sob medida para você, tudo prático e gratuito.

Você pode encomendar no site uma versão do firmware nodemcu.bin só com os recursos que pretende usar – o link chega por e-mail logo após.

No meu caso, para os testes gerais que pretendo fazer, montei um firmware bastante conservador e amplo, a partir da árvore master e incluindo os módulos node, file, GPIO, WiFi, net, PWM, I2C, SPI, timer, ADC, UART, 1-wire, bit, MQTT, U8G, cJSON e suporte a SSL.

Em poucos minutos recebi por e-mail o link para download do arquivo nodemcu-master.bin, em duas versões: com aritmética em ponto flutuante ou com aritmética de inteiros. Optei pelo segundo, menor e mais rápido, que disponibilizei para meu próprio uso neste ZIP (mas recomendo que você gere o seu próprio).

Instalação do esptool.py

Existem vários flashers ou ferramentas de upload de firmwares para o ESP8266, que servem igualmente para instalar o NodeMCU ou para fazer upgrade/downgrade do firmware original (que oferece os tradicionais comandos AT).

Algumas são exclusivas para Windows, outras são em Java, e elas têm variados graus de usabilidade e maturidade. Para meu próprio uso, optei pelo espartano esptool.py, do qual fiz download na forma de um único arquivo em Python, tornei executável (chmod a+x esptool.py, se você estiver usando Mac ou Linux, que usualmente já vêm com o Python e demais dependências instalados) e a partir daí pude rodar via linha de comando, como descreverei adiante.

Usuários de Windows que se sintam à vontade com Python também podem usar a mesma ferramenta, ou então investigar a alternativa oficialmente indicada pelo NodeMCU, chamada NodeMCU Flasher (que eu não conheço, pois não uso a plataforma). Existem várias outras alternativas também – para outras plataformas, em outras linguagens, com outros hardwares de suporte, e até para transferir os dados via WiFi. Nada contra você preferir alguma delas, desde que não espere que eu também a conheça, indique ou saiba usar :)

Pinagem para o upload do NodeMCU para o ESP8266

Com todos os requisitos de software já no lugar, é hora da montagem física.

Usei um conversor USB-Serial² como o deste artigo, mas poderia ter usado um Arduino para fazer o papel dele, como descrevi neste outro artigo.

A conexão física é simples, mas no caso da minha placa de desenvolvimento precisei tomar providências devido aos pinos erroneamente designados (TXD trocado com RXD, como descrevi acima).

A pinagem para upload de firmware para o ESP8266 é como segue, tanto para o ESP01 quanto para a placa de desenvolvimento:

Detalhando:

• O pino RXD do conversor vai no pino TXD do ESP8266 (que, no caso específico da minha placa "industrial", veio erroneamente identificado como RXD³).
• O pino TXD do conversor vai no pino RXD do ESP8266 (que, no caso específico da minha placa "industrial", veio erroneamente identificado como TXD).
• O pino GND do conversor vai no pino GND do ESP8266.
• O pino 3V3 do conversor vai no pino 3V3 do ESP01 (no caso do módulo de desenvolvimento isso não é necessário, pois ele usa pilhas).

Os pinos acima podem ficar permanentemente conectados, sem maiores problemas. Mas na hora em que você for fazer um upload, deve garantir que os pinos do ESP8266 a seguir estejam em estados específicos:

* O estado do GPIO15 e GPIO2 só precisará ser considerado se esses pinos estiverem expostos na sua placa. Se eles não estiverem acessíveis, desconsidere-os sem medo.

Detalhando:

• GPIO0: LOW (conectado ao GND). Este pino seleciona o modo do boot. Sempre que o GPIO0 estiver em LOW quando você liga ou reseta a placa, o ESP8266 entrará em modo de recepção de um novo firmware. Se estivesse em HIGH, o ESP8266 ligaria e executaria o firmware que já estiver carregado. Algumas placas de desenvolvimento têm uma chave ou botão associados a este pino, para facilitar ⁴. Este é o único pino cuja configuração você precisa alterar após carregar o firmware.
• CH_PD: HIGH (conectado a 3,3V)
• GPIO15 (se estiver exposto na sua placa): LOW (conectado ao GND)
• GPIO2 (se estiver exposto na sua placa): HIGH (conectado a 3,3V)

Tanto a imagem acima, quanto a imagem que abre este artigo, mostram o ESP01 conectado a um módulo FTDI Basic usado como o conversor USB-Serial. Na imagem acima as conexões dos pinos acontecem diretamente com uma combinação de jumpers fêmea-fêmea e jumpers macho-fêmea, e na foto que abre o artigo eu usei uma plaquinha adaptadora "caseira" que permite plugar o ESP01 a uma protoboard e usar apenas jumpers macho-macho.

Em ambos os casos eu usei uma fonte externa de 3,3V para alimentar o ESP01, mas você pode usar a alimentação do seu conversor USB-serial, se ele tiver um pino 3V3 ou você se encarregar de converter a tensão.

Enviar o NodeMCU para o ESP8266

Após garantir os estados⁵ acima, basta resetar (ou desligar/ligar) o ESP8266, e emitir num terminal o comando a seguir:

esptool.py -p /dev/tty.usbserial-A703TQT1 write_flash 0x000000 nodemcu.bin

No trecho em verde substitua o caminho da porta correspondente ao seu conversor USB-Serial, e no trecho em vermelho coloque o caminho e nome completos do arquivo .bin do seu firmware, que pode ser bem maior que o do exemplo: o do meu caso era nodemcu-master-16-modules-2015-08-22-16-23-40-integer.bin...

O comendo acima, quando bem-sucedido, demora alguns segundos executando, e gera mensagens como estas:

É possível que na sua plataforma ou configuração sejam necessários parâmetros adicionais ou mais passos, confira a documentação do esptool para saber detalhes⁶, ou como alternativa siga o link da ferramenta ~oficial~ de upload, mencionada acima.

Testando o NodeMCU

Com a conclusão bem-sucedida dos 3 passos acima, o NodeMCU estará instalado no seu ESP8266, pronto para receber comandos. Na prática, você terá interesse em passos adicionais, como instalar um ambiente de desenvolvimento, ou enviar programas em Lua para execução.

Veremos mais detalhes sobre esses passos em artigos posteriores. Hoje, entretanto, faremos apenas o teste mínimo: uma conexão serial para enviar comandos Lua em modo interativo.

Para isso, é necessário manter as conexões entre o adaptador USB-Serial como descritas acima, e ligar o ESP8266 com o pino GPIO0 em HIGH (ou seja, fora do modo de upload de firmware).

No modo mais básico, você se conecta ao ESP8266 via terminal serial do seu computador, e digita nele comandos em Lua.

A partir dessa inicialização, basta usar um programa terminal serial, como o Coolterm (no Mac), Putty (no Windows), minicom (no Linux), o monitor serial da IDE do Arduino, ou outro de sua preferência, para conectar (velocidade 9600, N-8-1) à porta serial do seu adaptador USB – a mesma usada no trecho em verde no comando descritos acima –, recebendo um singelo prompt de comando na forma de um ">", como se nunca tivéssemos saído da década de 1980. Se o prompt não aparecer, experimente pressionar a tecla Enter e, se tudo estiver certo, ele será exibido.

Aí é só digitar os comandos em Lua que você souber usar. Um exemplo básico, que não precisa de nenhum hardware especial (nem mesmo um led!) conectado ao esp, é simplesmente digitar o comando node.restart(), que vai provocar um reset que, em seguida, mostra um breve ruído e algumas linhas de informações sobre o firmware instalado, assim:

Caso você tenha esquecido o GPIO0 no estado LOW usado para instalar o firmware, não vai funcionar ;-) Neste caso, conecte o GPIO0 ao pino 3V3, e tente novamente!

Já no exemplo abaixo, eu acendi e apaguei 2 vezes o led conectado ao pino 2 da minha placa de desenvolvimento (funcionaria igualmente se eu conectasse um led e resistor adequados ao pino GPIO2 do ESP01):

Essencialmente, o efeito é a alternância entre os 2 modos mostrados abaixo:

Na continuidade, dê uma olhada nos exemplos de código em Lua para o ESP8266 que constam na capa do site do NodeMCU: tem um servidor e um cliente web, um servidor Telnet, um exemplo de criação de arquivo de inicialização, a definição de um timer, e mais.

Em breve voltaremos ao tema, falando na instalação de uma IDE e na programação do NodeMCU em Lua, em artigos adicionais – aguarde!