MicroPython

Hola, soy Alex de DEV STORIES DOT EU. MicroPython, episodio 1 de 7. El Python de escritorio normalmente consume megabytes de memoria solo para arrancar. Intenta meter eso en un chip diminuto de dos dólares y el sistema se quedará sin recursos inmediatamente. Para escribir Python para microcontroladores, necesitas un intérprete que quepa en una fracción de ese espacio sin perder las características principales del lenguaje de las que dependes. Eso es exactamente lo que ofrece MicroPython. MicroPython es una implementación ligera y altamente eficiente del lenguaje de programación Python 3. Está diseñado específicamente para ejecutarse en entornos con recursos limitados. El Python estándar, a menudo llamado CPython, asume que se está ejecutando sobre un sistema operativo completo como Linux o Windows, con gigabytes de almacenamiento y mucha RAM. MicroPython le da la vuelta a esta idea. Está construido para ejecutarse en bare metal. No hay un sistema operativo subyacente que gestione el hardware. En su lugar, MicroPython actúa como el sistema operativo. Se comunica directamente con el hardware para que puedas escribir scripts de alto nivel y controlar dispositivos físicos. La ingeniería detrás de esto se centra por completo en las severas limitaciones de recursos. MicroPython puede ejecutarse por completo en tan solo 256 kilobytes de espacio de código compilado. Y lo que es aún más impresionante, requiere apenas 16 kilobytes de RAM para funcionar. Dentro de estos límites tan ajustados, ofrece un entorno Python totalmente funcional. El Python estándar incluye una enorme biblioteca estándar, conocida por su famoso enfoque de batteries included. MicroPython reduce eso a un subconjunto de módulos cuidadosamente seleccionado, manteniendo solo lo que tiene sentido para un sistema embebido. A pesar de estas fuertes optimizaciones, el lenguaje en sí sigue siendo Python 3 auténtico. Esto significa que el código que escribes en tu ordenador se traduce directamente al dispositivo embebido. MicroPython soporta características avanzadas del lenguaje como closures, list comprehensions, generators y el manejo de excepciones estándar. Incluso maneja enteros de precisión arbitraria. Si tu lógica requiere multiplicar números enormes, MicroPython escala la memoria dinámicamente para darte la respuesta correcta sin chocarse contra un límite arquitectónico estricto, exactamente igual que el Python de escritorio. Aquí está la clave. Como todo el motor de Python cabe en el chip, tienes un prompt interactivo en vivo directamente en el hardware. Este read-eval-print loop cambia la forma en la que escribes código embebido. Normalmente, programar un microcontrolador implica escribir código en C, compilarlo en tu ordenador, flashearlo en la placa y esperar a que se ejecute. Con MicroPython, conectas la placa a tu ordenador, abres una terminal serie y escribes comandos de Python directamente en el chip. Puedes probar la lógica, leer valores de sensores o activar acciones al instante. Para que esto sea posible, MicroPython incluye módulos built-in específicos que van más allá del Python estándar. Como el Python estándar no sabe nada sobre leer pines físicos o configurar timers de hardware, MicroPython proporciona interfaces especializadas y altamente optimizadas para estas tareas. Estas están integradas directamente en el firmware de tu chip específico, dándote un control total sobre el mundo físico sin inflar el memory footprint. Al quitar el sistema operativo y encoger el intérprete para que quepa en 256 kilobytes, MicroPython convierte un hardware barato y con pocos recursos en un entorno de desarrollo dinámico e interactivo. Si quieres apoyar el programa, puedes encontrarnos buscando DevStoriesEU en Patreon. Gracias por escucharnos. ¡Hasta la próxima!

Hola, soy Alex de DEV STORIES DOT EU. MicroPython, episodio 2 de 7. Deja de recompilar código en C y flashear firmware solo para probar un sensor o accionar un interruptor. Quieres control directo sobre tu microcontrolador sin el boilerplate, y eso es exactamente lo que ofrece el módulo machine. El módulo machine es tu puente con el hardware. Traduce el código Python en las señales eléctricas que controlan los pines físicos de tu placa. Proporciona acceso a funciones de hardware esenciales como la frecuencia de la CPU, los modos sleep y los inputs y outputs digitales. Pero al estar tan cerca del metal, viene con una advertencia. Este módulo no te lleva de la mano. Si configuras el registro de hardware equivocado o escribes en una dirección de memoria protegida, tu placa hará crash y se reiniciará. La base de este módulo es la clase Pin. Un pin es una conexión física en el microcontrolador que puede enviar o recibir voltajes eléctricos. Para controlar un componente básico como un LED, necesitas aplicar voltaje a un pin específico. Esto lo haces importando el módulo machine y creando un objeto Pin. Le pasas el número del pin físico y defines si el pin debe actuar como input o como output. Para un LED, lo configuras como output pasándole una constante de output. Una vez creado el objeto, lo usas para establecer el estado. Aplicar un valor de uno pone la línea de hardware en alto y enciende el LED. Aplicar un valor de cero la pone en bajo y lo apaga. Estás manipulando el estado digital del hardware en tiempo real desde un prompt de Python. A veces, los estados básicos de encendido y apagado no son suficientes. Si quieres atenuar ese LED o controlar la velocidad de un motor, necesitas Pulse Width Modulation, o PWM. El módulo machine tiene una clase PWM dedicada para esto. En lugar de un flujo constante de voltaje, PWM enciende y apaga el pin rapidísimo. Creas un objeto PWM pasándole el objeto Pin que ya configuraste. Luego, configuras dos parámetros de hardware: la frecuencia y el duty cycle. Aquí está la clave. La frecuencia dicta cuántas veces por segundo hace un ciclo la señal, mientras que el duty cycle dicta qué porcentaje de ese tiempo la señal está realmente encendida. Si ajustas el duty cycle al cincuenta por ciento, el LED solo recibe energía la mitad del tiempo, haciendo que parezca la mitad de brillante para el ojo humano. Al cambiar gradualmente ese valor del duty cycle dentro de un loop, le indicas al hardware que cree un efecto de desvanecimiento suave. Para casos de uso avanzados, el módulo machine ofrece acceso directo a los registros de hardware subyacentes a través de objetos llamados mem8, mem16 y mem32. Estos te permiten leer y escribir raw bytes, half-words o words de 32 bits directamente en direcciones de memoria específicas. No usas un objeto Pin para esto. Usas la notación estándar de corchetes, pasando la dirección de memoria física a la que quieres acceder, exactamente igual que al buscar una key en un diccionario. Asignar un valor a una dirección mem32 sobrescribe instantáneamente ese registro de hardware. Así es como interactúas con funciones oscuras del microcontrolador que MicroPython aún no ha encapsulado explícitamente en una clase. Te da autoridad absoluta sobre el silicio. El verdadero poder del módulo machine no es solo que hace accesible el hardware, sino que elimina por completo la barrera entre escribir lógica de software de alto nivel y manipular el voltaje físico. Gracias por escuchar. Cuidaos todos.

Hola, soy Alex de DEV STORIES DOT EU. MicroPython, episodio 3 de 7. Olvídate del tedioso ciclo de compile, flash y reboot. En un proyecto embebido típico, cambias una variable, esperas minutos a que termine la build, escribes en la memoria flash y esperas que funcione. MicroPython se salta todo esto permitiéndote hablar directamente con el chip en tiempo real. Este episodio trata sobre hacer Live Coding en la MCU usando el REPL y mpremote. El REPL significa Read-Eval-Print Loop. Es un prompt interactivo que se ejecuta directamente en tu microcontrolador. Conectas tu placa por USB, abres una terminal serie, escribes código Python y el chip lo ejecuta al instante. El REPL estándar está diseñado para humanos. Ofrece auto-indentación, historial de comandos y autocompletado básico. Es perfecto para probar un toggle rápido de un pin de hardware. Sin embargo, existe un segundo modo llamado raw REPL. La gente suele confundir esto con una versión limitada de MicroPython, pero en realidad es solo un modo de entrada diferente que se activa enviando un carácter de control específico por el puerto serie. El raw REPL desactiva el echo de caracteres y la auto-indentación. Las herramientas usan el raw REPL para inyectar programáticamente grandes bloques de código en el microcontrolador. Si un script intentara pegar texto en el REPL estándar, la auto-indentación pensada para humanos caería en cascada y destrozaría por completo el formato de Python. El raw REPL garantiza que el código entre exactamente como está escrito. Esto nos lleva a mpremote. Esta es la herramienta de línea de comandos oficial para interactuar con dispositivos MicroPython, y maneja el raw REPL por debajo para hacer el trabajo pesado. Para hacer live coding, mpremote ofrece dos comandos muy potentes: run y mount. Usas el comando run para ejecutar un script local de tu ordenador directamente en la placa. Escribes tu código en tu editor de texto favorito, abres tu terminal e invocas mpremote run seguido del nombre de tu archivo. Aquí está la clave. El código se envía por la línea serie y se ejecuta completamente en la RAM del microcontrolador. Nunca se escribe en la memoria flash del dispositivo. Si escribes un mal bucle y crasheas la placa, simplemente le haces un hard reset al chip. La flash permanece intacta, ahorrando ciclos de escritura, y tu ciclo de desarrollo tarda segundos. Cuando tu proyecto crece más allá de un solo script, usas el comando mount. Este comando le dice a mpremote que coja un directorio local de tu PC y lo mapee a través de la conexión serie. El microcontrolador anula temporalmente su propio almacenamiento y trata esa carpeta de tu ordenador como si fuera su filesystem interno. Imagina un escenario en el que estás escribiendo un driver de pantalla complejo. Normalmente, tendrías que copiar el archivo del driver a la placa, ejecutar tu script principal, observar un glitch en la pantalla, editar el archivo en tu PC y volver a copiarlo. Con el comando mount, el microcontrolador ejecuta el driver directamente desde el almacenamiento de tu PC. Le das a guardar en tu editor de texto en tu portátil, reinicias el script en la placa y los cambios se aplican de inmediato. Iteras tan rápido como tecleas, eliminando por completo el paso de flasheo de tu workflow. El verdadero poder de MicroPython no es solo la sintaxis de Python en sí, sino cómo herramientas como mpremote borran la frontera entre tu entorno de desarrollo local y el hardware embebido físico. Eso es todo por este episodio. ¡Gracias por escuchar, y a seguir programando!

Hola, soy Alex de DEV STORIES DOT EU. MicroPython, episodio 4 de 7. Conectar un microcontrolador básico a una red WiFi usando código C tradicional suele requerir cientos de líneas de boilerplate solo para inicializar la radio y gestionar el handshake. Es tedioso y propenso a errores. En MicroPython, puedes levantar una conexión inalámbrica en literalmente tres líneas. Ese es el trabajo del módulo network, específicamente de la clase WLAN. El módulo network abstrae las interfaces de red del hardware subyacente. Para operaciones WiFi, dependes de la clase network punto WLAN. Un chip WiFi estándar puede operar en dos roles distintos. Tienes que definir explícitamente qué rol quieres cuando creas el objeto WLAN. El primer rol es el modo Station, que se especifica usando la constante STA guion bajo IF. Usas el modo Station cuando tu hardware necesita conectarse como cliente a un router superior, igual que un smartphone uniéndose a una red doméstica. El segundo rol es el modo Access Point, que se especifica usando AP guion bajo IF. En este modo, el microcontrolador actúa como su propio router, emitiendo su propia red inalámbrica para que dispositivos externos puedan conectarse directamente a él. El modo Access Point es increíblemente útil al hacer deploy de hardware en ubicaciones remotas donde no hay ninguna red externa, permitiéndote conectarte localmente para la configuración. Conectar tu placa a la red requiere una secuencia específica. Primero, creas el objeto WLAN usando la constante del modo Station. Por defecto, la radio WiFi física está apagada para ahorrar energía. Tienes que encenderla pasándole True al método active de tu objeto WLAN. Una vez que la interfaz está activa, invocas el método connect con el nombre y la contraseña de tu red inalámbrica. Aquí está la clave. El método connect es estrictamente no bloqueante. Cuando lo invocas, MicroPython le pasa las credenciales al procesador de red e inmediatamente continúa ejecutando tu script. Deliberadamente no espera a que termine la autenticación de red. Este diseño permite que tu aplicación principal actualice una pantalla o lea un sensor mientras la radio negocia con el router en segundo plano. Sin embargo, si tu código intenta enviar datos inmediatamente después de llamar a connect, la operación fallará porque la placa en realidad aún no tiene conexión. Esto lo gestionas haciendo polling a la interfaz. El objeto WLAN proporciona un método llamado isconnected, que devuelve un valor boolean simple. El patrón estándar es escribir un loop while que evalúe si isconnected es false. Dentro de este loop, introduces un pequeño delay, como hacer un sleep de medio segundo. La ejecución se pausa aquí, comprobando repetidamente el estado del hardware hasta que el router finalmente acepta la conexión y isconnected devuelve true. Una vez que el loop termina, el hardware está oficialmente online. Para verificar los detalles de la red, llamas al método ifconfig en tu objeto WLAN. Este método devuelve una colección de cuatro elementos específicos: la dirección IP asignada, la máscara de subred, el gateway y el servidor DNS principal. Puedes extraer el primer elemento de esta colección e imprimirlo en la consola para ver exactamente qué dirección IP le asignó el router a tu placa. La naturaleza no bloqueante del método connect significa que siempre eres responsable de verificar el estado del hardware antes de intentar enrutar datos por la red. Eso es todo por hoy. Gracias por escuchar, ve a construir algo genial.

Hola, soy Alex de DEV STORIES DOT EU. MicroPython, episodio 5 de 7. A Python le encanta asignar memoria dinámicamente, creando nuevos objetos para cada cálculo. Eso funciona perfectamente en un servidor, pero en un microcontrolador, ese hábito acabará colgando tu placa, dejándote mirando un memory error incluso cuando parece que te sobra RAM. Hoy nos centramos en sobrevivir a las limitaciones: la RAM y el GC. La memoria donde viven tus objetos de Python se llama heap. En MicroPython, el heap es increíblemente pequeño. Cuando creas objetos, ocupan bloques de espacio. Cuando esos objetos ya no son necesarios, se eliminan. Esto deja huecos en tu memoria. Con el tiempo, a medida que se crean y destruyen objetos de distintos tamaños, tu heap acaba pareciendo un queso gruyer. Esto es la fragmentación del heap. Y aquí está la clave. Cuando necesitas alojar un nuevo objeto, MicroPython necesita un único bloque de memoria contiguo para que quepa. Si tu heap está muy fragmentado, podrías tener veinte kilobytes de RAM libre en total, pero ningún hueco mayor de un kilobyte. Si pides dos kilobytes, tu programa se cuelga. Tienes que dejar de desperdiciar RAM, empezando por tus variables globales. Si tienes valores enteros que nunca cambian, como números de pin o direcciones de hardware, no los asignes de forma normal. MicroPython proporciona una declaración especial llamada const. Si envuelves tu entero en esta declaración const, el compilador reemplaza el nombre de la variable por el número real en todo tu código durante la compilación. Esto evita por completo que se cree una variable en la RAM. Luego, échale un vistazo a tus bucles. La creación dinámica de objetos dentro de un bucle rápido es la causa principal de la fragmentación. Estás leyendo un sensor a través de un bus SPI cien veces por segundo. Si usas un comando read estándar, MicroPython crea una secuencia de bytes totalmente nueva en memoria para cada lectura. Esos objetos se acumulan rápidamente, llenando los huecos y destruyendo tu espacio contiguo. En lugar de crear nuevos objetos, reutiliza los que ya tienes. Antes de que empiece tu bucle, crea un bytearray del tamaño correcto. Un bytearray es un bloque de memoria mutable. Luego, dentro de tu bucle, usa un método de hardware llamado readinto. Le pasas tu bytearray preexistente a readinto. El hardware vuelca los datos del sensor directamente en ese mismo bloque de memoria, sobrescribiendo los datos antiguos. Procesas los datos, el bucle se repite, y se asigna cero memoria nueva. Incluso programando con cuidado, la creación de algunos objetos es inevitable, lo que nos lleva al garbage collector. Por defecto, el garbage collector se ejecuta automáticamente cuando falla la asignación de memoria. Escanea en busca de objetos no utilizados y libera su espacio. Sin embargo, este proceso lleva tiempo. Si se dispara automáticamente durante una operación sensible al tiempo, tu código se pausará de forma impredecible. Para solucionar esto, toma el control. Llama explícitamente a la función collect del módulo gc. Busca un punto seguro en tu código, como el final de tu bucle principal, y lanza la recolección allí. Esto mantiene el heap limpio según tu planificación, evitando retrasos inesperados. En el Python de escritorio, la memoria es algo que el lenguaje gestiona por ti, pero en MicroPython, la memoria es un contenedor físico que tienes que empaquetar a mano. Eso es todo por este episodio. Gracias por escuchar, ¡y sigue programando!

Hola, soy Alex de DEV STORIES DOT EU. MicroPython, episodio 6 de 7. Subes un archivo Python perfectamente válido a tu microcontrolador, escribes import, y la placa se bloquea al instante con un error out-of-memory. El código en sí está bien, pero el proceso de cargarlo acaba de consumir toda tu memoria disponible. Para solucionar esto, necesitas saltarte el compilador del dispositivo, lo que nos lleva al código compilado frente al código congelado para los deploys en producción. Cuando ejecutas un script de Python estándar en un ordenador de escritorio, la memoria es prácticamente infinita. En un microcontrolador, la memoria está estrictamente limitada. Cuando metes un archivo fuente de Python estándar en tu dispositivo y ejecutas el comando import, MicroPython no se limita a leer el archivo. El compilador arranca ahí mismo, en el microcontrolador. Parsea el texto, construye un árbol de sintaxis abstracta y genera el bytecode. Cada uno de esos pasos reserva memoria en la RAM. Imagina un framework de IoT grande que gestiona networking, seguridad y datos de sensores. Si intentas importar este módulo tan masivo desde un archivo fuente estándar, es muy probable que el compilador agote la memoria heap disponible antes de que se llegue a ejecutar la primera línea de tu aplicación real. El pico de uso de RAM durante la fase de compilación mata el proceso. Para evitar esto, necesitas quitar el paso de compilación del microcontrolador. Esto lo haces precompilando tu código con una herramienta de escritorio llamada cross-compiler, o mpy-cross. Ejecutas esta herramienta en tu ordenador principal. Coge tu archivo fuente de Python y saca un archivo compilado con extensión M-P-Y. Este archivo contiene el bytecode pregenerado. Cuando transfieres este archivo compilado al microcontrolador y lo importas, MicroPython reconoce el formato y se salta la fase de compilación por completo. Evitas por completo el pico de memoria causado por el compilador. Aquí es donde la cosa se pone interesante. Aunque precompilar te salva del pico de memoria de la compilación, el microcontrolador sigue cargando el bytecode real desde el file system a la RAM para poder ejecutarlo. Si tu framework de IoT es lo bastante grande, el bytecode por sí solo seguirá consumiendo demasiada RAM, dejándote con muy poco espacio para las variables y los datos de tu aplicación. Cuando los archivos precompilados no son suficientes, el último paso es congelar el bytecode. Congelar significa integrar el código compilado directamente en el firmware de MicroPython. En lugar de copiar el archivo compilado al file system de la placa, lo metes en un directorio de módulos específico dentro del código fuente de MicroPython en tu ordenador. Luego, reconstruyes toda la imagen del firmware de MicroPython desde cero y flasheas este firmware personalizado en tu placa. Esto cambia exactamente cómo se ejecuta el código. Cuando importas un módulo congelado, MicroPython no copia el bytecode en la RAM en absoluto. Como el código está integrado en el firmware, reside permanentemente en la memoria flash del microcontrolador. MicroPython ejecuta el bytecode directamente desde la flash. Al ejecutar desde la flash, el footprint de RAM de importar ese framework de IoT tan masivo cae a casi cero. Toda tu RAM se queda completamente libre para procesar datos en tiempo real. La diferencia fundamental se reduce a dónde vive tu código mientras se ejecuta. Precompilar ahorra memoria durante el paso de import, pero congelar ahorra memoria durante toda la vida del programa al forzar que la ejecución ocurra completamente en la memoria flash. Si te gustaría apoyar el programa, puedes buscar DevStoriesEU en Patreon. Eso es todo por este episodio. Gracias por escuchar, ¡y a seguir programando!

Hola, soy Alex de DEV STORIES DOT EU. MicroPython, episodio 7 de 7. Escribir una Interrupt Service Routine de hardware en un lenguaje de alto nivel con garbage collection suena a pedir a gritos un system crash inmediato. Pero MicroPython en realidad lo permite, siempre y cuando cumplas una regla inquebrantable: cero memory allocation. Este episodio trata sobre el Determinismo en Python: Timers e Interrupts. Cuando necesitas leer un sensor exactamente mil veces por segundo, un loop estándar con una función sleep fallará. El garbage collection y las background tasks introducen retrasos aleatorios, destruyendo tu timing. Para conseguir un comportamiento determinista, necesitas un hardware timer. Usando el módulo machine, configuras un objeto Timer para que se dispare periódicamente y ejecute una función callback específica. Este callback es tu Interrupt Service Routine, o ISR. Los timers disparan soft o hard interrupts. Una soft interrupt es programada por la virtual machine de MicroPython cuando es seguro hacerlo. Escribes una soft ISR igual que el código Python normal. Puede crear objetos, hacer append a listas y manejar números en floating-point. La desventaja es la latencia. Si el garbage collector está ejecutándose activamente cuando el timer se dispara, tu soft interrupt simplemente espera en la cola. Si necesitas una precisión de timing estricta, configuras el timer para que dispare una hard interrupt. Una hard interrupt detiene el procesador inmediatamente. Se salta la virtual machine y ejecuta tu callback al instante. Aquí está la clave. Como una hard interrupt interrumpe el estado actual del sistema, podría interrumpir al propio memory manager. Si tu ISR intenta hacer allocate de memoria en el heap mientras el heap se está modificando, el microcontrolador hará crash. Esta restricción dicta exactamente cómo escribes las hard ISRs. No puedes hacer allocate de nada de memoria. Nada de crear listas. Nada de construir diccionarios. Nada de manipulación de strings. Incluso las matemáticas en floating-point están estrictamente prohibidas, porque en Python, cada float es un nuevo objeto allocated en el heap. Tu código debe ejecutarse rápido, depender de matemáticas con enteros y usar estructuras de memoria preexistentes. Imagina un escenario donde un hardware timer se dispara a 1000 Hercios. Cada milisegundo, la hard ISR lee el valor de un sensor. Como no puedes hacer append de la lectura a una lista, debes hacer pre-allocate de tu almacenamiento antes de iniciar el timer. Creas un bytearray de mil bytes en tu programa principal. También defines una variable de índice global. Cuando el timer se dispara, la ISR lee el sensor. Actualiza el índice global, guarda el entero raw en el bytearray en esa posición y sale. El espacio de memoria se reservó por completo de antemano. La interrupción simplemente lo actualiza in place, garantizando una ejecución sin jitter. Una vez que el buffer está lleno, la ISR necesita pasar los datos al programa principal. No puedes lanzar una función compleja de procesamiento de datos directamente desde la hard ISR. En su lugar, usas micropython dot schedule. Esta función recibe una referencia a un callback y lo pone en cola para ejecutarse tan pronto como el sistema vuelva a un estado de ejecución soft y seguro. Gestionar hardware interrupts te obliga a dejar de pensar en Python como un resource pool infinito y a empezar a controlar exactamente cuándo y dónde se asigna tu memoria. Consulta la documentación oficial de MicroPython para conocer los comportamientos específicos de las interrupciones de tu hardware port, e intenta romper intencionadamente las reglas de memoria en tu propia placa para ver cómo reacciona el sistema. Si quieres sugerir temas para nuestra próxima serie, pásate por devstories dot eu. Me gustaría tomarme un momento para darte las gracias por escucharnos; nos ayuda muchísimo. ¡Que tengas un buen día!