MicroPython desde cero: instala el firmware, conecta al REPL y corre tu primer programa

Python directo en un microcontrolador, sin sistema operativo

¿Y si pudieras conectar un microcontrolador por USB, abrir un terminal, escribir print("hola") y obtener respuesta inmediata, sin compilar, sin Arduino IDE, sin esperar 30 segundos por cada modificación? Eso es MicroPython: una implementación de Python 3 diseñada para correr directamente sobre el chip, con un REPL interactivo accesible por puerto serie. La diferencia de productividad cuando estás explorando una librería nueva es enorme.

Esta guía está inspirada en el tutorial de SparkFun Learn y reorganiza el contenido alrededor de tres preguntas prácticas: ¿qué placa elijo?, ¿cómo le pongo MicroPython?, y ¿cuál entorno uso para escribir código día a día? Al final vas a tener MicroPython instalado, vas a saber conectarte al REPL y vas a correr tu primer programa, sin haber tocado un compilador.

¿Por qué MicroPython (y por qué no Arduino C++)?

Regla pragmática: si estás explorando, prototipando o haciendo automatización liviana, usa MicroPython. Si estás haciendo un producto con timing crítico, bajo consumo extremo, o vas a producción, usa Arduino C++ o el framework ESP IDF.

Placas soportadas (las más relevantes)

MicroPython oficial soporta decenas de placas. Las más usadas y mejor soportadas son:

• Raspberry Pi Pico (RP2040) y Pico 2 (RP2350): el sweet spot precio/comunidad.
• Pico W / Pico 2 W: los anteriores con WiFi y BLE integrado.
• ESP32 / ESP32-S2 / ESP32-S3 / ESP32-C3: todos andan, pero el setup es un poquito más manual que con los Pico.
• Teensy 4.0 / 4.1: ARM Cortex M7 a 600 MHz, los más potentes.
• STM32 (varias): más industrial, soporte excelente en MicroPython upstream.
• SparkFun IoT RedBoard ESP32 y otros boards de SparkFun con MicroPython prefirmado.

Para esta guía vamos a cubrir los dos casos más comunes: RP2040/RP2350 (arrastrar y soltar) y ESP32 (esptool).

Camino 1 · RP2040 / RP2350, el más fácil del mundo

Los chips Raspberry RP tienen un cargador USB integrado que aparece como un disco USB normal, sin drivers, sin terminales raros.

1. Mientras la placa está desconectada, mantén pulsado el botón BOOTSEL y conecta el USB. Suelta el botón. La placa aparece como un drive USB llamado RPI-RP2.
2. Descarga el firmware MicroPython más reciente para tu chip:
   • Pico (RP2040): https://micropython.org/download/RPI_PICO/
   • Pico 2 (RP2350): https://micropython.org/download/RPI_PICO2/
   • Pico W (RP2040 con WiFi): https://micropython.org/download/RPI_PICO_W/
3. Arrastra el archivo .uf2 descargado al drive RPI-RP2. La placa se reinicia sola y desaparece como disco: ahora es un dispositivo serial corriendo MicroPython.

Eso es todo. Ya tienes MicroPython en la placa.

Camino 2 · ESP32, con esptool

ESP32 requiere esptool.py, un binario Python que escribe firmware por serial.

1. Instala esptool (necesitas Python 3 con pip):
   Bash Copiar

   pip install esptool
   

2. Descarga el firmware ESP32 más reciente: https://micropython.org/download/ESP32_GENERIC/
3. Conecta la placa por USB. Identifica el puerto:
   • Linux/Mac: ls /dev/tty.usbserial-* o ls /dev/ttyUSB*
   • Windows: ver Administrador de dispositivos, COMx
4. Borra la flash (recomendado antes del primer flasheo):
   Bash Copiar

   esptool.py --chip esp32 --port /dev/ttyUSB0 erase_flash
   

5. Escribe el firmware:
   Bash Copiar

   esptool.py --chip esp32 --port /dev/ttyUSB0 --baud 460800 write_flash -z 0x1000 ESP32_GENERIC-20240105-v1.22.0.bin
   

Si te da error de "Failed to connect", probablemente necesites mantener apretado el botón BOOT durante el write_flash (algunos ESP32 no entran al bootloader automáticamente).

Tu primer programa: comprobar que MicroPython responde

Antes de cablear nada, conviene confirmar que el firmware quedó bien y que tu entorno habla con la placa. El programa más simple para eso pide a la placa que reporte sobre qué plataforma está corriendo:

import sys
print("Hola desde (Micro)Python. Estoy corriendo en la plataforma:", sys.platform)

Si lo corres en tu computador, sys.platform devuelve win32 o linux. Si lo corres en la placa, devuelve el identificador del chip: rp2 en un Raspberry Pi Pico 2 y esp32 en un ESP32. Es la forma más rápida de confirmar que estás ejecutando código en el microcontrolador y no en tu PC.

Entornos de desarrollo: las tres opciones reales

Una vez que el firmware está instalado, necesitas una herramienta para escribir código, subirlo a la placa y leer el REPL. Hay tres caminos según tu estilo de trabajo.

Thonny, el IDE oficial recomendado para principiantes

Open source, multiplataforma, soporta MicroPython de fábrica. Lo bajas en https://thonny.org, lo instalas, y vas a Tools → Options → Interpreter para elegir el intérprete según tu placa: MicroPython (Raspberry Pi Pico), MicroPython (ESP32) o el genérico. Selecciona el puerto COM correspondiente y listo.

Con el panel Files activado (menú View → Files) ves dos exploradores: el de tu computador arriba y el de la placa abajo. Creas un archivo nuevo en el dispositivo, escribes el código y lo guardas directo en la placa.

Pulsas el botón verde de ejecución y la salida aparece abajo, en el panel Shell, que es el REPL en vivo. Acá confirmas que la placa respondió con su identificador de plataforma.

mpremote, la línea de comando moderna

Para usuarios cómodos en terminal:

pip install mpremote
mpremote connect /dev/ttyUSB0 repl     # entrar al REPL
mpremote cp main.py :main.py            # copiar archivo
mpremote run blink.py                   # correr sin copiar
mpremote ls                              # listar archivos en la placa

Una vez dentro del REPL puedes navegar el sistema de archivos de la placa con el módulo os (os.listdir(), os.getcwd()) tal como lo harías en Python de escritorio. Con mpremote mount incluso montas una carpeta local de tu PC dentro de la placa, así editas en tu editor favorito sin copiar archivos a cada rato.

mpremote es mucho más rápido que Thonny para usuarios power, y funciona genial con git: puedes tener tu carpeta local versionada y sincronizar a la placa con un script.

PyCharm con el plugin MicroPython Tools

Para proyectos grandes con varios archivos. PyCharm Community Edition tiene autocompletado del API de MicroPython (vía paquetes de stubs) y un plugin (MicroPython Tools) que sube archivos al device y abre el REPL. Más pesado, pero más profesional cuando el proyecto crece.

Tu siguiente programa: parpadear un LED

Con MicroPython funcionando, el clásico siguiente paso es encender y apagar el LED integrado de la placa. Es la prueba de que controlas un pin:

from machine import Pin
import time

# En Pico/Pico W: LED interno = Pin("LED")
# En ESP32 genérico: típicamente GPIO 2
led = Pin("LED", Pin.OUT)

while True:
    led.value(1)
    time.sleep(0.5)
    led.value(0)
    time.sleep(0.5)

Guárdalo como main.py en la placa. Cualquier archivo llamado main.py se ejecuta automáticamente al boot, esa es la convención. Para detenerlo, abre el REPL y pulsa Ctrl+C.

Variantes y mejoras

• CircuitPython como alternativa. Es un fork de MicroPython mantenido por Adafruit, más opinionado pero con drivers excelentes para sus shields. Si vas a usar mucho hardware Adafruit, considera CircuitPython.
• Computadores de placa única con Python real. Raspberry Pi 4/5 corren CPython completo. Si necesitas librerías pesadas (NumPy, OpenCV, scikit-learn) no van en MicroPython, tienes que pasar a una Pi.
• Instalar módulos con mip. mip es el package manager de MicroPython (similar a pip). Puedes instalar módulos directamente desde GitHub o desde un mirror local: mip.install("github:user/repo").
• Sumar typings con stubs. El ecosistema micropython-stubs te da autocompletado y type checking en VS Code o PyCharm aunque MicroPython no traiga el módulo typing completo.

Personalización para Chile (MechatronicStore)

Para empezar mañana solo necesitas una placa soportada y el cable USB correcto. Todo lo demás (el computador con Thonny, mpremote o PyCharm) ya lo tienes:

• Raspberry Pi Pico 2 W (RP2350): el chip más nuevo, soportado oficialmente por MicroPython, con WiFi y BLE. La elección recomendada para arrancar con MicroPython en 2026. Usa el camino de arrastrar y soltar (sin esptool).
• Placa ESP32 (USB C): la alternativa popular con más memoria y más periféricos, soporte MicroPython maduro. Usa el camino con esptool.
• Cable USB a Micro USB: para alimentar y programar el Raspberry Pi Pico (el ESP32 con puerto USB C trae su propio cable).

Los boards SparkFun específicos del tutorial (Teensy, XRP, IoT RedBoard RP2350) son hardware más nicho y no están en stock chileno habitual: el Raspberry Pi Pico es funcionalmente equivalente para todos los ejemplos.

Recursos

• Tutorial original: Setup and Using MicroPython for Beginners, SparkFun Learn
• MicroPython oficial: https://micropython.org
• Documentación API: https://docs.micropython.org/en/latest/
• Thonny IDE: https://thonny.org
• esptool: https://github.com/espressif/esptool
• mpremote: https://docs.micropython.org/en/latest/reference/mpremote.html
• Stubs para autocompletado (micropython-stubs): https://github.com/Josverl/micropython-stubs

Versión chilena con componentes en stock local en MechatronicStore.