MicroPython en la Raspberry Pi Pico, sin nada que instalar
Principiante
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
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.
# 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.
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.
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.
| Arduino | MicroPython |
|---|---|
| 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 1023 | ADC(26).read_u16(), de 0 a 65535 |
| analogWrite(15, 128), de 0 a 255 | PWM(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=...) |
# 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.
# 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 circuitoPreguntas
¿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.
Sigue así
De dónde vienen los datos de esta página
Á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.