Programar ESP8266 pela interface do Arduino

Muitas pessoas pensam no ESP8266 como um componente WiFi a ser agregado a um Arduino ou PIC. Confesso que meu primeiro post sobre o ESP8266 realmente foi utilizando uma microcontroladora para gerenciá-lo e também fiz um projeto meio longo e sofrido com PIC16F883 controlando um ESP8266. Porém, agora vou iniciar esse post citando algo que poderá chocá-lo - o ESP8266 é uma CPU de 32bits que trabalha a 80MHz! Para quê então precisamos de outro dispositivo para controlá-lo, uma vez que ele oferece de 2 a vários pinos de I/O (conforme o modelo)?

Existem várias formas de programar diretamente para ele. Pode ser utilizando Micropython (link) (ainda com suporte pobre), ou usando o firmware NodeMCU (link) e programando em Lua (como citado nesse outro post que escrevi a respeito) ou ainda, programando em C/C++ diretamente da interface do Arduino, de forma transparente. Parece bom demais e sim, é bom demais! Nem o firmware padrão da Espressif precisa ser modificado, a única consideração é colocá-lo em modo flash na hora de subir o programa.

Mas não se tem fruto onde não se planta e mãos que plantam criam calos. Vamos aos calos primeiro.

Versão 1.6.5 (ou maior) da IDE do Arduino

Evite problemas. Eu os tive 2 vezes até perceber de que se tratava, então sigamos os conselhos dos sábios desenvolvedores e utilizemos a versão recomendada. Claro que a versão mais nova tem seus charmes e nada impede que a tenha para outros fins, até porque uma hora tudo estará funcionando adequadamente sobre ela.

Após baixar sua IDE em arduino.cc, descomprima-a e siga os passos descritos:

1 - Execute o Arduino

Abrindo o programa, vá diretamente em File->Preferences
Você verá uma tela assim:

O procedimento é o mesmo na IDE 2.0.

Em Aditional Board Manager, clique no canto direito e insira as URLs que lhe forem propícias. Para o ESP8266, apenas a primeira basta. Eu tenho diversas porque tenho diversos tipos de boards diferentes:

http://arduino.esp8266.com/stable/package_esp8266com_index.json
https://raw.githubusercontent.com/damellis/attiny/ide-1.6.x-boards-manager/package_damellis_attiny_index.json
http://drazzy.com/package_drazzy.com_index.json
https://raw.githubusercontent.com/wemos/WeMos_Boards/master/package_wemos.cc_index.json
https://adafruit.github.io/arduino-board-index/package_adafruit_index.json

Depois clique em Ok e siga para o segundo passo.

2 - Adicionar a board

Entre nessa sequência de Menu e sub-menu. Na IDE 2.0 do Arduino, você encontra tudo da mesma forma e adicionalmente, no menu vertical à esquerda.

Nessa última janela você já vê um monte de boards diferentes porque já as tenho instaladas. Você certamente não terá nenhuma, senão não estaria lendo essa linha do texto nesse momento. Clique em Board Manager. Aguarde até que a lista de placas seja carregada e na caixa de busca, digite esp8266, caso não tenha paciência de vasculhar. Meu sentimento diante desse menu é similar a uma mulher com a carteira cheia de cartões passeando no shopping center. Eu olhei item a item.

Quando encontrar o item que deseja instalar, dê um clique sobre ele. Se já não estiver instalado, aparecerá a opção "Install", caso contrário aparecerá "Remove".

Não me levem a mal pelo comentário, mas a IDE do Arduino (apesar de não ser realmente boa ainda) está muito legal, porque até pouco tempo era uma água de batata, não dava nem gosto de programar nela. Com esse recurso, você adicionou de forma simples e rápida o suporte à board desejada. Não pára por aí.

Instalando-o desse modo, automaticamente as boards serão carregadas no respectivo menu. Em Sketch->Include Library->Manage Libraries você adiciona as bibliotecas disponíveis através dos links oferecidos na primeira janela supracitada.

Não seja preguiçoso, navegue pelos recursos e veja o que lhe serve e o que poderá lhe servir até como idéia para um próximo projeto. Feito isso desse modo, você não terá problemas e poderá seguir para a seção de "referência de comandos" desse post. Aconteceu comigo em uma versão anterior do Linux Mint uma exceção; não foi possível instalar as bibliotecas desse modo tão automatizado, então tive que fazê-lo de forma manual, buscando pelos pacotes nos referidos repositórios.

3 - ...E se do modo automático falhou...

Você tem ainda a opção de baixar o arquivo zip ou clonar o git. Esses 2 processos não tem tanta diferença no procedimento, então suponhamos que você decida fazer pelo git (instale-o se não tiver instalado. Eu uso Debian based, então o comando é sudo apt-get install git):

wget -c http://arduino.cc/download.php?f=/arduino-1.6.5-r5-linux64.tar.xz
tar xvJf arduino*xz
ln -sf arduino-1.6.5-rc5 arduino
cd arduino/hardware && mkdir esp8266com && cd esp8266com
git clone https://github.com/esp8266/Arduino.git esp8266
cd esp8266/tools
python get.py

Dessa vez será necessário reiniciar a IDE do Arduino.

Referência de comandos

Você pode utilizar de forma transparente diversas bibliotecas da IDE como se estivesse programando para um Arduino, mas além disso quando você seleciona uma board específica, os menus em Tools se modificam um bocado.

Em minhas pesquisas, encontrei alguns exemplos da utilização do sketch de blink e fade, mas estranhamente não vi o recurso que é a espinha dorsal do ESP8266 - a conexão WiFi. Vamos a alguns exemplos e referências de comando para que tenha uma idéia do quão prazeroso pode ser programar diretamente em C/C++ para o ESP8266. Nos exemplos utilizarei o ESP-01, mas o código muda basicamente no que diz respeito aos pinos de I/O, que em boards mais completas aproveitam mais recursos do ESP8266.

Blink

Não, não vou por o blink porque o blink é o blink e o blink é a primeira coisa que todo mundo faz, não tem sentido exemplificar a programação para um processador de 32bits que roda à 80MHz acendendo um LED! A conexão WiFi também não vai demandar recursos, mas pelo menos é o carro chefe desse jóia minúscula.

Sincretismo - San Arduino e San ESP

Prometo manter o máximo possível a semelhança da informação com a documentação tentando transcrevê-la, mas de qualquer modo, gosto de tecer meus comentários no meio. Não influenciará no produto final.

Primeiro passo é ambientar-se com as semelhanças, depois absorver as diferenças. Nas semelhanças, temos a exata correspondência entre os GPIOs e para ambos podemos utilizar pinMode, digitalRead e digitalWrite. Para GPIO2, invoque digitalRead(2).

O mais interessante nesse ponto é que os pinos podem ser configurados como INPUT, OUTPUT, INPUT_PULLUP e o pino 16 adicionalmente pode ser configurado como INPUT_PULLDOWN_16.

Tal qual em Arduino ou PIC, os pinos podem ter outras funções como I2C, SPI, serial. O acesso aos recursos é feito através das bibliotecas que você inclui na IDE; como dito, de forma transparente.

Do github supracitado, uma imagem do ESP-12 mostra seus recursos e pinagem.

Os pinos de flashing não estão sendo exibidos no datagrama.

Entrada e saída analógica

O ESP8266 tem apenas um canal ADC disponível, ue pode ser utilizado pra ler tensão ou para ler a alimentação do módulo. Como em Arduino, utiliza-se analogRead, e como há apenas um pino, analogRead(A0). O que deve-se prestar muUuUUuuUUita atenção aqui é que a range é de 0v a 1v, não mais, não menos.

Para ler o VCC é bem simples e legal. Primeiramente, o pino deve (obviamente) estar desconectado. Então adiciona-se no sketch:

ADC_MODE(ADC_VCC);

Já na saída analógica, também tem um recurso interessante - perceba que você utiliza como se estivesse programando para Arduino, mas com algum recurso adicional:
AnalogWrite(pino,valor) para utilizar PWM no pino selecionado. Aqui começa a alegria, porque o pino tem 10 bits de resolução, indo de 0 à PWMRANGE, por padrão, 1023. Se quiser redefinir essa range, basta chamar analogWriteRange(novo_valor). A frequência do PWM é de 1kHz, podendo ser redefinido também, chamando a função analogWriteFreq(novaFrequencia)

Timing e delays
millis() e micros() retornam os respectivos valores passados desde o reset. delay(ms) pausa o sketch, mas permite que as tarefas de rede sejam executadas livremente. Do mesmo modo, delayMicroseconds(us) cumpre mesma tarefa, mas com um tempo menor.

A Serial no ESP-12 utiliza UART0, mapeado para os pinos GPIO1 (TX) e GPIO3 (RX), podendo ser remapeado para os pinos 15 e 13 chamando Serial.swap() após Serial.begin(). A Serial1 usa UART1 e o GPIO2 é o pino TX, mas RX não pode ser utilizado justamente por ser o pino de flashing.

As características de configuração da serial são as mesmas que para Arduino. Adicionalmente, Serial.setDebugOutput(true) ou Serial1.setDebugOutput(true) redirecionará a saída de debug novamente, uma vez que a biblioteca WiFi é desabilitada ao chamar Serial.begin. Habilitando esse debug, a saída de printf() poderá ser vista.

É motivadora a simplicidade dessa interação, não? Aí você tem as bibliotecas para adicionar mais e mais recursos. Essas referências você podia ver em um link que estava bem aqui, mas quebrou, onde uma relação enxuta porém robusta pode ser encontrada. A biblioteca de WiFi, Ticker, EEPROM, I²C, SPI, SoftSerial, APIs específicas do ESP, OneWire, servidor DNS e mais um monte de diversões podem levá-lo a muitas noites de insônia, cuidado com a diversão!

Wiring

A conexão é a mesma de sempre, através de um FTDI no caso desse exemplo. Você pode ver os detalhes nesse post. Como se trata de desenvolvimento contínuo, decidi fazer uma plaquinha focada no ESP-01, mas que permitisse utilizar qualquer outro ESP. Minha inspiração foi esse video:

https://www.youtube.com/watch?v=48JUh8Vlea4

Ou seja, o ESP estando conectado, eu pressiono o botão esquerdo e mantenho, então dou um toque no botão direito, solto-o e em seguida solto o botão esquerdo. Pronto, é só gravar! Não sei porque eu não consigo fazer só o básico, então adicionei alimentação pela USB (podendo ser fonte externa, obviamente), e um suporte a fios, caso a fonte esteja com o cabo cortado ou precise de outra tensão. Coloquei um regulador 3.3v e um barramento de 6 pinos de onde pode-se pegar 3.3v, raw (origem da fonte) e ground, para alimentar algum sensor ou algo do tipo. Se eu quiser ligar um ESP diferente do 01, é só puxar os fios pra protoboard e já era. O mesmo para o FTDI, que pode ser conectado diretamente no slot de pinos ou através de jumpers, além de que coloquei uma barra de pinos para o caso de querer puxar o FTDI para a protoboard também. Tá feio mas fiquei orgulhoso por fazê-lo.

Conexão WiFi do ESP8266 pela IDE do Arduino

No vídeo a seguir, eu demonstro a utilização da minha plaquinha (não deu pra fazer com uma mao só, perdoem-me) e subo um código só passando para Acess Point. Para voltar à rede em modo Station, o código a seguir serve perfeitamente.

Incialmente, inclua a biblioteca ESP8266WiFi em Skatch->Include Library. Depois é fácil demais:

#define MY_SSID   "suaRede"
#define MY_PASSWD "suasenha"

void setup(){
    Serial.begin(115200);
    delay(10);
    WiFi.mode(WIFI_STA); //AP,STA,AP_STA,OFF
    WiFi.softAP(MY_SSID,MY_PASSWD); //na lib do Arduino eh diferente; WiFi.begin(S,P)
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
    WiFi.printDiag(Serial); //informacoes diagnosticas
    Serial.println(WiFi.localIP());
}

E o vídeo:

https://www.youtube.com/watch?v=JXzAIPf9CoY

Esse é o código suficiente pra conexão. Exemplos mais robustos você encontra na própria IDE do Arduino.

Ticker
Essa biblioteca executa dentro de um determinado periodo de forma repetida, como um timer. Como está diretamente relacionada à interrupção, não deve-se chamar funções dentro dela, mas apenas apontar uma flag ser tratada no loop principal.

Bom, fiz esse post para descansar a mente um pouco porque estou trabalhando intensamente no próximo post, garanto que será no mínimo interessante. Agora com licença, vou retomar.

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

Próximo post a caminho!