Simulador de MicroPython para ESP32: o firmware oficial, online
Iniciante
- 526componentes na bancada
- 46placas rodando agora
- 1.00xtempo real, em todas as placas
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.
# 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.
# 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.
# 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.
# 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.
# 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.
# 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 circuitoPerguntas
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.
Continuar
De onde vêm as informações desta página
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.