Qué placas
Varias placas ofrecen MicroPython (main.py) en su panel de Firmware. Esta página trata de las del ESP32 clásico: la DOIT DevKit V1, la DevKitC y la LOLIN32 Lite. Las demás ejecutan cada una la compilación oficial de su propio chip de la misma manera:
- ESP32-S3: la ESP32-S3-DevKitC-1, la XIAO ESP32-S3 y el Arduino Nano ESP32.
- ESP32-C3: la ESP32-C3-DevKitM-1, la XIAO ESP32-C3 y la ESP32-C3 SuperMini.
- ESP32-C6: la ESP32-C6-DevKitC-1 y la XIAO ESP32-C6.
- RP2040: la Raspberry Pi Pico y la Pico W.
La Cheap Yellow Display, la T-Display y la D1 R32 también usan el ESP32 clásico, pero solo ejecutan sketches de Arduino.
Lo que corre es MicroPython v1.29.0 para el ESP32, la compilación oficial de un solo núcleo, byte por byte tal como la publica micropython.org, sobre el modelo de Mokxi del chip completo, arrancando desde la ROM de máscara del propio Espressif. Nada de esta página interpreta tu Python.
Elegirlo en el panel de Firmware
- Coloca una ESP32 DevKit V1, DevKitC o LOLIN32 Lite en el lienzo.
- Abre su panel de Firmware y elige MicroPython (main.py).
- Los archivos de la placa se convierten en un
main.py. Escribe tu programa ahí y presiona Ejecutar.
Una placa cuyos archivos tienen un main.py y ningún .ino ejecuta MicroPython. Un sketch de Arduino en la misma placa corre como siempre, y no se carga nada de MicroPython para él.
La primera Ejecución de un proyecto de MicroPython en un ESP32 descarga el firmware y la ROM del chip, 1.4 MB, y el navegador los conserva para cada Ejecución posterior. Un sketch de Arduino nunca los descarga.
Qué hace Ejecutar con main.py
Ejecutar arranca el firmware, y la computadora al final del cable USB simulado de la placa copia tus archivos .py a la placa como lo hacen Thonny y mpremote: entra al REPL crudo por el puerto serie de la placa, escribe cada archivo en la flash de la placa y la reinicia por software. La placa imprime MPY: soft reboot, ejecuta boot.py y luego main.py.
Cada pestaña .py, .txt, .json y .csv se copia, así que un controlador como el ssd1306.py de micropython-lib va en su propia pestaña junto al main.py y import ssd1306 lo encuentra.
El botón EN y machine.reset() conservan los archivos, así que main.py corre de nuevo, como en un escritorio. Ejecutar de nuevo parte de un chip borrado.
El monitor serie y el REPL
Desde MPY: soft reboot en adelante, el monitor serie es el UART0 de la placa, en ambos sentidos. Todo lo que diga print() aparece ahí. Cuando main.py termina, o lo detienes con Ctrl-C, el REPL responde ahí: escribe una expresión y presiona Enter.
Cuando un programa se detiene con un error, MicroPython imprime un traceback. Mokxi lo lee, marca la línea en tu archivo y dice qué suele significar el error, como lo hace en la Pico.
Lo que funciona
machine.Pin con interrupciones, PWM (el LEDC), ADC en los ocho canales del ADC1 con las cuatro atenuaciones, I2C y SoftI2C, SPI y SoftSPI, UART(1) y UART(2) en los pines conectados a ellos, neopixel, dht, onewire y ds18x20, y machine.freq() a 80, 160 o 240 MHz.
No se simula: 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, ni los watchdogs reiniciando la placa. La compilación es de un solo núcleo.
WiFi
network.WLAN se une al punto de acceso simulado de Mokxi, el mismo al que se une el WiFi.begin de un sketch de Arduino. Su nombre y contraseña son las propiedades WiFi de la placa, que empiezan como Mokxi-Lab y breadboard; cámbialas en las propiedades de la placa y usa esas mismas dos en wlan.connect(). La placa obtiene 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 y urequests llegan a los sitios inventados de la red simulada: time.mokxi, weather.mokxi, echo.mokxi y api.mokxi. Cualquier otro nombre no se encuentra, y https:// no tiene a dónde ir. El panel de la Nube muestra lo que pide la placa.
network.WLAN(network.AP_IF) inicia el punto de acceso propio de la placa: el panel Web se une a él como un celular, ap.status('stations') lo lista, y un servidor de sockets en el puerto 80 se abre en http://192.168.4.1/. Para ejecutarlo junto con la estación, muévelo con ap.ifconfig(), ya que la red simulada también es 192.168.4.0/24.
No se simula en la red: una segunda estación en el punto de acceso, ESP-NOW, el ahorro de energía, TLS, y cualquier red que no sea la simulada.
WiFi simulado cubre la red en sí.
Importar desde Wokwi
Un proyecto de Wokwi para un ESP32 DevKit V1, DevKitC o LOLIN32 Lite que tenga un
main.py se importa como un proyecto de MicroPython, con su placa configurada en MicroPython. La red de su placa se llama Wokwi-GUEST sin contraseña, como en Wokwi, así que
wlan.connect("Wokwi-GUEST", "") funciona tal cual está escrito. Mira
Si vienes de Wokwi.
En un ESP32 real
Una placa de 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), luego copia main.py a la placa con Thonny o mpremote. Pon el nombre y la contraseña de tu propia red en wlan.connect(): los sitios .mokxi solo existen en Mokxi.
Proyectos iniciales
Seis proyectos iniciales en un DevKit V1, cada uno en su propia página: blink, un botón con Pin.irq(), un fundido con PWM, un DHT22, una OLED SSD1306 y WiFi y el clima. El simulador de MicroPython para ESP32 recorre los seis.
En otras partes
- Las placas: la ESP32 DevKit V1, la DevKitC y la LOLIN32 Lite
- MicroPython en la Pico: la Pico
- Las páginas de placas: /boards/esp32-devkit y /boards/esp32-devkitc
- El contrato de Arduino del chip: el modelo de ESP32 DevKit