Simulador de MicroPython para ESP32: el firmware oficial, en línea
Principiante
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
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.
# 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.
# 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.
# 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.
# 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.
# 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.
# 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 circuitoPreguntas
¿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.
Sigue así
De dónde vienen los datos de esta página
Á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.