|
| HOME PROJETOS PROGRAMAÇÃO |
Você que programa Python e também gosta de montar projetos com os microcontroladores da família ESP8266, mais precisamente o NodeMCU ESP8266, agora pode usar a linguagem Micropython adaptada para esse microcontrolador.
Este artigo não trata da linguagem Python propriamente dita mas somente de instalar uma infraestrutura de programação para os microcontroladores NodeMCU ESP8266.
Ao instalar o Micropython no NodeMCU ESP8266 e alguns outros programas no Linux, pode-se montar uma infraestrutura de programação ideal para a construção de sistemas baseados nessa família de microcontroladores.
Siga os passos abaixo para instalar os softwares necessários mas, antes de continuar, verifique se o Python está instalado no sistema com o comando:
[user@mg45]$ python -V
A instalação de softwares aqui descrita foi realizada no Fedora 28 mas pode ser usada como modelo para outras distribuições. No momento, a versão do Python instalada no meu Fedora 28 é 2.7.15.
O esptool é um programa para linha de comandos que permite o gerenciamento do ESP8266 através do terminal do Linux. Esse programa permite, por exemplo, apagar a memória flash do ESP8266 e também gravar o firmware no mesmo.
A instalação do esptool deve ser feita com o comando abaixo:
[user@mg45]$ pip install esptool
Baixar o firmware do Micropython para o NodeMCU ESP8266 do site Micropython.org, escolhendo sempre a última versão. Será baixado um arquivo com o nome parecido a "esp8266-20180511-v1.9.4.bin"
Após baixar o firmware, conecte o NodeMCU no PC através da porta USB e descubra o nome do dispositivo ttyUSB com o comando:
[user@mg45]$ ls -l /dev/ttyUSB*
Será obtido algo como:
[user@mg45]$ crw-rw---- 1 root dialout 188, 0 fev 4 09:49 /dev/ttyUSB0
O device a ser usado, no caso, será /dev/ttyUSB0.
Entre na pasta onde o arquivo do firmware foi baixado e dê o seguinte comando para apagar a memória flash do NodeMCU:
[user@mg45]$ esptool.py --port /dev/ttyUSB0 --baud 115200 erase_flash
Grave o firmware do Micropython no NodeMCU usando o comando:
[user@mg45]$ esptool.py --port /dev/ttyUSB0 --baud 115200 write_flash --flash_size=detect -fm dio 0 esp8266-20180511-v1.9.4.bin
Se durante a gravação do firmware aparecer a mensagem "Connetcing ....____....____", pressione o botão Reset do NodeMCU para que a gravação inicie.
A comunicação do PC com o NodeMCU deve ser feita através de um terminal serial. Para esta instalação escolhemos o programa picocom que é um terminal serial muito simples e fácil de instalar.
Instale o programa picocom usando o gerenciador de pacotes de sua distribuição Linux. No caso do Fedora 28, usar o comando:
[user@mg45]$ sudo dnf install picocom
No terminal do Linux, iniciar o programa picocom com o comando:
[user@mg45]$ picocom /dev/ttyUSB0 -b 115200
Ao aparecer a mensagem "Terminal ready" (figura 1) pressione o botão RESET do NodeMCU para receber o prompt ">>>" do Micropython (figura 2). Alguma sujeira pode aparecer na tela mas não se preocupe, isso é assim mesmo. Se tudo foi feito corretamente, o Micropython está pronto para uso. Tente dar alguns comandos para verificar o funcionamento, como mostram as figuras 3 e 4.
 Fig 1 - Ao iniciar o terminal serial |
 Fig 2 - Após pressionar Reset no NodeMCU |
 Fig 3 - Teste de funcionamento |
 Fig 4 - Verificando o sistema de arquivos |
O Micropython cria, na memória do NodeMCU, um sistema de arquivos no formato FAT que será usado para gravar os programas criados. Esse sistema de arquivos pode ser controlado com comandos no terminal. Entre no terminal serial do Micropython com o comando:
[user@mg45]$ picocom /dev/ttyUSB0 -b 115200
Use os comandos abaixo para listar, criar e ler arquivos dentro do sistema de arquivos. Outros comandos podem ser consultados na Internet.
Terminal ready
>>> import os
>>> os.listdir()
Terminal ready
>>> import os
>>> f=open('teste.txt', 'w')
>>> f.write('linha 1')
>>> f.write('linha 2')
>>> f.close()
>>> os.listdir()
Terminal ready
>>> import os
>>> f=open('teste.txt')
>>> f.read()
>>> f.close()
Além disso, o sistema de arquivos do Mycropython pode ser gerenciado através do terminal do Linux com o programa AMPY que veremos a seguir.
O programa AMPY gerencia o sistema de arquivos do NodeMCU através da terminal do Linux, sem necessidade de usar o terminal serial.
Esse programa não deve ser usado simultaneamente com o terminal serial (picocom). Se houver uma sessão de terminal serial aberta, será necessário fechá-la antes de usar o programa AMPY.
O programa AMPY deve ser instalado no Python do Linux com o comando:
[user@mg45]$ pip install --user 0 adafruit-ampy
Para ver todas as opções do programa AMPY use o comando:
[user@mg45]$ ampy help
Para transferir um arquivo do Linux para o NodeMCU use o comando:
[user@mg45]$ ampy --port /dev/ttyUSB0 --baud 115200 put <nome do arquivo>
Para baixar um arquivo do NodeMCU para o Linux use o comando:
[user@mg45]$ ampy --port /dev/ttyUSB0 --baud 115200 get <nome do arquivo>
O programa AMPY também possibilita executar um programa, que está num arquivo no Linux, diretamente no NodeMCU sem a necessidade de transferí-lo para lá antecipadamente. Para executar um programa diretamente no NodeMCU use o comando:
[user@mg45]$ ampy --port /dev/ttyUSB0 run <pgm.py>
Ao ligar o NodeMCU, a primeira coisa que o Micropython faz é procurar no seu sistema de arquivos um programa chamado boot.py. Se esse programa estiver presente, ele será executado. Após executar o programa boot.py, o Micropython vai a procura de um arquivo chamado main.py que, se estiver presente, também sera executado. A falta de um ou outro ou dos dois arquivos não acarreta nenhum problema ao funcionamento do sistema.
O arquivo boot.py pode ser usado para configurações gerais do NodeMCU e o main.py para configurações especificas. Por exemplo, com os comandos abaixo podemos criar um arquivo main.py para limpar a tela e emitir uma mensagem de boas-vindas assim que o terminal serial iniciar.
print('\033c')
print("HPSpin MicroPython Environment *** 22/01/2019",end='\n')
Crie o arquivo main.py com os comandos acima e transfíra-o para o sistema de arquivos do Micropython usando o programa AMPY e, em seguida, inicie o terminal serial (picocom).
Ao receber a mensagem "Terminal ready" pressione o botão RESET do NodeMCU. Notar que a tela deverá ser apagada e a mensagem deverá aparecer.
Entrar no terminal serial (picocom), pressionar o botão RESET do NodeMCU para receber o prompt e digitar as linhas abaixo:
>>> import machine, time
>>> p=machine.Pin(2, machine.Pin.OUT)
>>> while 1:
... p.on()
... time.sleep_ms(70)
... p.off()
... time.sleep_ms(70)
...
...
...
Após a última linha digitada, o LED azul do NodeMCU começará a piscar num intervalo de 70ms.
Essa forma de programar não é muito eficiente já que ao desligar o NodeMCU o programa será apagado e, se quisermos executá-lo novamente, teremos que digitá-lo outra vez.
Entrar no terminal do Linux, abrir um arquivo vazio com o nome 'blink.py' e digitar as linhas abaixo:
import machine, time
p=machine.Pin(2, machine.Pin.OUT)
while 1:
p.on()
time.sleep_ms(70)
p.off()
time.sleep_ms(70)
Salvar o arquivo e transferí-lo para o sistema de arquivos do NodeMCU com o programa AMPY como no comando abaixo:.
[user@mg45]$ ampy --port /dev/ttyUSB0 --baud 115200 put blink.py
Após o programa ter sido transferido, entre no terminal serial e no prompt do Micropython digite:
>>> import blink
O comando acima, fará o programa iniciar porém, se o NodeMCU for reiniciado pelo botão RESET ou se for desligado e religado, o programa não será executado, a menos que você entre novamente no terminal serial e dê o comando import blink.
A execução do programação através do Linux pode, também, ser conseguida usando-se o programa AMPY para executá-lo diretamene no NodeMCU, como no comando abaixo:
[user@mg45]$ ampy --port /dev/ttyUSB0 --baud 115200 run blink.py
Quando se desenvolve um projeto no ESP8266, é necessário que o programa comece executar assim que o dispositivo é ligado mas, conforme visto acima, é necessário entrar no terminal serial e fazer o import do programa ou então usar no Linux o programa AMPY para executá-lo diretamente.
Para efetivar o programa blink.py no NodeMCU, isto é, para que esse programa seja executado toda vez que o NodeMCU seja reiniciado pelo botão RESET ou seja desligado e religado, devemos codificar sua chamada dentro do script boot.py.
Para fazer isso, abra um arquivo novo boot.py num editor de texto do Linux e digite a linha abaixo:
>>> import blink
Salve e transfira o arquivo para o sistema de arquivos do Micropython com o programa AMPY com o comando abaixo:
[user@mg45]$ ampy --port /dev/ttyUSB0 --baud 115200 put boot.py
Após o programa ter sido transferido, desligue e religue o NodeMCU e note que agora o programa funcionará toda vez que o chip for reiniciado, seja pelo botão RESET ou se for desligado e religado.
Esse procedimento fará o programa ser executado mesmo que o NodeMCU não esteja conectado ao PC pelo cabo USB.
|
H P S P I N Desde 04 de Março de 2010 Atualização: 23 de Apr de 2024 |
|