Primeiros passos com Python para ESP8266 e ESP32: 6 etapas

2024 Autor: John Day | [email protected]. Última modificação: 2024-01-30 11:35

Bacground

O ESP8266 e seu irmão mais velho ESP32 são microchips Wi-Fi de baixo custo com pilha TCP / IP completa e capacidade de microcontrolador. O chip ESP8266 chamou a atenção da comunidade de fabricantes pela primeira vez em 2014. Desde então, o preço baixo (<5 USD), sua capacidade de Wi-Fi, uma memória flash embutida de 1 ou 4 MB e uma variedade de desenvolvimento disponível placas, fez do chip ESP um dos microcontroladores mais populares para projetos de WiFi e IoT DIY.

MicroPython é uma implementação enxuta e eficiente da linguagem de programação Python cada vez mais popular que inclui um pequeno subconjunto da biblioteca padrão do Python e é otimizada para rodar em microcontroladores.

A combinação dos dois é uma opção muito interessante para projetos DIY, tanto para iniciantes como para usuários mais avançados.

O projeto MiPy-ESP

Em 2015, meus primeiros projetos com ESP8266 começaram com o chip ESP-01 usando Arudions para executar comandos AT do chip em conexão serial. Depois disso, nos anos seguintes apliquei o núcleo do Arduino para ESP8266 para programar os chips com a linguagem C ++. Isso funciona bem, mas para um entusiasta do Python, minha descoberta da implementação MicroPython do Python 3 foi uma ótima notícia.

O projeto MiPy-ESP é uma estrutura flexível que aplica MicroPython para projetos Python IoT full-stack nos microcontroladores da família ESP.

O framework é desenvolvido pela Equipe de Desenvolvimento de Software do Comitê Técnico LeGarage (LG-TC-SWDT-01) com o objetivo de substituir o código baseado em C ++ já estabelecido para nossos aplicativos de microcontrolador.

O projeto oferece recursos básicos, como

• Procedimentos de conexão de rede
• Servidor da web do ponto de acesso do chip (para conexão wi-fi e veiculação de páginas da web do chip para E / S de dados)
• Funcionalidades MQTT
• Registro / depuração
• Agendamento de eventos do microcontrolador
• Rotinas de I / O de hardware

Com um script de código compacto principal (main.py), todos com configuração global (config.py).

Este código do microcontrolador é executado com manutenção robusta de conexões de chip para rede WiFi e corretores MQTT. Os módulos MicroPython existentes para vários hardwares podem ser facilmente integrados ao sistema.

A estrutura MiPy-ESP se tornou a espinha dorsal de todos os nossos projetos de IoT eletrônicos de passatempo envolvendo microcontroladores da família ESP. Ele foi testado em várias placas da família ESP, como as placas NodeMCU, Wemos e Lolin.

O tutorial a seguir é um guia de introdução aos microcontroladores da família ESP e MicroPython usando a estrutura MiPy-ESP.

Etapa 1: A placa Wemos D1 Mini ESP8266

A estrutura MiPy-ESP funciona com a maioria dos microcontroladores baseados em ESP8266.

A mini placa de desenvolvimento Wemos D1 é baseada no chip ESP-8266EX. Em uma pegada de 2,5 x 3,5 cm, possui 4 MB de memória flash, 11 pinos de entrada / saída digital, todos os pinos suportam interrupção, PWM, I2C, SPI, serial e 1 entrada analógica com entrada máxima de 3,3 V, pode funcionar com alimentação de 5 V, tem conexão micro USB e é compatível com placa de ensaio. O preço baixo e seu tamanho pequeno a tornaram minha placa ESP favorita.

Além disso, a versão D1 mini pro da placa vem com opção de conexão de antena externa, aumentando significativamente o alcance de conexão (alcance de +100 m). Além disso, a placa também vem com uma variedade de placas de extensão prontas para usar com tamanho compacto semelhante.

Etapa 2: se preparando para MicroPython no chip ESP

Nesta primeira etapa, você irá

• Conecte a placa ESP via USB ao seu computador
• Instale o software Esptool para atualizar o chip
• Apagar memória do chip
• Atualize o chip com o firmware MicroPython
• Instale o Rshell para permitir a interação da linha de comando com o seu chip
• Instale o mpy-cross (para compilação de arquivos.py para binários)

Conectar a placa ao seu computador via USBBoards com uma porta serial USB integrada torna o UART disponível para o seu PC e é a opção mais fácil para começar. Para placas sem conexão USB, um módulo FTDI com USB para serial pode ser usado para conectar os pinos GPIO para flash conectados ao mundo externo, mas isso não é abordado neste tutorial.

Para MicroPython usando o código MiPy-ESP, o requisito mínimo para o tamanho do chip flash é 1 MB. Também existe uma construção especial para placas com 512kB, mas não tem suporte para um sistema de arquivos, do qual MiPy-ESP depende.

Ao usar um cabo USB, a placa é alimentada pelo computador enquanto está conectada. Isso também permite a programação e depuração pela conexão serial. Quando o código do projeto é carregado e seu projeto implantado, a alimentação externa é aplicada sobre os pinos da fonte de alimentação da placa.

Instalar o EsptoolInformações sobre o software Esptool podem ser encontradas no repositório Esptool GitHub. Se você quiser usar o Windows / Linux / OSX (MAC), o link acima também cobre isso. O pacote Python pode ser instalado por

pip instalar esptool

Para usuários Linux, os pacotes do Esptool são mantidos para Debian e Ubuntu, e também podem ser instalados com

sudo apt install esptool

Apagando a memória flash do ESP Usando o Esptool, você apaga a memória flash do ESP com o comando

esptool.py --port / dev / ttyUSB0 erase_flash

Baixando o firmware MicroPytonO firmware MicroPython reside em um arquivo.bin que pode ser baixado do site MicroPython.

O branch master do projeto atual do repo foi testado e está operacional com o Micropython v.1.12. Para garantir o sucesso com a estrutura MiPY-ESP, baixe o arquivo 'esp8266-20191220-v1.12.bin' deste link e grave o firmware no chip pelo comando:

esptool.py --port / dev / ttyUSB0 --baud 460800 write_flash --flash_size = detectar 0 esp8266-20191220-v1.12.bin

Instalando RshellO pacote Rshell permite a interação da linha de comando com o ambiente MicroPython instalado no chip. Ele pode ser encontrado neste link. Rshell é um shell simples que é executado no host e usa REPL bruto do MicroPython para enviar fragmentos de python para o pyboard a fim de obter informações do sistema de arquivos e para copiar arquivos de e para o sistema de arquivos do MicroPython. REPL significa Read Evaluate Print Loop e é o nome dado ao prompt MicroPython interativo que você pode acessar no ESP8266. Usar o REPL é de longe a maneira mais fácil de testar seu código e executar comandos. Instale o Rshell pelo comando:

sudo pip install rshell

Instalando o compilador mpy-cross MicroPython pode ser aplicado com arquivos ascii.py carregados para o sistema de arquivos do chip. MicroPython também define o conceito de arquivos.mpy, que é um formato de arquivo contêiner binário que contém código pré-compilado e que pode ser importado como um módulo.py normal. Ao compilar arquivos.py em.mpy, mais memória RAM estará disponível para o código em execução - e isso é necessário para ter um módulo principal funcional da estrutura MiPy-ESP.

Para implantação de código MiPy-ESP, um compilador cruzado mpy-cross MicroPython compila os scripts.py para.mpy antes do upload do chip. Instale o pacote mpy-cross seguindo as instruções neste link. Como alternativa, o comando mpy-cross pode ser instalado pelo comando Python pip ou executado a partir do caminho da pasta mpy-cross se você clonar o repositório MicroPython do GitHub aqui.

Agora você tem MicroPython e todas as ferramentas necessárias instaladas para começar a construir seu primeiro projeto MiPy-ESP

Etapa 3: Introdução ao MiPy-ESP

Nesta etapa você vai

Baixe o framework MyPy-ESP

Baixando a estrutura MiPy-ESPO projeto MiPy-ESP pode ser encontrado no GitHub neste repositório de código. No GitHub, você pode baixar a estrutura do arquivo do repositório ou cloná-lo para o seu computador

git clone

Com o repositório de código instalado em seu computador, agora você tem todos os módulos de código de que precisa para construir um projeto ESP IoT pronto para usar. Mais detalhes sobre a caixa de ferramentas na próxima etapa.

Etapa 4: a arquitetura da estrutura MiPy-ESP

Nesta etapa você vai

aprender sobre o fluxo de trabalho do código MiPy-ESP

Arquitetura de código MiPy-ESP

Todos os módulos da estrutura Python são encontrados na pasta / src do repositório de código MiPY-ESP. A pasta src / core contém os módulos principais que vão para cada projeto. A pasta src / drivers possui uma seleção de módulos para vários hardwares a serem conectados ao seu chip. A pasta src / utilities contém módulos de utilitários opcionais para incluir em seu projeto.

Os arquivos main.py e config.py são encontrados na pasta src /. Estes são os principais arquivos a serem editados para a construção de seu projeto:

config.py:

Este arquivo é o arquivo de configuração global do seu projeto. Possui várias configurações, todas com comentários descritivos no arquivo.

main.py:

Este é o script principal para o loop de código do microcontrolador. Ele contém o código específico do aplicativo na estrutura. Na inicialização do chip, main.py executa e importa todos os módulos dependentes do projeto com as entradas fornecidas do arquivo config.py. O fluxograma acima mostra o layout do script main.py.

A figura acima descreve o fluxo de trabalho de main.py:

1. Na inicialização, o código tenta conectar o chip à rede Wi-Fi. Redes aplicadas anteriormente e suas senhas (criptografadas no chip) são armazenadas na memória flash. SSIDs de rede e suas senhas podem ser provisionados no arquivo wifi.json no formato {" SSID1 ":" Senha "," SSID ":" Senha2 "}. As redes fornecidas neste arquivo são armazenadas, as senhas são criptografadas e o arquivo é excluído na inicialização.
2. Se nenhuma rede já conhecida for encontrada, o código configura um servidor da web de ponto de acesso (AP). O SSID e a senha do servidor AP do chip são definidos no arquivo config.py. Ao fazer logon no SSID do chip, uma página da web para logon do chip para Wi-Fi é servida em 192.168.4.1. As redes detectadas são mostradas em um menu, ou o SSID pode ser inserido manualmente (redes ocultas) junto com a senha do Wi-Fi. Após a conexão bem-sucedida do chip ao Wi-Fi, o servidor AP desliga e o código main.py prossegue para as próximas etapas.

3. Na seção Configuração de main.py,

   • funções para jobs e callbacks (etc. callbacks MQTT) e eventos regulares são definidos.
   • Diferentes trabalhos cronometrados para funções em execução são definidos.
   • Cliente corretor MQTT estabelecido

4. O código então vai para o loop principal do microcontrolador,

   • verificar continuamente as conexões de rede e do broker MQTT,
   • Assinaturas MQTT,
   • I / O de hardware
   • e trabalhos agendados.
   • Ao perder a conexão da rede ou do broker MQTT, o código tenta se restabelecer.

Etapa 5: Preparando Seu Código de Projeto

Nesta etapa você vai

• aprender sobre a estrutura de arquivo do repositório MiPy-ESP
• prepare o código do seu projeto para upload do chip

Estrutura da pasta do repositórioA figura acima descreve a estrutura da pasta do repositório e lista os módulos atuais da estrutura. Seu projeto está em estágios na pasta src /. Os módulos da estrutura Core MiPy-ESP residem em src / core, módulos de utilitário opcionais em src / utilities e módulos de hardware em src / drivers.

A maioria das bibliotecas de hardware MicroPython disponíveis pode ir para a pasta / drivers sem nenhuma modificação. Todos os drivers atuais são testados com a estrutura MiPy-ESP. Em relação aos módulos nos utilitários / pasta, mais serão adicionados à medida que ganham vida.

Preparação do código do projetoSeu código específico do projeto deve ser colocado na pasta src /. Já estão lá os arquivos main.py e config.py que você pode editar. Copie também os utilitários de projeto desejados de src / utilities e src / drivers para src /.

Caso queira fornecer redes Wi-Fi conhecidas e senhas ao chip, adicione o arquivo wifi.json a src /.

Compilar e preparar para uploadUm Makefile fornecido pode ser aplicado para preparar arquivos para transferência para o chip compilando arquivos.py em / src, compilando os módulos principais e transferindo os arquivos compilados para uma nova pasta chamada build / pelo comando

fazer construir

Os arquivos em construção estão prontos para serem carregados no sistema de arquivos do chip. Por padrão, o main.py e o config.py não são compilados para o binário, a fim de acessá-los facilmente para inspeção dos chips implantados. O comando:

limpar

Exclui a compilação / pasta e seu conteúdo.

Etapa 6: Compilando e enviando o código para o microcontrolador

Nesta seção você irá

• carregue os arquivos preparados na compilação / da última seção
• iniciar e monitorar o código em execução

Enviando build / arquivos com Rshell

Carregue todos os arquivos no diretório / build para o chip ESP usando Rshell. Com o microcontrolador conectado ao USB, a partir da compilação / pasta, inicie o Rshell com o comando

rshell -p / dev / ttyUSB0

Em seguida, inspecione os arquivos do chip (se houver) por

ls / pyboard

Todos os arquivos no chip podem ser excluídos por

rm /pyboard/*.*

Copie todos os arquivos do projeto no build / para o chip:

cp *. * / pyboard

Em seguida, inicie o terminal interativo Python pelo comando

repl

Agora você pode invocar comandos Python ou importar módulos e monitorar a saída serial do chip do módulo logger MiPy-ESP.

Reinicie o chip pressionando o botão de reinicialização ou na linha de comando

importar principal

ou

máquina de importação

e então

machine.reset ()

Dependendo das configurações de registro / depuração no arquivo de configuração do projeto, o repl agora mostrará mensagens de depuração do chip ESP pela conexão serial.

Esperançosamente, isso deve ajudá-lo a começar.