Aprender

Simulador de MicroPython para ESP32: o firmware oficial, online

Iniciante

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
ESP32 DevKit: MicroPython pisca um LEDao vivo0.000 s 0.00x
Clique para abrir no editor
Aperte Rodar. O firmware oficial do MicroPython inicializa, o main.py é copiado para a placa e o GPIO 2 pisca os dois LEDs.

O Mokxi roda MicroPython em suas placas clássicas de ESP32: a DOIT DevKit V1, a DevKitC e a LOLIN32 Lite. Coloque uma no canvas, escolha MicroPython (main.py) no painel Firmware, escreva o main.py e aperte Rodar. O que roda é o firmware oficial do MicroPython v1.29.0 para o ESP32, o mesmo arquivo que o micropython.org publica, sobre o modelo do Mokxi do chip inteiro, inicializado a partir da mask ROM da própria Espressif. Nada na página interpreta o seu Python.

Quando você aperta Rodar, o computador na ponta do cabo USB simulado da placa copia seus arquivos .py para o flash da placa como o Thonny e o mpremote fazem, e então faz um soft-reboot. O MicroPython imprime MPY: soft reboot e roda o main.py. Tudo o que o print() diz aparece no Monitor Serial, e quando o main.py termina, ou você o interrompe com Ctrl-C, o REPL responde lá.

O circuito acima é o primeiro de seis projetos iniciais abaixo: o GPIO 2 pisca o LED azul da própria DevKit e um LED vermelho ligado ao D2, e o Monitor Serial mostra on e off.

Piscar com machine.Pin

Pin(2, Pin.OUT) é o GPIO 2, que numa DevKit V1 está ligado ao LED azul da placa e ao pino D2 do cabeçalho. O LED vermelho no D2 vai por 220 ohms ao terra, então os dois acendem juntos e apagam juntos.

main.py: piscar um LED
# MicroPython on an ESP32 DevKit: blink an LED.
# GPIO 2 is the DevKit's own blue LED, and the red LED wired to D2 through
# 220 ohms blinks with it.
from machine import Pin
import time

led = Pin(2, Pin.OUT)

while True:
    led.value(1)
    print("on")
    time.sleep_ms(500)
    led.value(0)
    print("off")
    time.sleep_ms(500)

Um botão com Pin.irq()

A button from D15 to ground, with the pin’s own pull-up: the pin reads 1 until the button is pressed, and Pin.IRQ_FALLING calls the handler when it goes to 0. A real button bounces, and so does this one, so the handler only sets a flag. The main loop waits 20 ms for the contacts to settle and counts a press only if the pin is still 0. Pressed three times, it prints presses 1, presses 2 and presses 3, once each, and toggles the board’s LED with each press.

main.py: contar toques com uma interrupção
# MicroPython on an ESP32 DevKit: count button presses with an interrupt.
# The button joins D15 to ground. The pin's own pull-up holds it at 1, so a
# press pulls it to 0 and IRQ_FALLING calls pressed().
from machine import Pin
import time

led = Pin(2, Pin.OUT)                       # the DevKit's blue LED
button = Pin(15, Pin.IN, Pin.PULL_UP)
presses = 0
flag = False

def pressed(pin):
    global flag
    flag = True                             # keep a handler short: set a flag

button.irq(trigger=Pin.IRQ_FALLING, handler=pressed)
print("Press the button")

while True:
    if flag:
        time.sleep_ms(20)                   # let the contacts stop bouncing
        flag = False
        if button.value() == 0:             # still down: a real press
            presses += 1
            led.value(not led.value())
            print("presses", presses)
    time.sleep_ms(5)

Esvazeie um LED com PWM

PWM(Pin(4), freq=1000) é um dos canais LEDC do ESP32 no D4, e duty_u16() aceita de 0 a 65535. O laço sobe o duty e o desce de novo, então o LED acende e apaga em passos pequenos: ele respira, em vez de piscar.

main.py: um LED que respira
# MicroPython on an ESP32 DevKit: an LED that breathes.
# The LED on D4 is driven by PWM at 1 kHz; the duty goes up and down
# from 0 to 65535 in steps, so the LED fades in and out.
from machine import Pin, PWM
import time

led = PWM(Pin(4), freq=1000)

while True:
    for duty in range(0, 65536, 2048):
        led.duty_u16(duty)
        time.sleep_ms(20)
    for duty in range(65535, -1, -2048):
        led.duty_u16(duty)
        time.sleep_ms(20)
    print("breath")

Um DHT22 com o módulo dht

O módulo dht do próprio MicroPython lê um DHT22 no D4, bit por bit pelo pino, como numa placa real. Com o componente em 23.5 C e 41% ele imprime Temperature: 23.5 C Humidity: 41.0 %, e quando você muda a temperatura no componente a próxima leitura acompanha.

main.py: um DHT22
# MicroPython on an ESP32 DevKit: a DHT22 temperature and humidity sensor.
# DATA is on D4; the module has its own pull-up.
from machine import Pin
import dht
import time

sensor = dht.DHT22(Pin(4))
time.sleep(2)                    # the DHT22 needs a moment after power-up

while True:
    try:
        sensor.measure()
        print("Temperature: %.1f C  Humidity: %.1f %%" % (sensor.temperature(), sensor.humidity()))
    except OSError as e:
        print("Could not read the DHT22:", e)
    time.sleep(2)                # a DHT22 gives a new reading every two seconds

Um OLED SSD1306 em I2C

I2C(0, scl=Pin(22), sda=Pin(21)) é o primeiro bloco I2C do ESP32 nos pinos que a maioria dos tutoriais de ESP32 usa. scan() encontra o OLED e imprime I2C: ['0x3c']. Adicione o ssd1306.py da micropython-lib como uma aba ao lado do main.py e ele é copiado para a placa junto, como o Thonny copiaria; o programa então desenha duas linhas de texto e um contador que sobe uma vez por segundo.

main.py: texto em um OLED SSD1306
# MicroPython on an ESP32 DevKit: an SSD1306 OLED on I2C.
# SCL is on D22 and SDA on D21, the ESP32's usual I2C pins.
# ssd1306.py, micropython-lib's driver, is in its own tab.
from machine import I2C, Pin
import ssd1306
import time

i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=400000)
print("I2C:", [hex(a) for a in i2c.scan()])   # 0x3c, the OLED

oled = ssd1306.SSD1306_I2C(128, 64, i2c)
count = 0

while True:
    oled.fill(0)
    oled.text("Hello, ESP32!", 0, 0)
    oled.text("MicroPython", 0, 16)
    oled.text("count %d" % count, 0, 40)
    oled.show()
    print("count", count)
    count += 1
    time.sleep(1)

WiFi e um HTTP GET com urequests

O network.WLAN entra no ponto de acesso simulado do Mokxi. O nome e a senha são as propriedades WiFi da placa, que começam como Mokxi-Lab e breadboard. A placa recebe seu endereço por DHCP e imprime Connected, IP address 192.168.4.2.

O urequests.get() então busca http://weather.mokxi/, um dos sites inventados da rede simulada, e o programa imprime Mokxi: 21.5 C, 48 % humidity. O painel Cloud mostra as requisições que a placa faz. A rede é simulada: nomes fora de .mokxi não são encontrados, e https:// não tem para onde ir.

main.py: entrar no WiFi e buscar o clima
# MicroPython on an ESP32 DevKit: join WiFi and fetch the weather.
# The board joins Mokxi's simulated access point; its name and password are
# the board's WiFi properties. On a real board, put in your own network's.
import network
import time
import urequests

SSID = "Mokxi-Lab"
PASSWORD = "breadboard"

wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect(SSID, PASSWORD)
print("Connecting to", SSID)
while not wlan.isconnected():
    time.sleep_ms(250)
print("Connected, IP address", wlan.ifconfig()[0])

while True:
    r = urequests.get("http://weather.mokxi/")
    weather = r.json()
    r.close()
    print("%s: %.1f C, %d %% humidity" % (weather["location"], weather["temperatureC"], weather["humidity"]))
    time.sleep(10)

O que funciona, e o que não funciona

Funcionando: machine.Pin com interrupções, PWM no LEDC, ADC nos oito canais do ADC1 com as quatro atenuações, I2C e SoftI2C, SPI e SoftSPI, UART(1) e UART(2), neopixel, dht, onewire e ds18x20, machine.freq() a 80, 160 ou 240 MHz, e network.WLAN com socket e urequests na rede simulada. Drivers como ssd1306.py conversam com os componentes no canvas.

Não simulado: light sleep e deep sleep; ADC2; PSRAM; os modos escravos de I2C e SPI; controle de fluxo do UART; recepção com o RMT; os watchdogs reiniciando a placa; e na rede, uma segunda estação no soft AP (o telefone do painel Web entra na WLAN(AP_IF)), ESP-NOW, economia de energia, TLS e qualquer rede que não a simulada. O firmware é a versão de núcleo único. Código na flash roda tão rápido quanto código na RAM, já que o tempo dos caches não é modelado.

Importando do Wokwi

Um projeto Wokwi para um ESP32 com um main.py é importado como projeto MicroPython, com a placa configurada para MicroPython. A placa entra na Wokwi-GUEST sem senha, como no Wokwi, então o usual wlan.connect("Wokwi-GUEST", "") funciona como está escrito.

O mesmo código num ESP32 de verdade

Uma placa MicroPython não precisa de compilação. Coloque o MicroPython no ESP32 com 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), então copie o main.py para ela com Thonny ou mpremote.

Numa placa de verdade, troque o SSID e a senha no projeto inicial de WiFi pelos da sua própria rede. Os sites .mokxi existem apenas no Mokxi.

Abra este circuito no editor. ESP32 DevKit: MicroPython pisca um LED, ligado como roda no topo desta página. Troque um componente ou um valor e rode de novo.

Abrir o circuito

Perguntas

Isso é MicroPython de verdade?

Sim. A placa roda o firmware oficial do MicroPython v1.29.0 para o ESP32, a versão de núcleo único que o micropython.org publica, sobre um modelo do chip inteiro inicializado a partir da ROM de máscara da Espressif. Nada na página web interpreta o seu Python.

Quais placas rodam MicroPython?

As placas ESP32 clássicas: a DOIT DevKit V1, a DevKitC e a LOLIN32 Lite, além do Raspberry Pi Pico. Escolha MicroPython (main.py) no painel Firmware da placa. Um sketch Arduino na mesma placa roda como antes.

Como o main.py chega à placa?

Do jeito que o mpremote faz. Ao Rodar, o computador simulado na porta USB da placa entra no REPL raw pelo UART0, grava cada arquivo .py no sistema de arquivos da placa e faz um soft reboot, e a placa então roda o boot.py e o main.py.

Ele baixa alguma coisa?

O primeiro Rodar de um projeto MicroPython num ESP32 baixa o firmware e a ROM do chip, 1.4 MB, e o navegador os guarda para todo Rodar seguinte. Um sketch Arduino nunca os baixa.

Monte isto de verdade

Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.