Aprender

Simulador de MicroPython para ESP32: el firmware oficial, en línea

Principiante

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
ESP32 DevKit: MicroPython parpadea un LEDen vivo0.000 s 0.00x
Haz clic para abrirlo en el editor
Presiona Ejecutar. El firmware oficial de MicroPython arranca, main.py se copia a la placa y el GPIO 2 parpadea ambos LEDs.

Mokxi ejecuta MicroPython en sus placas clásicas de ESP32: la DOIT DevKit V1, la DevKitC y la LOLIN32 Lite. Pon una en el lienzo, elige MicroPython (main.py) en su panel de Firmware, escribe main.py y presiona Ejecutar. Lo que corre es el firmware oficial de MicroPython v1.29.0 para el ESP32, el mismo archivo que publica micropython.org, sobre el modelo completo del chip de Mokxi, arrancado desde la ROM de máscara de Espressif. Nada en la página interpreta tu Python.

Al presionar Ejecutar, la computadora al final del cable USB simulado de la placa copia tus archivos .py a la flash de la placa como lo hacen Thonny y mpremote, y luego la reinicia suavemente. MicroPython imprime MPY: soft reboot y ejecuta main.py. Todo lo que diga print() aparece en el monitor serie, y cuando main.py termina, o lo detienes con Ctrl-C, el REPL responde allí.

El circuito de arriba es el primero de seis ejemplos de inicio: el GPIO 2 parpadea el LED azul del propio DevKit y un LED rojo conectado a D2, y el monitor serie dice on y off.

Parpadeo con machine.Pin

Pin(2, Pin.OUT) es el GPIO 2, que en una DevKit V1 está conectado al LED azul de la placa y al pin D2 del header. El LED rojo en D2 va a tierra a través de 220 ohms, así que los dos se encienden juntos y se apagan juntos.

main.py: parpadear un 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)

Un botón con 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 pulsaciones con una interrupción
# 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)

Desvanecer un LED con PWM

PWM(Pin(4), freq=1000) es uno de los canales LEDC del ESP32 en D4, y duty_u16() acepta de 0 a 65535. El bucle sube y baja el ciclo útil, así que el LED se enciende y se atenúa en pasos pequeños: respira, en lugar de parpadear.

main.py: un 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")

Un DHT22 con el módulo dht

El módulo dht de MicroPython lee un DHT22 en D4, bit por bit a través del pin, como en una placa real. Con el componente configurado a 23.5 C y 41% imprime Temperature: 23.5 C Humidity: 41.0 %, y al cambiar la temperatura del componente la siguiente lectura la sigue.

main.py: un 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

Una OLED SSD1306 por I2C

I2C(0, scl=Pin(22), sda=Pin(21)) es el primer bloque I2C del ESP32 en los pines que usan la mayoría de tutoriales del ESP32. scan() encuentra la OLED e imprime I2C: ['0x3c']. Agrega el ssd1306.py de micropython-lib como una pestaña junto a main.py y se copiará a la placa con él, como lo haría Thonny; el programa dibuja dos líneas de texto y un contador que sube una vez por segundo.

main.py: texto en una 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 y un HTTP GET con urequests

network.WLAN se conecta al punto de acceso simulado de Mokxi. Su nombre y contraseña son las propiedades WiFi de la placa, que empiezan como Mokxi-Lab y breadboard. La placa obtiene su dirección por DHCP e imprime Connected, IP address 192.168.4.2.

urequests.get() luego consulta http://weather.mokxi/, uno de los sitios inventados de la red simulada, y el programa imprime Mokxi: 21.5 C, 48 % humidity. El panel Nube muestra las peticiones que hace la placa. La red es simulada: los nombres fuera de .mokxi no se encuentran, y https:// no tiene a dónde ir.

main.py: conectarse al WiFi y consultar el 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)

Lo que funciona, y lo que no

Funcionan: machine.Pin con interrupciones, PWM en el LEDC, ADC en los ocho canales del ADC1 con las cuatro atenuaciones, I2C y SoftI2C, SPI y SoftSPI, UART(1) y UART(2), neopixel, dht, onewire y ds18x20, machine.freq() a 80, 160 o 240 MHz, y network.WLAN con socket y urequests en la red simulada. Controladores como ssd1306.py se comunican con los componentes del lienzo.

No se simulan: la suspensión ligera y profunda; el ADC2; la PSRAM; los modos esclavo de I2C y SPI; el control de flujo del UART; la recepción con el RMT; los watchdogs reiniciando la placa; y en la red, una segunda estación en el soft AP (el celular del panel Web se une a WLAN(AP_IF)), ESP-NOW, el ahorro de energía, TLS y cualquier red que no sea la simulada. El firmware es la compilación de un solo núcleo. El código en la flash corre igual de rápido que el código en RAM, porque no se modela el tiempo de las cachés.

Importar desde Wokwi

Un proyecto de Wokwi para un ESP32 cuyo main.py se importa como proyecto de MicroPython, con su placa configurada en MicroPython. La placa se une a Wokwi-GUEST sin contraseña, como en Wokwi, así que el clásico wlan.connect("Wokwi-GUEST", "") funciona tal cual está escrito.

El mismo código en un ESP32 real

Una placa con MicroPython no necesita compilación. Pon MicroPython en el ESP32 con esptool (esptool.py --chip esp32 erase_flash, luego esptool.py --chip esp32 write_flash -z 0x1000 ESP32_GENERIC-UNICORE-20260824-v1.29.0.bin, de micropython.org/download/ESP32_GENERIC), y después copia main.py con Thonny o mpremote.

En una placa real, cambia el SSID y la contraseña del iniciador de WiFi por los de tu propia red. Los sitios .mokxi existen solo en Mokxi.

Abre este circuito en el editor. ESP32 DevKit: MicroPython hace parpadear un LED, conectado como aparece al inicio de esta página. Cambia un componente o un valor y vuelve a ejecutarlo.

Abrir el circuito

Preguntas

¿Es MicroPython de verdad?

Sí. La placa corre el firmware oficial de MicroPython v1.29.0 para el ESP32, la compilación de un solo núcleo que publica micropython.org, sobre un modelo del chip completo arrancado desde la ROM de máscara de Espressif. Nada en la página web interpreta tu Python.

¿Qué placas corren MicroPython?

Las placas ESP32 clásicas: la DOIT DevKit V1, la DevKitC y la LOLIN32 Lite, además de la Raspberry Pi Pico. Elige MicroPython (main.py) en el panel de Firmware de la placa. Un sketch de Arduino en la misma placa corre como siempre.

¿Cómo llega main.py a la placa?

De la manera en que lo hace mpremote. Al presionar Ejecutar, la computadora simulada en el puerto USB de la placa entra al REPL raw por UART0, escribe cada archivo .py en el sistema de archivos de la placa y reinicia la placa por software, que entonces ejecuta boot.py y main.py.

¿Descarga algo?

La primera vez que ejecutas un proyecto de MicroPython en un ESP32 se descargan el firmware y la ROM del chip, 1.4 MB, y el navegador los guarda para todas las ejecuciones siguientes. Un sketch de Arduino nunca los descarga.

Ármalo en la vida real

Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.