Aprender

MicroPython en la Raspberry Pi Pico, sin nada que instalar

Principiante

O mira todas las lecciones.

  • 526componentes en el banco de trabajo
  • 46placas funcionando ahora
  • 1.00xtiempo real, en todas las placas
Raspberry Pi Pico: MicroPython regula el brillo de un LED con una perillaen vivo0.000 s 0.00x
Haz clic para abrirlo en el editor
Presiona Ejecutar y luego gira la perilla. MicroPython lee GP26 con el ADC y fija el ciclo útil del PWM en GP15.

Mokxi ejecuta MicroPython en su Raspberry Pi Pico. Pon una Pico en el lienzo, elige MicroPython (main.py) en su panel de Firmware, escribe main.py y presiona Ejecutar. Lo que corre es el firmware oficial de MicroPython v1.29.0 para la Pico, el mismo archivo que arrastrarías a una real, sobre el RP2040 simulado de Mokxi, instrucción por instrucción.

Al presionar Ejecutar la placa arranca ese firmware, y la computadora al extremo de su cable USB simulado copia tus archivos .py al sistema de archivos de la placa como lo hace Thonny, y luego la reinicia en caliente. MicroPython imprime MPY: soft reboot y ejecuta main.py. Todo lo que diga print() aparece en el monitor serie, y cuando main.py termina el REPL responde: escribe 6*7 y dice 42.

El circuito de arriba es un potenciómetro en GP26 y un LED en GP15. Gira la perilla y el LED baja y sube de brillo, y el monitor serie muestra la posición de la perilla en porcentaje.

El programa: entrada por ADC, salida por PWM

ADC(26) es la entrada analógica del RP2040 en GP26, y read_u16() da 0 con 0 V y 65535 con la referencia de 3.3 V. El convertidor tiene 12 bits, así que el valor avanza en pasos de unos 16. PWM(Pin(15)) es la parte de PWM detrás de GP15, y duty_u16() acepta el mismo rango de 0 a 65535, así que la lectura de la perilla puede entrar directamente como ciclo útil.

Con el cursor a 1.1 V, a un tercio del recorrido, read_u16() imprimió aquí 21845 todas las veces: 1365 de 4095 cuentas, que MicroPython estira a 16 bits desplazándolo cuatro bits arriba y repitiendo sus cuatro bits superiores debajo, como en una Pico real. Con un ciclo útil de 32768, el pin del LED estuvo en alto durante el 50.0% de cada período de 1 ms.

main.py: el regulador de brillo con perilla
# MicroPython on a Raspberry Pi Pico: a knob dims an LED.
# The potentiometer's wiper is on GP26 (ADC0), the LED on GP15 is driven by PWM.
from machine import ADC, Pin, PWM
import time

knob = ADC(26)            # read_u16(): 0 at 0 V, 65535 at 3.3 V
led = PWM(Pin(15))
led.freq(1000)            # 1 kHz, far too fast to see it flicker

last = -1
while True:
    value = knob.read_u16()
    led.duty_u16(value)   # the knob's position is the LED's duty cycle
    percent = value * 100 // 65535
    if percent != last:
        print("knob", percent, "%")
        last = percent
    time.sleep_ms(50)

Parpadeo con machine.Pin, y cuánto tarda de verdad un sleep

El LED integrado de una Pico está en GP25. El programa de abajo lo alterna cada 100 ms. Medido en el pin de la placa, aquí cada período fue de 200 ms con menos de un milisegundo de diferencia, porque time.sleep_ms() espera en el propio temporizador de microsegundos del RP2040.

utime.ticks_us() también lee ese temporizador. Cuatro llamadas seguidas a sleep_ms(250) midieron aquí dentro de medio milisegundo de 1000000 microsegundos todas las veces. machine.freq() dice 125000000, los 125 MHz de la Pico.

main.py: parpadear el LED integrado
from machine import Pin
import time

led = Pin(25, Pin.OUT)   # the Pico's green LED

while True:
    led.toggle()
    time.sleep_ms(100)

Un botón con una interrupción

Pin.irq() ejecuta una función cuando un pin cambia, sin que el bucle principal lo vigile. Aquí un botón de GP14 a tierra usa la resistencia pull-up interna del pin, así que el pin lee 1 hasta que se presiona el botón, y IRQ_FALLING ejecuta el controlador una vez por cada presión. Mantén un controlador breve: suma a un contador, activa una bandera, y deja que el bucle principal se encargue de imprimir.

main.py: contar presiones con Pin.irq()
from machine import Pin
import time

presses = 0

def pressed(pin):
    global presses
    presses += 1

button = Pin(14, Pin.IN, Pin.PULL_UP)
button.irq(trigger=Pin.IRQ_FALLING, handler=pressed)

last = 0
while True:
    if presses != last:
        last = presses
        print("presses", presses)
    time.sleep_ms(5)

Portar un sketch de Arduino a MicroPython

Casi todo un sketch de Arduino tiene un equivalente en MicroPython de una sola línea. No hay setup() ni loop(): la parte superior de main.py se ejecuta una vez, y un ciclo while True: al final se ejecuta para siempre. Los pines son objetos creados con el módulo machine, y los tiempos vienen del módulo time.

Dos cosas cambian de tamaño. analogRead() en un Uno da de 0 a 1023, y read_u16() da de 0 a 65535 sin importar la resolución propia del convertidor. Y una diferencia de tiempo se calcula con time.ticks_diff(), que sigue siendo correcta cuando el contador se desborda, en lugar de restar directamente.

Abajo está el ejemplo AnalogReadSerial de Arduino, portado, sobre el circuito del atenuador con perilla. Con la perilla a la mitad imprimió 0 ms 32743 1.65 V, y luego la misma lectura a los 500 ms, 1000 ms y así: 32743 es 2046 de 4095 cuentas, estirado a 16 bits.

Llamadas de Arduino y sus equivalentes en MicroPython en la Pico
ArduinoMicroPython
pinMode(15, OUTPUT); digitalWrite(15, HIGH);led = Pin(15, Pin.OUT); led.value(1)
pinMode(14, INPUT_PULLUP); digitalRead(14)button = Pin(14, Pin.IN, Pin.PULL_UP); button.value()
analogRead(A0), de 0 a 1023ADC(26).read_u16(), de 0 a 65535
analogWrite(15, 128), de 0 a 255PWM(Pin(15)).duty_u16(32768), de 0 a 65535
delay(500)time.sleep_ms(500)
millis()time.ticks_ms()
Serial.println(x)print(x)
attachInterrupt(..., FALLING)Pin.irq(trigger=Pin.IRQ_FALLING, handler=...)
main.py: AnalogReadSerial, portado
# Arduino's AnalogReadSerial, ported to MicroPython
from machine import ADC
import time

pot = ADC(26)                     # analogRead(A0) becomes ADC(26)
start = time.ticks_ms()           # millis() becomes time.ticks_ms()

while True:
    value = pot.read_u16()        # 0 to 65535, not 0 to 1023
    volts = value * 3.3 / 65535
    print(time.ticks_diff(time.ticks_ms(), start), "ms", value, "%.2f V" % volts)
    time.sleep_ms(500)            # delay(500) becomes time.sleep_ms(500)

I2C: una OLED y un BME280 con machine.I2C

machine.I2C(0) y machine.I2C(1) son los dos bloques I2C del RP2040, y los componentes en un bus responden en sus direcciones: aquí la OLED SSD1306 está en I2C0 (GP4 y GP5) y scan() la encuentra en 0x3C (60), y el BME280 está en I2C1 (GP6 y GP7) en 0x76 (118). Ambos también pueden compartir un bus, porque tienen direcciones distintas. Agrega los controladores como pestañas, ssd1306.py de micropython-lib y un controlador de BME280, y se copian a la placa junto con main.py, igual que Thonny los copia.

El bus funciona con el reloj simulado a la velocidad que el bloque realmente genera: 400 kHz pedidos son 376 kHz en el cable, y oled.show(), 1 KB de imagen, tarda 25.4 ms. Pregunta a una dirección donde nadie responde y la llamada lanza OSError: [Errno 5] EIO, como en una Pico real. machine.SPI funciona igual, con DMA y todo, y SoftI2C y SoftSPI funcionan en cualquier pin.

main.py: un BME280 en una SSD1306
# MicroPython on a Raspberry Pi Pico: a BME280 and an SSD1306 OLED on I2C.
# The OLED is on I2C0: SDA on GP4 (pin 6), SCL on GP5 (pin 7).
# The BME280 is on I2C1: SDA on GP6 (pin 9), SCL on GP7 (pin 10).
# Both run from 3V3 (pin 36). ssd1306.py and bme280.py are in their own tabs.
from machine import I2C, Pin
import time
import ssd1306
import bme280

i2c0 = I2C(0, scl=Pin(5), sda=Pin(4), freq=400000)
i2c1 = I2C(1, scl=Pin(7), sda=Pin(6), freq=400000)
print("I2C0:", [hex(a) for a in i2c0.scan()])   # 0x3c, the OLED
print("I2C1:", [hex(a) for a in i2c1.scan()])   # 0x76, the BME280

oled = ssd1306.SSD1306_I2C(128, 64, i2c0)
sensor = bme280.BME280(i2c=i2c1)

while True:
    t, p, h = sensor.read_compensated_data()   # C, Pa, %RH
    oled.fill(0)
    oled.text("Pico weather", 0, 0)
    oled.text("%.1f C" % t, 0, 20)
    oled.text("%.1f hPa" % (p / 100), 0, 34)
    oled.text("%.1f %%RH" % h, 0, 48)
    oled.show()
    print("%.2f C  %.2f hPa  %.2f %%" % (t, p / 100, h))
    time.sleep(2)

Cuando el programa se detiene con un error

MicroPython detiene un programa que falla e imprime un traceback: el archivo, la línea y el error. Mokxi lo lee desde el puerto serie, marca la línea en el editor y dice qué suele significar el error. Un NameError es un nombre usado antes de que se le asigne un valor o se importe (los nombres en Python distinguen mayúsculas de minúsculas); un SyntaxError es una línea que no es Python válido, muchas veces por dos puntos que faltan al final de una línea if, for, while o def; un ImportError de RPi.GPIO o gpiozero significa código escrito para una computadora Raspberry Pi, no para la Pico.

Después del traceback responde el REPL, así que puedes probar la línea a mano antes de cambiar main.py.

Qué se simula y qué no

Simulado: el núcleo Cortex-M0+ del RP2040 y su ROM de arranque, el cargador de arranque de segunda etapa, el chip de flash y el sistema de archivos littlefs que lleva, los relojes, el puerto USB, los pines GPIO con sus pull-ups e interrupciones, el PWM, el ADC con el sensor de temperatura, los bloques I2C y SPI y el DMA, el temporizador, el RTC y el watchdog.

Aún no simulado: el segundo núcleo, así que _thread detiene la placa con un mensaje que lo dice; el bloque I2C como destino (machine.I2CTarget); y el reloj de la CPU, que se queda en 125 MHz sin importar lo que se configure en machine.freq(), aunque el temporizador y todas las mediciones de tiempo siguen siendo correctas. Los bloques PIO sí funcionan, así que rp2.PIO y rp2.StateMachine manejan sus pines. La Pico W ejecuta su propia compilación de MicroPython, con su CYW43439 modelado a partir de sus pines: Pin("LED") enciende el LED de la placa y network.WLAN se conecta a la red simulada de Mokxi.

Abre este circuito en el editor. Raspberry Pi Pico: MicroPython atenúa un LED con una perilla, conectado como se ejecuta arriba en esta página. Cambia un componente o un valor y ejecútalo de nuevo.

Abrir el circuito

Preguntas

¿Es MicroPython real o una imitación?

Real. La placa ejecuta el firmware oficial de MicroPython v1.29.0 para la Raspberry Pi Pico, el mismo archivo .uf2 que publica micropython.org, sobre un RP2040 simulado. Nada en la página web interpreta tu Python: el firmware lo compila y lo ejecuta en el chip simulado.

¿Cómo llega main.py a la placa?

Como lo hacen Thonny y mpremote. Al Ejecutar, la computadora simulada en el puerto USB de la Pico abre su puerto serie, entra al REPL en modo raw, escribe cada pestaña .py en el sistema de archivos littlefs de la placa con un pequeño script y reinicia suavemente la placa, que entonces ejecuta main.py.

¿Puedo agregar mis propios módulos o una biblioteca?

Sí. Agrega una pestaña con el archivo .py del módulo, como ssd1306.py, e impórtalo desde main.py. Cada pestaña .py se copia a la placa junto con main.py.

¿Descarga algo?

La primera ejecución de un proyecto de MicroPython descarga el firmware, 229 KB, y el navegador lo conserva para cada ejecución siguiente. Un proyecto de Arduino nunca lo descarga.

Ármalo en la vida real

Abre el editor, cambia un valor y mira cómo cambia el número con él. Nada que instalar y sin necesidad de cuenta.