Si ya te manejas con Python «normal» y acabas de descubrir que existe MicroPython para placas tipo Arduino y ESP, es bastante probable que ahora mismo tengas la cabeza llena de dudas: qué es exactamente, en qué se diferencia de Python de escritorio, qué placas soporta, cómo se instala o qué pinta tiene eso de programar un microcontrolador con un intérprete de Python integrado.
En los últimos años, el ecosistema de MicroPython y hardware como Arduino, ESP32, ESP8266 o RP2040 ha explotado en popularidad. Al mismo tiempo, Arduino ha pasado de ignorar prácticamente Python a crear su propio editor especializado, colaborar directamente con el creador de MicroPython y ofrecer firmware ya compilado para muchas de sus placas modernas. Vamos a ver con calma todo este panorama, bajando a los detalles prácticos y enlazando los distintos elementos de la información que ya existe dispersa por la red.
Qué es exactamente MicroPython y en qué se diferencia de Python
MicroPython es una implementación de Python 3 pensada para microcontroladores, escrita en C y tremendamente optimizada para funcionar en dispositivos con recursos muy limitados: poca memoria RAM, poco almacenamiento, mucha restricción de consumo, etc. No hablamos de tu viejo PC del instituto, sino de placas diminutas como las de la familia Arduino, ESP8266, ESP32, BBC micro:bit o microcontroladores ARM como los STM32 o los RP2040.
A nivel interno, MicroPython incluye un compilador de código Python a bytecode y un intérprete que ejecuta ese bytecode directamente en el microcontrolador. En muchos casos puedes escribir scripts .py, copiarlos al dispositivo y ejecutarlos al vuelo, pero también existe la opción de precompilar a archivos .mpy y “congelarlos” dentro del propio firmware para ganar velocidad y ahorrar memoria.
Desde el punto de vista del usuario, uno de los elementos clave es el REPL (Read-Eval-Print Loop) interactivo, al que te conectas por puerto serie/USB y desde el que puedes teclear instrucciones en tiempo real, probar cosas rápidas, inspeccionar el estado del hardware o depurar sin necesidad de recompilar continuamente.
En cuanto a sintaxis, MicroPython respeta prácticamente toda la sintaxis de Python 3.4 (incluyendo excepciones, context managers con with, construcciones como yield from, etc.) e incorpora además elementos de Python 3.5 como async y await. Donde sí se recorta es en la cantidad de módulos estándar disponibles: no tiene sentido cargar en un microcontrolador todo el arsenal de la librería estándar de Python de escritorio.
Para compensar esa reducción, MicroPython aporta módulos específicos para manejo de hardware de bajo nivel: control de GPIO, buses I2C/SPI/UART, PWM, acceso a sensores, gestión de memoria flash, WiFi, BLE, etc. Es decir, sacrifica cosas que en un PC no echarías de menos en un micro, y a cambio te da herramientas para exprimir los periféricos típicos de las placas de desarrollo.
Un poco de historia: de la PyBoard a un ecosistema enorme
En sus comienzos, MicroPython sólo se podía usar en la PyBoard original, una placa diseñada por Damien George (creador del proyecto) basada en un microcontrolador STM32F4. Era un entorno muy controlado, pensado casi como demostración de que Python podía vivir dentro de un micro.
Con el paso del tiempo, el proyecto fue creciendo, se abrieron más puertos y hoy en día MicroPython se ejecuta en una gran variedad de familias de microcontroladores. Entre los más populares destacan los SoC WiFi ESP8266 y ESP32, los RP2040 de Raspberry Pi, un buen número de STM32, SAMD de Microchip, nRF de Nordic, familias Renesas RA, y otros muchos chips ARM y no ARM.
Esta expansión se ha materializado en forma de numerosos “ports” o adaptaciones de MicroPython a cada arquitectura: esp8266, esp32, rp2 (RP2040), samd, stm32, nrf, mimxrt, renesas-ra, rp2350, cc3200, por citar algunos de los más visibles. Cada port incluye el soporte básico de la MCU y, en muchos casos, controladores para periféricos de placas concretas.
Todo el desarrollo se coordina en torno al repositorio oficial de GitHub: github.com/micropython/micropython, donde está el código fuente completo. Desde ahí puedes compilar el proyecto o descargar distribuciones ya hechas. El proyecto también genera distribuciones de código fuente y snapshots diarios, y cuenta con un sistema automatizado de generación de firmware para un buen número de placas soportadas.
Además del repositorio, existe infraestructura de compilación continua que genera cada día firmware listo para flashear en distintas placas y puertos. Estos builds automáticos permiten probar características nuevas o verificar correcciones de errores sin tener que montar tú mismo todo el entorno desde cero.
MicroPython y Arduino: de la desconexión al trabajo conjunto
Durante bastante tiempo, la relación entre Arduino y MicroPython fue más bien distante. Aunque Arduino se había convertido en el estándar de facto para aficionados, educación y prototipado rápido, su ecosistema oficial giraba en torno a C/C++ y a la API clásica de Arduino (setup/loop, etc.).
Mientras tanto, MicroPython se consolidaba como uno de los lenguajes más interesantes para programar microcontroladores: sintaxis limpia, rapidez de desarrollo, flexibilidad, facilidad para enseñar programación… y sin embargo, el soporte oficial para placas Arduino brillaba por su ausencia. Lo poco que había eran iniciativas no oficiales, ports experimentales o hacks específicos para ciertos modelos.
Resultaba llamativo que uno de los mejores lenguajes para micros y una de las plataformas hardware más populares prácticamente no se hablasen entre sí. Eso dejaba a muchos usuarios con la sensación de estar forzados a C/C++ aunque prefirieran Python, o a cambiarse a otras placas donde MicroPython sí estaba bien soportado.
Con el tiempo, en Arduino se dieron cuenta de que Python se había convertido en la lengua franca para muchos perfiles de usuario: estudiantes, científicos de datos, gente de IA, programadores que venían del mundo web, etc. Empezaron a experimentar con MicroPython en entornos educativos y detectaron un problema claro: era complicado encontrar un IDE de MicroPython multiplataforma realmente sencillo que estuviera a la altura de la experiencia de usuario del IDE clásico de Arduino.
La solución que adoptaron fue colaborar directamente con Damien George para portar la máquina virtual de MicroPython a placas Arduino modernas y, además, construir un editor propio adaptado a este flujo de trabajo. Esa colaboración cristalizó en un producto concreto que ha marcado un punto de inflexión en el soporte oficial de Python dentro del ecosistema Arduino.
Arduino Lab for MicroPython: el IDE ligero para tus placas
De esa colaboración salió Arduino Lab for MicroPython, un editor específico para trabajar con MicroPython sobre placas Arduino y otros microcontroladores compatibles. En lugar de un simple plugin para el IDE tradicional de Arduino, se optó por una aplicación independiente, ligera y centrada en las necesidades típicas de este tipo de proyectos.
Arduino Lab for MicroPython es, básicamente, un entorno muy sencillo para editar código, conectarte a la placa, subir scripts, gestionar archivos y usar el REPL. Está disponible para Linux, macOS y Windows, y se orienta a quienes quieren la facilidad del mundo Arduino pero programando en MicroPython.
Entre sus capacidades principales se incluyen la conexión directa con la placa por puerto serie/USB, la carga de código .py, la transferencia de otros ficheros al sistema de archivos interno del microcontrolador y el acceso al shell interactivo de MicroPython para experimentar en tiempo real.
Desde la propia Arduino lo definen como una herramienta todavía “experimental”, aunque totalmente funcional y ya disponible para que la comunidad juegue con ella y dé feedback. Tanto es así que han abierto un espacio específico en su sitio de Arduino Labs para seguir la evolución del proyecto.
Para el usuario final, esto se traduce en que, sin tener que pelearte con configuraciones rebuscadas, puedes empezar a escribir y probar MicroPython en placas Arduino recientes con muy pocos pasos adicionales, aprovechando la curva de aprendizaje suave que siempre ha caracterizado al ecosistema Arduino.
Firmware de MicroPython para placas Arduino y otros microcontroladores
Uno de los pilares del ecosistema MicroPython actual es la disponibilidad de firmware ya precompilado para un montón de placas de distintos fabricantes, entre ellos Arduino. Estos firmwares se construyen de forma automatizada a diario y se publican en los servidores del proyecto.
En estas compilaciones diarias se puede filtrar por “port” (esp32, esp8266, rp2, stm32, samd, nrf, renesas-ra, cc3200, etc.), por “feature” (WiFi, BLE, USB, Ethernet, cámara, DAC, display, SD, micrófono, LoRa, PoE, memoria externa flash/RAM, etc.) y también por fabricante, donde encontrarás específicamente la opción de seleccionar “Arduino” como proveedor.
Al elegir el fabricante Arduino, verás una lista de modelos soportados con firmware de MicroPython generado automáticamente. Entre las placas que aparecen como compatibles se encuentran, por ejemplo, Giga, Arduino Nano 33 BLE Sense, Arduino Nano ESP32, Arduino Nano RP2040 Connect, la serie Nicla (como Nicla Vision), Portenta C33, Portenta H7, Opta WiFi, Primo y otros modelos modernos.
Cada una de estas placas se apoya internamente en una MCU concreta: esp32, esp32s2, esp32s3, RP2040, SAMD21, SAMD51, STM32 de distintas familias, Renesas RA4/RA6, nRF52
Esta infraestructura de builds diarios hace que no tengas que compilar siempre el firmware por tu cuenta: en muchos casos basta con descargar la imagen adecuada e instalarla en tu placa para empezar a programar con MicroPython al momento.
Ejemplo práctico de compilación de firmware: Seeeduino XIAO SAMD
Aunque tengas firmwares ya hechos, en ocasiones puede interesarte compilar MicroPython tú mismo: para activar módulos personalizados, optimizar para una placa concreta o simplemente entender mejor el proceso. Un ejemplo bastante documentado es el del Seeeduino XIAO SAMD, una placa diminuta basada en microcontroladores SAMD de arquitectura ARM que ya cuenta con soporte oficial de MicroPython.
El flujo típico arranca con la preparación del entorno de compilación en un sistema tipo Debian/Ubuntu. Para compilar para ARM se utiliza una toolchain cruzada como arm-none-linux-gnueabi, que puedes instalar con el gestor de paquetes habitual (en Debian/Ubuntu, mediante el paquete gcc-arm-linux-gnueabi o similar). Junto a eso, necesitarás herramientas como gcc, make, git y Python instaladas en tu máquina.
Una vez tienes el entorno listo, el siguiente paso es clonar el repositorio oficial de MicroPython y descargar los submódulos necesarios. El propio proyecto incluye scripts y ficheros de configuración que indican desde qué repositorios se obtiene cada dependencia externa y en qué ruta se deben colocar.
Antes de compilar el firmware específico, casi todos los ports requieren generar el compilador cruzado mpy-cross. Este pequeño programa se utiliza para precompilar scripts Python a bytecode (.mpy) que luego se pueden incluir congelados dentro del firmware, algo especialmente útil cuando se quiere integrar librerías personalizadas sin depender del sistema de archivos de la placa.
Con mpy-cross ya construido, se procede a compilar las dependencias externas y el propio firmware del port elegido, en este caso el correspondiente a la familia SAMD. Normalmente se especifica la versión o el modelo concreto (como el Seeeduino XIAO SAMD), se entra en el directorio adecuado dentro del árbol de MicroPython y se lanza el comando de compilación con las opciones pertinentes.
Al terminar la compilación, obtendrás un archivo de firmware listo para grabar en la placa. El proceso de flasheo puede variar ligeramente según la placa, pero a menudo se reduce a poner el dispositivo en modo bootloader y copiar el archivo de firmware a la unidad que aparece en tu sistema al pulsar un botón de reset especial.
Una vez instalado el firmware de MicroPython, puedes probarlo con un ejemplo sencillo, como un script que haga parpadear el LED integrado de la placa. Copias el código a la placa (o lo ejecutas directamente desde el REPL) y, si el LED empieza a parpadear tal y como esperabas, es señal de que tu nuevo firmware MicroPython está en marcha.
Características clave del lenguaje MicroPython en este contexto
Desde el punto de vista de quien viene de Python estándar, conviene recordar que MicroPython ofrece “Python menos algunas cosas y más otras”. Mantiene la sintaxis y muchas de las construcciones avanzadas, pero recorta y reorganiza la librería estándar para adaptarla al entorno embebido.
No vas a encontrar todas las utilidades que conoces del Python de escritorio, porque muchas simplemente no tienen sentido en un microcontrolador con unos pocos cientos de kilobytes de memoria. Sin embargo, sí verás módulos específicos que encapsulan funcionalidades muy habituales en proyectos de electrónica: control de pines digitales, lectura analógica, PWM, buses de comunicación serie, acceso directo a registros, etc.
Otra característica interesante es la posibilidad de usar scripts .py “al vuelo” o archivos .mpy precompilados. Con .py tienes máxima flexibilidad para desarrollar y probar, mientras que los .mpy congelados en firmware te permiten agrupar librerías y lógica crítica de forma más eficiente y robusta.
Todo esto se combina con el REPL interactivo, que es una especie de consola Python pegada al microcontrolador. Puedes conectar vía USB/serie, escribir instrucciones, inspeccionar variables, probar pequeñas rutinas de lectura de sensores o control de actuadores, y sólo cuando lo tienes claro pasar tu código a un script permanente.
Para quien se inicia en la programación de hardware, esta mezcla de sintaxis conocida, feedback inmediato y acceso directo al hardware hace que la experiencia sea muy diferente a la clásica de C/C++ con ciclos de compilar-subir-probar, reduciendo enormemente el tiempo hasta ver resultados.
¿Funciona MicroPython con todas las placas Arduino?
Una duda muy habitual de quien descubre el tema es si MicroPython es compatible con “todas” las placas Arduino, incluidas las más antiguas como Arduino Uno basadas en microcontroladores AVR. Aquí la respuesta corta es que no, al menos no de forma oficial ni práctica para la mayoría de usuarios.
Las placas clásicas tipo Arduino Uno, Nano o Mega con chips AVR tienen recursos muy limitados para lo que exige una máquina virtual de Python: poca RAM, muy poca memoria de programa y un hardware pensado para otro tipo de entornos. Por eso, MicroPython no las soporta de forma estándar, y cualquier intento de port sería muy comprometido en funcionalidades y rendimiento.
En cambio, las placas Arduino modernas basadas en ARM, ESP32, RP2040 o similares sí entran de lleno en el rango de dispositivos para los que MicroPython ha sido diseñado. Son estos modelos los que aparecen en los firmwares automáticos y los que reciben atención en herramientas como Arduino Lab for MicroPython.
Si tienes una placa como Arduino Uno y quieres usar algo parecido, la opción más realista suele ser dar el salto a una placa compatible con MicroPython (por ejemplo, un ESP32, un ESP8266, un RP2040 o una placa Arduino reciente basada en estas arquitecturas) o quedarte con C/C++ en la Uno tradicional.
En cambio, si ya tienes dispositivos como NodeMCU (ESP8266), placas ESP32 o un Arduino Nano RP2040 Connect, ahí sí que puedes instalar fácilmente MicroPython y empezar a programar usando herramientas como esptool, Thonny, Arduino Lab for MicroPython u otros IDEs compatibles.
Qué necesitas para empezar con MicroPython en placas tipo Arduino
Para iniciar tu andadura con MicroPython en una placa compatible no hace falta montar una gran infraestructura. Lo básico es contar con una placa soportada, un cable USB, un firmware adecuado y un editor que hable con el puerto serie.
En el apartado de software, puedes optar por diferentes enfoques: desde IDEs sencillos centrados en MicroPython (como Thonny o el propio Arduino Lab for MicroPython) hasta soluciones más generales donde te conectes tú manualmente al puerto serie y gestiones los scripts por tu cuenta.
Dependiendo del chip de tu placa (ESP8266, ESP32, RP2040, SAMD, etc.), necesitarás un método concreto para flashear el firmware de MicroPython. En los ESP es habitual usar herramientas como esptool; en muchas placas con bootloader USB, el proceso se reduce a copiar el archivo .uf2 o similar a la unidad que aparece en tu sistema al pulsar un botón de reset especial.
Una vez tengas el firmware instalado, te bastará con conectarte al puerto serie/USB correspondiente, abrir el REPL y escribir unas líneas de prueba. En placas tipo NodeMCU o ESP32, el clásico ejemplo de encender y apagar el LED integrado o hacer parpadear un pin de salida es una buena forma de comprobar que todo está correcto.
En cuanto a la elección de IDE, no existe una obligación estricta: puedes usar desde editores muy básicos hasta entornos más completos. Lo importante es que puedas subir fácilmente archivos al dispositivo y tengas acceso al REPL, porque esas dos piezas son el núcleo de la experiencia de desarrollo con MicroPython.
Con todo este ecosistema ya consolidado, la unión entre MicroPython y placas como Arduino, ESP y RP2040 se ha convertido en una combinación muy potente: permite a quienes ya conocen Python dar el salto al mundo del hardware sin tener que aprender desde cero otro lenguaje, al tiempo que proporciona a los makers y a la comunidad educativa una vía rápida para prototipar y explorar proyectos de IoT, robótica, sensores y automatización usando un lenguaje moderno y muy extendido.
