¿Qué es MicroPython? Comandos básicos, REPL y primeros programas

MicroPython es una reimplementación pequeña y rápida del lenguaje Python 3 para microcontroladores. Cuando instalas MicroPython en una placa como la Raspberry Pi Pico o el ESP32, la placa ejecuta el código Python por sí misma: escribes un comando sin compilar nada y ves cómo el LED se enciende al instante. Si aprendiste Python en clase o en tu ordenador, con la misma sintaxis puedes leer pines, mover motores, tomar datos de sensores y conectarte al Wi-Fi.

En esta guía aprenderás en qué se diferencia MicroPython del Python normal, el REPL que te permite hablar con la placa al momento y los módulos que más usarás, es decir machine.Pin, PWM, ADC e I2C, con código de ejemplo. Después verás la diferencia entre time.sleep y ticks_ms, los archivos main.py y boot.py que se ejecutan al arrancar, cómo subir archivos con Thonny y mpremote, cómo añadir bibliotecas con mip y cómo grabar el firmware en la Pico y el ESP32. En la última sección comparamos MicroPython y Arduino C++ cara a cara.

¿Qué es MicroPython y en qué se diferencia de Python?

MicroPython es un proyecto de código abierto que Damien George inició en 2013 para una placa pequeña y que hoy es compatible con decenas de microcontroladores. El firmware que grabas en la placa contiene el intérprete de Python, los módulos básicos y un pequeño sistema de archivos. Tu código se convierte primero en bytecode dentro de la placa y luego el intérprete ejecuta ese bytecode paso a paso. Como es imposible meter todo el Python de tu ordenador en unos cientos de KB de RAM, el lenguaje es el mismo, pero la mayoría de las bibliotecas están recortadas o directamente no existen. A cambio se ha añadido algo que el Python de escritorio no tiene: el módulo machine, que da acceso directo al hardware.

Placas que ejecutan MicroPython

Grabar el firmware de MicroPython en la Pico y el ESP32

1. Pico: Mantén pulsado el botón BOOTSEL de la placa mientras conectas el cable USB y luego suéltalo. En el ordenador aparece una unidad llamada RPI-RP2 (RP2350 en la Pico 2).
2. Descarga de la página oficial de MicroPython el archivo .uf2 adecuado para tu placa (RPI_PICO para la Pico, RPI_PICO_W para la Pico W) y arrástralo a esa unidad.
3. Al terminar la copia, la placa se reinicia sola y la unidad desaparece; MicroPython ya está instalado. En Thonny, elige MicroPython (Raspberry Pi Pico) en Herramientas > Opciones > Intérprete.
4. ESP32: Si tienes Python instalado en el ordenador, escribe pip install esptool en la línea de comandos. Conecta la placa y averigua su puerto (por ejemplo COM3 en Windows, /dev/ttyUSB0 en Linux).
5. Borra primero la flash: esptool.py --chip esp32 --port COM3 erase_flash. Si la placa no conecta, mantén pulsado el botón BOOT mientras se ejecuta el comando.
6. Graba el firmware: esptool.py --chip esp32 --port COM3 --baud 460800 write_flash -z 0x1000 ESP32_GENERIC-....bin. En el ESP32-S3 y el ESP32-C3 la dirección es 0x0. La opción Install or update MicroPython (esptool) de Thonny hace lo mismo desde una ventana.

El REPL: hablar con la placa al instante

El REPL (Read-Eval-Print Loop) es la línea de comandos que la placa te abre por el puerto serie. El símbolo >>> que ves en la ventana Shell de la parte inferior de Thonny indica que el REPL te está esperando. Si escribes 1 + 1, la placa lo calcula y devuelve 2; si escribes from machine import Pin y después Pin("LED", Pin.OUT).value(1), el LED de la Pico se enciende en ese mismo instante. No hay forma más rápida que el REPL para leer el valor de un sensor, comprobar si un pin está bien conectado o descubrir cómo funciona una biblioteca, sin esperar a compilar y cargar.

Primer programa y su equivalente en Arduino C++

1# İlk program: dahili LED'i yakıp söndür / First program: blink the onboard LED
2from machine import Pin
3import time
4
5led = Pin("LED", Pin.OUT)        # Pico ve Pico W; ESP32'de Pin(2, Pin.OUT) / Pico and Pico W; Pin(2, Pin.OUT) on ESP32
6
7while True:
8    led.value(1)                 # yak / on
9    time.sleep(0.5)              # saniye cinsinden / in seconds
10    led.value(0)                 # söndür / off
11    time.sleep(0.5)

1// Aynı program Arduino C++ ile / The same program in Arduino C++
2void setup() {
3  pinMode(LED_BUILTIN, OUTPUT);
4}
5
6void loop() {
7  digitalWrite(LED_BUILTIN, HIGH);
8  delay(500);                    // milisaniye cinsinden / in milliseconds
9  digitalWrite(LED_BUILTIN, LOW);
10  delay(500);
11}

Los dos programas hacen lo mismo, pero su estructura es distinta. En MicroPython no hay setup() ni loop(): el archivo se ejecuta una vez de arriba abajo y el bucle infinito lo montas tú con while True:. En lugar de llaves y punto y coma se usa la sangría; todas las líneas dentro del bucle deben tener la misma sangría (normalmente 4 espacios). La espera también usa otra unidad: time.sleep(0.5) recibe segundos y el delay(500) de Arduino, milisegundos. En MicroPython usas time.sleep_ms() para milisegundos y time.sleep_us() para microsegundos. Las bases del lado de Arduino están en Fundamentos de programación con Arduino.

machine.Pin: entradas y salidas digitales

time.sleep y ticks_ms: medir el tiempo sin bloquear

time.sleep() deja la placa totalmente en espera; mientras tanto no se lee ningún botón ni se consulta ningún sensor. Para llevar varias tareas a la vez usas el equivalente en MicroPython de la técnica millis() de Arduino: time.ticks_ms() da los milisegundos desde el arranque y time.ticks_diff(nuevo, viejo) calcula la diferencia entre dos instantes. Es importante obtener la diferencia con ticks_diff y no con una resta normal; el contador vuelve a empezar al llegar a cierto valor y en ese momento la resta da un resultado erróneo. El código siguiente hace parpadear el LED sin bloquear mientras atiende un botón mediante una interrupción (IRQ); cada pulsación cambia la velocidad del parpadeo.

1# delay kullanmadan iki iş: LED yanıp söner, buton kesmeyle modu değiştirir
2# Two jobs without blocking: the LED blinks, a button interrupt switches the mode
3from machine import Pin
4import time
5
6led = Pin(15, Pin.OUT)                       # LED + 220 Ω, GP15
7buton = Pin(14, Pin.IN, Pin.PULL_UP)         # buton GP14 ile GND arasında / button between GP14 and GND
8
9hizli = False
10son_basma = 0
11son_degisim = time.ticks_ms()
12
13def buton_kesme(pin):                        # kesme fonksiyonu kısa olmalı / keep the handler short
14    global hizli, son_basma
15    simdi = time.ticks_ms()
16    if time.ticks_diff(simdi, son_basma) > 200:   # 200 ms debounce / 200 ms debounce
17        son_basma = simdi
18        hizli = not hizli
19
20buton.irq(trigger=Pin.IRQ_FALLING, handler=buton_kesme)   # basınca HIGH'dan LOW'a iner / goes HIGH to LOW when pressed
21
22while True:
23    aralik = 100 if hizli else 500
24    if time.ticks_diff(time.ticks_ms(), son_degisim) >= aralik:   # taşmaya karşı güvenli / safe against wrap-around
25        son_degisim = time.ticks_ms()
26        led.value(not led.value())
27    # burada başka işler yapılabilir / other work can run here

PWM: brillo, servos y sonido

1# PWM: LED parlaklığı ve servo açısı / PWM: LED brightness and servo angle
2from machine import Pin, PWM
3import time
4
5led = PWM(Pin(15))
6led.freq(1000)                               # 1 kHz: titreme görünmez / no visible flicker
7
8for d in range(0, 65536, 2048):              # duty_u16: 0 (kapalı) ... 65535 (tam) / 0 (off) ... 65535 (full)
9    led.duty_u16(d)
10    time.sleep_ms(20)
11led.duty_u16(0)
12
13servo = PWM(Pin(16))
14servo.freq(50)                               # servolar 50 Hz (20 ms) ister / servos expect 50 Hz (20 ms)
15
16def servo_aci(derece):
17    us = 500 + derece * 2000 // 180          # 0° = 0,5 ms, 180° = 2,5 ms; servona göre ayarla / tune for your servo
18    servo.duty_ns(us * 1000)
19
20for a in (0, 90, 180, 90):
21    servo_aci(a)
22    time.sleep(1)

El objeto PWM enciende y apaga un pin muy rápido para ajustar una potencia media. freq() fija cuántas veces por segundo se repite y duty_u16() cuánto tiempo permanece encendido el pin, con un número entre 0 y 65535; 32768 equivale a un 50 % aproximadamente. Esta escala da pasos mucho más finos que el rango 0–255 de analogWrite en Arduino. Los servos esperan una señal de 50 Hz y un ancho de pulso de entre 0,5 y 2,5 ms; duty_ns() indica la duración del pulso directamente en nanosegundos y simplifica mucho el código del servo. También puedes tocar notas dando distintos valores de freq() a un zumbador pasivo. El ciclo de trabajo y la frecuencia se explican a fondo en Qué es PWM.

ADC: lectura analógica

1# ADC: potansiyometre ve Pico'nun dahili sıcaklık sensörü
2# ADC: a potentiometer and the Pico's internal temperature sensor
3from machine import ADC, Pin
4import time
5
6pot = ADC(Pin(26))                           # GP26 = ADC0; ESP32'de ADC(Pin(34)) / ADC(Pin(34)) on ESP32
7yonga = ADC(4)                               # 4. kanal: dahili sıcaklık / channel 4: internal temperature
8
9def ortalama(adc, n=16):                     # gürültüyü azalt / reduce noise
10    toplam = 0
11    for _ in range(n):
12        toplam += adc.read_u16()
13    return toplam // n
14
15while True:
16    ham = ortalama(pot)                      # 0-65535 (12 bit ölçüm 16 bite ölçeklenir) / 12-bit reading scaled to 16 bits
17    volt = ham * 3.3 / 65535
18    v_t = ortalama(yonga) * 3.3 / 65535
19    derece = 27 - (v_t - 0.706) / 0.001721   # RP2040 veri sayfasındaki formül / formula from the RP2040 datasheet
20    print("Pot: {} ({:.2f} V)  Yonga / chip: {:.1f} C".format(ham, volt, derece))
21    time.sleep(1)

read_u16() devuelve un valor entre 0 y 65535 en todas las placas, así que el mismo código funciona en la Pico y en el ESP32. El ADC de la Pico es en realidad de 12 bits y la lectura se escala a 16 bits. La Pico tiene tres pines analógicos accesibles: GP26 (ADC0), GP27 (ADC1) y GP28 (ADC2); el cuarto canal es el sensor de temperatura interno del chip y mide la temperatura del chip, no la de la habitación. En el ESP32 necesitas adc.atten(ADC.ATTN_11DB) para leer todo el rango de 0–3,3 V, y los pines ADC2 no se pueden usar con el Wi-Fi activo, así que elige los pines ADC1 entre GPIO 32 y 39. La media de 16 lecturas del código reduce bastante el ruido del ADC. Conceptos como resolución y tensión de referencia están en Qué es un ADC.

I2C: conectar sensores y pantallas

1# I2C: hattı tara ve SSD1306 OLED'e yaz / I2C: scan the bus and write to an SSD1306 OLED
2from machine import Pin, I2C
3import ssd1306                               # önce: mpremote mip install ssd1306 / first: mpremote mip install ssd1306
4
5i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)   # Pico; ESP32'de I2C(0, sda=Pin(21), scl=Pin(22))
6adresler = i2c.scan()
7print("Bulunan / found:", [hex(a) for a in adresler])   # OLED genelde 0x3c / OLED is usually 0x3c
8
9if 0x3C in adresler:
10    oled = ssd1306.SSD1306_I2C(128, 64, i2c)
11    oled.fill(0)
12    oled.text("MicroPython", 0, 0)
13    oled.text("I2C: " + hex(adresler[0]), 0, 16)
14    oled.show()

I2C(0, sda=..., scl=...) inicia la unidad I2C por hardware en los pines que elijas y scan() devuelve una lista con las direcciones de todos los dispositivos que responden en el bus. Si un sensor no funciona, este escaneo es lo primero que debes hacer: una lista vacía indica un problema de cableado, y una dirección distinta de la esperada se corrige en el código. En la Pico los pines que puede usar cada unidad I2C son fijos; por ejemplo, para I2C0 funcionan los pares GP0-GP1, GP4-GP5 o GP8-GP9, y si eliges un par incorrecto recibes un ValueError. En el ESP32 el I2C se puede asignar a casi cualquier pin. Los detalles de la pantalla están en Pantalla OLED y el protocolo en Qué es I2C.

main.py y boot.py: el código que se ejecuta al arrancar

Cuando pulsas Ejecutar en Thonny, el código solo corre en ese momento sin guardarse en la placa; al desconectar el USB desaparece. Para que tu código se ejecute solo cada vez que arranque la placa, debes guardar el archivo en la placa con el nombre main.py. Al arrancar se ejecuta primero boot.py y después main.py. boot.py sirve para preparativos que se hacen una vez, como conectar al Wi-Fi o ajustar el reloj; el firmware del ESP32 crea este archivo por sí mismo, mientras que en la Pico normalmente no existe. Tu programa principal siempre va en main.py. Puedes traer a main.py funciones de otros archivos con import y guardar mediciones en el sistema de archivos de la placa con open().

1# main.py: kart her açıldığında otomatik çalışır / runs automatically every time the board starts
2import time
3from machine import Pin
4
5time.sleep(3)                                # Ctrl+C ile durdurmak için güvenlik payı / a safety window for Ctrl+C
6led = Pin("LED", Pin.OUT)
7sayac = 0
8
9try:
10    while True:
11        sayac += 1
12        led.value(sayac % 2)
13        print("Calisiyor / running", sayac)
14        time.sleep(1)
15except KeyboardInterrupt:                    # Thonny'de Stop ya da Ctrl+C / Stop in Thonny or Ctrl+C
16    led.value(0)
17    print("Durduruldu / stopped")

Subir archivos: Thonny y mpremote

Si estás empezando, Thonny es el camino más fácil: escribe tu código, elige Archivo > Guardar como, selecciona Raspberry Pi Pico o MicroPython device en la ventana que se abre y llama al archivo main.py. Si abres Ver > Archivos verás lado a lado los archivos del ordenador y de la placa, y podrás copiarlos de uno a otro con el botón derecho. Para quienes prefieren la línea de comandos y usan un editor como VS Code, la herramienta oficial es mpremote; se instala con pip install mpremote y se conecta sola a la primera placa con MicroPython que encuentra.

Añadir bibliotecas: mip

En MicroPython no hay pip; en su lugar se usa el pequeño gestor de paquetes mip. En una placa que puede conectarse a internet, como la Pico W o el ESP32, primero te conectas al Wi-Fi y luego escribes import mip y mip.install("ssd1306") en el REPL; el paquete se descarga del repositorio oficial micropython-lib y se coloca en la carpeta /lib de la placa. También puedes instalar un driver de GitHub con mip.install("github:usuario/repositorio"). Para una Pico sin Wi-Fi, haz lo mismo desde el ordenador con el comando mpremote mip install o con el menú Herramientas > Gestionar paquetes de Thonny. Copiar a la placa un driver de un solo archivo (por ejemplo un .py escrito para un sensor) también sirve; mientras el archivo esté en la raíz o en /lib, lo cargas con import. Los pasos para conectar al Wi-Fi están en Wi-Fi con la Pico W.

¿MicroPython o Arduino C++?

En la práctica decide tu proyecto. Leer un sensor y enviarlo por Wi-Fi, servir una página web o manejar una pantalla se resuelve en MicroPython con menos líneas y más rápido. Generar señales con precisión de microsegundos, actualizar cientos de LED a gran velocidad o tener solo una placa pequeña como el Uno inclina la balanza hacia C++. Puedes acelerar una función lenta con el decorador @micropython.native y reducir las pausas del recolector de basura evitando crear listas y cadenas nuevas dentro de los bucles. Para elegir placa, consulta también ¿Arduino o ESP32?.

Errores frecuentes y soluciones

MicroPython es el camino más corto al mundo de los microcontroladores si ya sabes Python: ves el resultado en cuanto pruebas un pin en el REPL y con unas pocas líneas lees un sensor y te conectas al Wi-Fi. Cuando domines los módulos básicos, la idea de main.py y la temporización sin bloqueo con ticks_ms, tus proyectos crecerán deprisa. En la app BlueGrays encontrarás proyectos con la Raspberry Pi Pico de LED, semáforo, botones y PWM, con esquemas de conexión y código MicroPython paso a paso.