Dicas rápidas de ESP8266 com MicroPython

Decidi escrever esse artigo porque as dicas importantes sobre o MicroPython estão muito esparramadas em meus artigos, sendo que as cito conforme as vou utilizando. às vezes precisamos só de um determinado comando ou procedimento, mas não lembramos onde vimos aquilo alguma vez, por isso quis concentrar tudo em um post que receberá atualização conforme eu for lembrando ou aprendendo mais coisas.

O sistema de arquivos

Rodando o MicroPython, você tem um acesso muito fácil ao sistema de arquivos na flash, onde você pode salvar seus scripts escritos no computador ou diretamente no terminal do MicroPython. Para acessar o sistema de arquivos eu escrevi um artigo de como fazê-lo através da IDE do Arduino, que você pode ver aqui. Mas com MicroPython tem maneiras mais simples de fazê-lo.

Uma delas é utilizando o WEBREPL, que te dá uma interface web ao console do MicroPython e desse modo você não precisa mais utilizar o FTDI para interagir com o sistema operacional do ESP8266.

Habilitar o WEBREPL no MicroPython

Para habilitar o recurso é bastante simples também. Basta que você esteja conectado ao ESP8266 via FTDI, onde você terá acesso ao console Python. Após, você deverá habilitar o serviço webrepl:

import webrepl_setup

Será questionado sobre a inicialização do daemon em brackground. Responda com E. Uma senha então será solicitada (uma senha curta). Eu optei por 1234, escolha a sua. Ao término, será solicitado um reboot do ESP8266 e já estará habilitado o serviço.

Download do WEBREPL

O segundo passo é clonar o git do projeto:

git clone https://github.com/micropython/webrepl.git

Depois, entre no diretório webrepl e lá você encontrará 2 importantes ítens para interagir com o MicroPython.

webrepl_cli.py

Com esse app você copia arquivos locais ou remotos para origem e destino selecionados. Veja que o próprio help da ferramenta dá exemplos claros:

python webrepl_cli.py --help
webrepl_cli.py - Perform remote file operations using MicroPython WebREPL protocol
Arguments:
  <host>:<remote_file> <local_file> - Copy remote file to local file
  <local_file> <host>:<remote_file> - Copy local file to remote file
Examples:
  webrepl_cli.py script.py 192.168.4.1:/another_name.py
  webrepl_cli.py script.py 192.168.4.1:/app/
  webrepl_cli.py 192.168.4.1:/app/script.py .

webrepl.html

Esse você deve abrir no browser para ter acesso ao console do MicroPython. Eu normalmente acesso todo o sistema operaciona do meu notebook pelo console aberto em minha interface gráfica, então estando no diretório do webrepl, eu uso o comando:

xdg-open webrepl.html

Isso já me abre o browser com a página do webrepl. Só que para acessar o console do MicroPython é necessário estar conectado ao ESP8266, que até esse momento só oferece acesso como AP. Além disso, estando como AP não há acesso à internet, que será necessário em outra dica. Vamos então à dica de configuração do WiFi no MicroPython.

Configurar WiFi AP e Station no ESP8266

Ao iniciar o ESP8266 com o firmware MicroPython você o encontrará em sua lista de redes disponíveis. Simplesmente se conecte a ele, então pelo browser (usando webrepl) você poderá acessar o console de maneira simples, clicando em "Connect". à direita da janela você tem as opções de upload e download de arquivos, que só estarão acessíveis após você se autenticar.

Após abrir o console, você já estará hábil a configurar o modo station e access point. O procedimento é feito em poucas linhas:

import network
sta_if = network.WLAN(network.STA_IF)
ap_if  = network.WLAN(network.AP_IF)

As variáveis acima são comumente utilizadas e faz todo o sentido, por isso você vai ver tanto na documentação quanto em  outros códigos a utilização igual descrita acima.

Tendo-as configuradas, você pode verificar o status das interfaces. O método para isso é o active().

sta_if.active()
False

ap_if.active()
True

Esses são os retornos comuns quando você executa pela primeira vez, porque o modo station deve ser habilitado manualmente e o modo AP deve ser removido se desejar. Para tal, utiliza-se do mesmo método, porém passando como parâmetro o boolean da condição desejada:

sta_if.active(True)

Para desabilitar uma interface, utilize o boolean 'False'. E após ter a interface ativa, você pode conectar seu ESP8266 à sua rede WiFi doméstica.

sta_if.connect('SuaRede','SuaSenha')

Para ver o IP que lhe foi atribuido, a função ifconfig está disponível para seu objeto sta_if:

sta_if.ifconfig()
('192.168.1.12', '255.255.255.0', '192.168.1.1', '192.168.1.2')

A linha abaixo do comando é a resposta, sendo IP, máscara, gateway e DNS. No meu caso, eu tenho um Raspberry Pi que fiz de servidor DNS (entre outros serviços na minha rede local), por isso o último IP é 192.168.1.12.

Se você precisar verificar a conexão, você tem um método também:

sta_if.isconnected()

Se por acaso você precisar fazer um scan em busca da rede, o seguinte comando lhe retorna uma lista com todas elas:

sta_if.scan()

Trocar o ESSID do ESP8266

O SSID é o nome que aparece quando você procura uma rede para se conectar. Normalmente o nome é algo como ESP8266_finalDoMAC ou MicroPython_finalDoMAC etc. Para colocar um nome amigável, configure a interface AP e use o comando config. Veja a configuração completa:

import network

ap_if = network.WLAN(network.AP_IF)
ap_if.active(True)
ap_if.config(essid="NomeDesejado")

Instalar módulos no MicroPython

E agora que você tem acesso à Internet, você pode também instalar módulos no seu MicroPython. Bem, exatamente agora estou tendo problemas em fazê-lo e vou descobrir o porquê, mas o procedimento é esse que vós descrevo. Alias, se você programa em Python deve conhecer a ferramenta pip. E certamente se a conhece, deve ficar feliz em saber que o MicroPython utiliza a upip.

import upip

upip.install('micropython-urllib')

Com esse comando, você instalará a urllib. Pode acontecer algum erro e o erro será retornado no terminal. Aí entra a próxima dica.

Lista de código de erros do MicroPython

Eu obtive um erro de permissão, o nome do erro nem sempre é claro, por isso uma boa pedida é ter uma lista de código de erros para consultar. Aqui está:

EPERM   = 1   # Operation not permitted
ENOENT  = 2   # No such file or directory
ESRCH   = 3   # No such process
EINTR   = 4   # Interrupted system call
EIO     = 5   # I/O error
ENXIO   = 6   # No such device or address
E2BIG   = 7   # Argument list too long
ENOEXEC = 8   # Exec format error
EBADF   = 9   # Bad file number
ECHILD  = 10  # No child processes
EAGAIN  = 11  # Try again
ENOMEM  = 12  # Out of memory
EACCES  = 13  # Permission denied
EFAULT  = 14  # Bad address
ENOTBLK = 15  # Block device required
EBUSY   = 16  # Device or resource busy
EEXIST  = 17  # File exists
EXDEV   = 18  # Cross-device link
ENODEV  = 19  # No such device
ENOTDIR = 20  # Not a directory
EISDIR  = 21  # Is a directory
EINVAL  = 22  # Invalid argument
ENFILE  = 23  # File table overflow
EMFILE  = 24  # Too many open files
ENOTTY  = 25  # Not a typewriter
ETXTBSY = 26  # Text file busy
EFBIG   = 27  # File too large
ENOSPC  = 28  # No space left on device
ESPIPE  = 29  # Illegal seek
EROFS   = 30  # Read-only file system
EMLINK  = 31  # Too many links
EPIPE   = 32  # Broken pipe
EDOM    = 33  # Math argument out of domain of func
ERANGE  = 34  # Math result not representable
EAFNOSUPPORT = 97 # Address family not supported by protocol
ECONNRESET = 104 # Connection timed out
ETIMEDOUT = 110 # Connection timed out
EINPROGRESS = 115 # Operation now in progress

Interrupções com MicroPython

Acredito que o MicroPython está realmente à altura de qualquer outro firmware, aliás, em muitos aspectos o considero superior. E claro, com todos os recursos desse firmware, não poderia faltar tratamento de interrupções. Mas não só em MicroPython como em qualquer outro firmware, CPU ou MCU, é necessário tratar as interrupções de uma forma bastante delicada, porque senão você pode interromper o fluxo do processamento e causar um WDT, forçando o reset do ESP8266 (em nosso caso). Para evitar tais problemas, o código para interrupção deve primordialmente ser sucinto de forma a evitar bloqueios ainda que temporários. A melhor maneira é a interrupção marcar uma flag para o código principal em loop e a cada volta ele reagir ao evento.

Uma outra dica é não fazer append nem usar floats na função de tratamento de interrupções. No caso de retorno de múltiplos bytes, utilize um bytearray.

Quando houver dados partilhados entre o ISR e o programa principal, matenha a interrupção desligada até que o retorno da primeira seja feita pelo programa principal, para não encadear eventos.

Buffer de emergência

Utilizar um buffer de emergência lhe permitirá um feedback da ISR. Para tal:

import micropython
micropython.alloc_emergency_exception_buf(100)

Agora olhe só que delicia o exemplo:

import micropython
from machine import Timer

micropython.alloc_emergency_exception_buf(100)
class Foo(object):
    def __init__(self, timer, led):
        self.led = led
        timer.callback(self.cb)
    def cb(self, tim):
        self.led.toggle()

timer = Timer(-1)
#LED 1
timer.init(period=300,mode=Timer.PERIODIC,callback=blinkLED(1))
#LED 2
timer.init(period=800,mode=Timer.PERIODIC,callback=blinkLED(2))

Nesse exemplo você vê como iniciar uma rotina com um intervalo predefinido. O modo está como PERIODIC para que haja repetitividade, mas se fosse para executar apenas uma vez em um determinado período, bastaria trocar PERIODIC por ONE_SHOT. O período está em milisegundos.

Evite o uso de delays

Se vocẽ precisar marcar tempo, faça o incremento de uma variável com ISR. Se não quiser utilizar ISR, você tem mais uma boa opção que é acumular tempo com os ticks do processador:

import time

acum  = time.ticks_ms()
...
loop(){
...
    delta = time.ticks_diff(time.ticks_ms(),acum)
    if delta > 10000:
        print("Passaram 10 segundos")
        acum  = time.ticks_ms()    
...
}

Quer ser cabeção e usar delay, correndo o risco de um WDT? Beleza, é só fazer assim:

import time

time.sleep_ms(10000)

E conforme for me lembrando de outras coisas importantes, vou incrementando esse artigo. Ele será de grande utilidade para outros artigos patrocinados que virão, fiquem atentos!

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

Também estamos no Instagram.