Placas

MicroPython no ESP32

Rode o main.py em uma placa ESP32 clássica com o firmware oficial do MicroPython: o painel de Firmware, o REPL, WiFi e importação do Wokwi.

Quais placas

Várias placas oferecem MicroPython (main.py) no painel de Firmware. Esta página fala das placas clássicas de ESP32: a DOIT DevKit V1, a DevKitC e a LOLIN32 Lite. As outras rodam, cada uma, a compilação oficial do próprio chip da mesma maneira:

O Cheap Yellow Display, o T-Display e o D1 R32 também usam o ESP32 clássico, mas rodam apenas sketches de Arduino.

O que roda é o MicroPython v1.29.0 para o ESP32, a compilação oficial de núcleo único, byte por byte como o micropython.org publica, sobre o modelo do chip inteiro do Mokxi, iniciado a partir da mask ROM da própria Espressif. Nada nesta página interpreta o seu Python.

Escolhendo-o no painel Firmware

  1. Coloque uma ESP32 DevKit V1, DevKitC ou LOLIN32 Lite no canvas.
  2. Abra o painel Firmware dela e escolha MicroPython (main.py).
  3. Os arquivos da placa passam a ser um main.py. Escreva seu programa lá e aperte Rodar.

Uma placa cujos arquivos têm um main.py e nenhum .ino roda MicroPython. Um sketch de Arduino na mesma placa roda como antes, e nada do MicroPython é carregado para ele.

A primeira vez que você aperta Rodar em um projeto MicroPython no ESP32, o firmware e a ROM do chip são baixados, 1.4 MB, e o navegador os guarda para todas as vezes seguintes. Um sketch de Arduino nunca os baixa.

O que o Rodar faz com o main.py

O Rodar inicia o firmware, e o computador na ponta do cabo USB simulado da placa copia seus arquivos .py para a placa como o Thonny e o mpremote fazem: entra no REPL raw pela porta serial da placa, grava cada arquivo na flash da placa e a reinicia por software. A placa imprime MPY: soft reboot, executa boot.py e depois main.py.

Toda aba .py, .txt, .json e .csv é copiada, então um driver como o ssd1306.py da micropython-lib vai numa aba própria ao lado do main.py, e import ssd1306 o encontra.

O botão EN e machine.reset() mantêm os arquivos, então o main.py roda de novo, como numa mesa. Rodar de novo começa de um chip apagado.

O monitor serial e o REPL

A partir de MPY: soft reboot, o monitor serial é a UART0 da placa, nos dois sentidos. Tudo o que print() diz aparece lá. Quando o main.py termina, ou quando você o interrompe com Ctrl-C, o REPL responde ali: digite uma expressão e aperte Enter.

Quando um programa para com um erro, o MicroPython imprime um traceback. O Mokxi o lê, marca a linha no seu arquivo e diz o que o erro costuma significar, como faz no Pico.

O que funciona

machine.Pin com interrupções, PWM (o LEDC), ADC nos oito canais do ADC1 com as quatro atenuações, I2C e SoftI2C, SPI e SoftSPI, UART(1) e UART(2) nos pinos ligados a elas, neopixel, dht, onewire e ds18x20, e machine.freq() a 80, 160 ou 240 MHz.

Não simulados: light sleep e deep sleep, ADC2, PSRAM, os modos slave de I2C e SPI, controle de fluxo do UART, recepção com o RMT e os watchdogs reiniciando a placa. A compilação é a de núcleo único.

WiFi

network.WLAN conecta ao ponto de acesso simulado do Mokxi, o mesmo que o WiFi.begin de um sketch Arduino conecta. O nome e a senha dele são as propriedades de WiFi da placa, que começam como Mokxi-Lab e breadboard; mude nas propriedades da placa e use os mesmos dois em wlan.connect(). A placa recebe 192.168.4.2 por DHCP.

import network, time, urequests

wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect("Mokxi-Lab", "breadboard")
while not wlan.isconnected():
    time.sleep_ms(250)
r = urequests.get("http://weather.mokxi/")
print(r.json())
r.close()

socket e urequests alcançam os sites fictícios da rede simulada: time.mokxi, weather.mokxi, echo.mokxi e api.mokxi. Qualquer outro nome não é encontrado, e https:// não tem para onde ir. O painel Nuvem mostra o que a placa pede.

network.WLAN(network.AP_IF) inicia o próprio ponto de acesso da placa: o painel Web conecta a ele como um celular, ap.status('stations') o lista, e um servidor de socket na porta 80 abre em http://192.168.4.1/. Para rodá-lo junto com a estação, mova-o com ap.ifconfig(), já que a rede simulada também é 192.168.4.0/24.

Não simulados na rede: uma segunda estação no ponto de acesso, ESP-NOW, economia de energia, TLS e qualquer rede que não a simulada.

WiFi, simulado cobre a própria rede.

Importando do Wokwi

Um projeto do Wokwi para um ESP32 DevKit V1, DevKitC ou LOLIN32 Lite que tenha um main.py é importado como um projeto MicroPython, com a placa definida como MicroPython. A rede da placa dele se chama Wokwi-GUEST sem senha, como no Wokwi, então wlan.connect("Wokwi-GUEST", "") funciona como está escrito. Veja Vindo do Wokwi.

Em um ESP32 real

Uma placa MicroPython não precisa de compilação. Coloque o MicroPython no ESP32 com o esptool (esptool.py --chip esp32 erase_flash, depois esptool.py --chip esp32 write_flash -z 0x1000 ESP32_GENERIC-UNICORE-20260824-v1.29.0.bin, de micropython.org/download/ESP32_GENERIC), e então copie o main.py para ela com o Thonny ou o mpremote. Coloque o nome e a senha da sua própria rede em wlan.connect(): os sites .mokxi existem só no Mokxi.

Projetos iniciais

Seis projetos iniciais em um DevKit V1, cada um na sua própria página: blink, um botão com Pin.irq(), um fade com PWM, um DHT22, um OLED SSD1306 e WiFi e o clima. O simulador de MicroPython do ESP32 passa pelos seis.

Em outros lugares