Simulador de CircuitPython: el firmware oficial en una Pico, en línea
Principiante
- 526componentes en el banco de trabajo
- 46placas funcionando ahora
- 1.00xtiempo real, en todas las placas
Mokxi corre CircuitPython en la Raspberry Pi Pico, la Pico W, la Arduino Nano RP2040 Connect y la ESP32-S3-DevKitC-1. Pon una Pico en el lienzo, elige CircuitPython (code.py) en su panel de Firmware, escribe code.py y presiona Ejecutar. Lo que corre es el firmware oficial de Adafruit, CircuitPython 10.3.1 para la Raspberry Pi Pico, byte por byte tal como lo publica circuitpython.org, sobre el RP2040 a nivel de instrucciones de Mokxi. Nada en la página interpreta tu Python.
La placa arranca como lo haría una real: CircuitPython monta su unidad CIRCUITPY, espera su ventana de un segundo de modo seguro mientras el LED de GP25 parpadea, e inicia el USB. La computadora al final del cable USB simulado de la placa entonces abre su puerto serie y guarda code.py en la unidad, como lo hace tu propia computadora cuando guardas desde tu editor, y la recarga automática de CircuitPython lo ejecuta.
El circuito de arriba es el primero de los ejemplos iniciales de abajo: board.LED hace parpadear el LED propio de la Pico y un LED rojo en GP15, y el monitor serie dice on y off.
Cómo llega code.py a la placa
CircuitPython guarda sus archivos en una unidad llamada CIRCUITPY, en la flash de la Pico. Al presionar Ejecutar, Mokxi escribe esa unidad antes de que la placa se encienda: el boot_out.txt del propio firmware, las bibliotecas de Adafruit que tu programa importa bajo lib/, y todas las pestañas .py, .txt, .json, .csv y .toml excepto code.py.
code.py en sí se guarda por USB, bloque por bloque, como un sistema operativo escribe un archivo en una unidad USB. CircuitPython toma el guardado en su flash y se recarga, y code.py corre con el monitor serie conectado, así que se muestra cada línea que imprime. Imprime unos dos segundos después de Ejecutar; la mayor parte de ese tiempo es la ventana de modo seguro del propio CircuitPython y la espera tras un guardado antes de recargarse.
Parpadeo con digitalio
digitalio.DigitalInOut(board.LED) es el LED propio de la Pico en GP25, y board.GP15 maneja un LED rojo a través de 220 ohmios a tierra. Los dos se encienden juntos, y el monitor serie imprime on y off después de la línea code.py output: de CircuitPython.
# CircuitPython on a Raspberry Pi Pico: blink an LED.
# board.LED is the Pico's own LED (GP25); the red LED on GP15 through
# 220 ohms blinks with it.
import board
import digitalio
import time
onboard = digitalio.DigitalInOut(board.LED)
onboard.direction = digitalio.Direction.OUTPUT
led = digitalio.DigitalInOut(board.GP15)
led.direction = digitalio.Direction.OUTPUT
while True:
onboard.value = led.value = True
print("on")
time.sleep(0.5)
onboard.value = led.value = False
print("off")
time.sleep(0.5)
Un botón con la resistencia pull-up del pin
Un botón de GP14 a tierra, con switch_to_input(pull=digitalio.Pull.UP): el pin lee True hasta que se presiona el botón, y False mientras se mantiene presionado. El programa imprime Press the button, enciende el LED de la placa mientras lo mantienes presionado, y cuenta cada presión una sola vez.
# CircuitPython on a Raspberry Pi Pico: a button lights the LED.
# The button joins GP14 to ground. The pin's own pull-up holds it True, so
# a press reads False.
import board
import digitalio
import time
led = digitalio.DigitalInOut(board.LED)
led.direction = digitalio.Direction.OUTPUT
button = digitalio.DigitalInOut(board.GP14)
button.switch_to_input(pull=digitalio.Pull.UP)
print("Press the button")
presses = 0
was_pressed = False
while True:
pressed = not button.value
led.value = pressed
if pressed and not was_pressed:
presses += 1
print("pressed", presses)
was_pressed = pressed
time.sleep(0.01)
Un arcoíris de NeoPixel con la biblioteca neopixel
Ocho LED WS2812 en GP16. La biblioteca neopixel de Adafruit va sola en lib/, y envía los bits de la tira desde una de las máquinas de estado PIO de la Pico, como en una Pico real. Los colores giran alrededor de la tira, y cada 64 pasos el programa imprime el paso y el color del primer pixel, empezando con step 64 first pixel.
# CircuitPython on a Raspberry Pi Pico: a NeoPixel rainbow.
# Eight WS2812 LEDs on GP16, driven by Adafruit's neopixel library (which
# the editor puts in lib/ for you) through the Pico's PIO.
import board
import neopixel
import time
pixels = neopixel.NeoPixel(board.GP16, 8, brightness=0.3, auto_write=False)
def wheel(pos):
# 0 to 255 around the color wheel: red, green, blue and back to red.
if pos < 85:
return (255 - pos * 3, pos * 3, 0)
if pos < 170:
pos -= 85
return (0, 255 - pos * 3, pos * 3)
pos -= 170
return (pos * 3, 0, 255 - pos * 3)
print("Rainbow on 8 NeoPixels")
step = 0
while True:
for i in range(8):
pixels[i] = wheel((i * 32 + step) % 256)
pixels.show()
if step % 64 == 0:
print("step", step, "first pixel", pixels[0])
step = (step + 4) % 256
time.sleep(0.02)
Un BME280 con adafruit_bme280
busio.I2C(board.GP5, board.GP4) es el I2C0 de la Pico, primero SCL y luego SDA. La biblioteca adafruit_bme280 de Adafruit lee el sensor; no la agregas en ninguna parte, porque el editor la pone en la carpeta lib/ de la unidad cuando code.py la importa. Con el componente configurado en 22.5 C y 45% imprime 22.5 C 45.0 % humidity y la presión cada dos segundos, y cuando cambias la temperatura en el componente, la siguiente lectura la sigue.
# CircuitPython on a Raspberry Pi Pico: a BME280 to the Serial Monitor.
# I2C0 on GP5 (SCL) and GP4 (SDA); Adafruit's adafruit_bme280 library goes
# into lib/ for you.
import board
import busio
import time
from adafruit_bme280 import basic as adafruit_bme280
i2c = busio.I2C(board.GP5, board.GP4)
bme = adafruit_bme280.Adafruit_BME280_I2C(i2c, address=0x76)
while True:
print("%.1f C %.1f %% humidity %.1f hPa" % (bme.temperature, bme.relative_humidity, bme.pressure))
time.sleep(2)
Texto en una OLED SSD1306 con displayio
displayio dibuja en la pantalla OLED a través de adafruit_displayio_ssd1306, y adafruit_display_text crea las etiquetas, con la fuente terminalio incluida en el firmware. Ambas bibliotecas, y la adafruit_ticks que necesita adafruit_display_text, van solas a lib/. El programa escribe un título y un contador que sube una vez por segundo, e imprime count 0, count 1 y así sucesivamente.
# CircuitPython on a Raspberry Pi Pico: text on an SSD1306 OLED.
# I2C0 on GP5 (SCL) and GP4 (SDA). displayio draws a label with the built-in
# terminalio font; adafruit_displayio_ssd1306 and adafruit_display_text go
# into lib/ for you.
import board
import busio
import displayio
import i2cdisplaybus
import terminalio
import time
import adafruit_displayio_ssd1306
from adafruit_display_text import label
displayio.release_displays()
i2c = busio.I2C(board.GP5, board.GP4)
bus = i2cdisplaybus.I2CDisplayBus(i2c, device_address=0x3C)
display = adafruit_displayio_ssd1306.SSD1306(bus, width=128, height=64)
group = displayio.Group()
title = label.Label(terminalio.FONT, text="Hello, Pico!", x=4, y=8)
counter = label.Label(terminalio.FONT, text="", x=4, y=32, scale=2)
group.append(title)
group.append(counter)
display.root_group = group
n = 0
while True:
counter.text = str(n)
print("count", n)
n += 1
time.sleep(1)
WiFi en la Pico W
La Pico W ejecuta la compilación propia de CircuitPython para ella, con su chip de radio CYW43439 modelado a partir de sus pines: board.LED es el LED del chip de radio, y wifi.radio.connect() se conecta al punto de acceso simulado de Mokxi. Su nombre y contraseña son las propiedades WiFi de la placa, que empiezan como Mokxi-Lab y breadboard. socketpool y adafruit_requests de Adafruit, con el adafruit_connection_manager que necesita, ya puestos en lib/ por ti, permiten consultar los sitios .mokxi inventados de la red simulada, como http://weather.mokxi/.
La red es simulada: los nombres fuera de .mokxi no se encuentran, y https:// no lleva a ningún lado. El Bluetooth, los clientes del modo punto de acceso y el ahorro de energía no están simulados, y wifi.radio.ap_info lanza NotImplementedError, igual que en el port de CircuitPython para la Pico W, que no lo implementa.
Las bibliotecas que van solas a lib/
Mokxi lee cada línea de import y pone las bibliotecas de Adafruit que encuentra en la carpeta lib/ de la unidad, junto con lo que estas importan a su vez, como lo haría circup. Son los archivos .mpy compilados por el propio Adafruit, de su paquete de CircuitPython 10.x, sin cambios: adafruit_bme280, adafruit_display_text (con adafruit_ticks), adafruit_displayio_ssd1306, adafruit_framebuf (con su font5x8.bin en la raíz de la unidad), adafruit_hcsr04, adafruit_requests (con adafruit_connection_manager), adafruit_ssd1306 y neopixel. Una pestaña con el nombre de una biblioteca, como neopixel.py, es tuya y se usa en su lugar.
Los módulos integrados en el firmware no necesitan nada: board, digitalio, analogio, pwmio, busio, time, displayio, terminalio, i2cdisplaybus y los demás.
El REPL
El monitor serie es el puerto serie USB de la Pico, en ambos sentidos: lo que imprime code.py, sus tracebacks, y Code done running. al terminar. Ctrl-C detiene code.py con un KeyboardInterrupt, cualquier tecla entra luego al REPL, donde >> responde, y Ctrl-D recarga y ejecuta code.py de nuevo.
Cuando un programa se detiene con un error, Mokxi marca la línea en tu archivo y dice lo que suele significar el error, con las palabras de CircuitPython: un módulo de MicroPython como machine en un programa de CircuitPython, una pull-up faltante, un pin en uso, o board.I2C(), que la Pico no tiene.
Lo que funciona, y lo que no
Funcionan: digitalio, analogio, pwmio, busio.I2C y busio.UART, con los componentes en el lienzo; adafruit_bme280, adafruit_ssd1306 con adafruit_framebuf, y displayio con adafruit_display_text. El PIO también se ejecuta, así que neopixel_write y la biblioteca neopixel encienden una tira WS2812, y pulseio.PulseIn lee el eco que adafruit_hcsr04 usa para medir un HC-SR04. Un reinicio desde adentro, con microcontroller.reset() o el watchdog, conserva la unidad, así que code.py se ejecuta de nuevo.
Todavía no simulado: el segundo núcleo; audiobusio, audiopwmio y picodvi; y leer la unidad desde la computadora, que solo guarda en ella. La ESP32-S3-DevKitC-1 también ejecuta CircuitPython, con su propia compilación y su REPL y su unidad en el USB nativo de la S3, pero ahí el WiFi no está simulado bajo CircuitPython.
Importar desde Wokwi
Un proyecto de Wokwi para la Pico, la Pico W, la Nano RP2040 Connect o la ESP32-S3-DevKitC-1 con un code.py se importa con su placa en modo CircuitPython y se ejecuta. En otra placa su code.py se guarda como texto, y la importación dice por qué. Es posible que Wokwi haya usado otra versión de CircuitPython; el reporte de importación dice cuál corre aquí.
El mismo código en una Pico real
Una placa de CircuitPython no necesita compilación. Pon CircuitPython en la Pico (mantén BOOTSEL mientras la conectas, luego arrastra el .uf2 de circuitpython.org/board/raspberry_pi_pico a la unidad RPI-RP2), después guarda code.py en la unidad CIRCUITPY que aparece, y copia cualquier biblioteca que importe a CIRCUITPY/lib (circup install lo hace por ti).
Abre este circuito en el editor. Raspberry Pi Pico: CircuitPython enciende un LED, cableado como se ejecuta arriba en esta página. Cambia un componente o un valor y ejecútalo de nuevo.
Abrir el circuitoPreguntas
¿Es CircuitPython de verdad?
Sí. La placa ejecuta el firmware oficial de CircuitPython 10.3.1 para la Raspberry Pi Pico, el mismo .uf2 que publica circuitpython.org, byte por byte, sobre un RP2040 simulado. Nada en la página web interpreta tu Python.
¿Qué placas ejecutan CircuitPython?
La Raspberry Pi Pico; la Pico W, con WiFi en la red simulada; la Arduino Nano RP2040 Connect con la compilación propia de CircuitPython para ella, donde `board.LED` es el LED del D13 y `board.I2C()` está en A4 y A5; y la ESP32-S3-DevKitC-1. Elige CircuitPython (code.py) en el panel de Firmware de la placa. La misma Pico puede ejecutar en su lugar MicroPython (main.py) o un sketch de Arduino.
¿Necesito instalar bibliotecas?
No. Las bibliotecas de Adafruit que importa un programa, de las que Mokxi tiene, van solas a la carpeta lib/ de la unidad al Ejecutar, con lo que necesitan a su vez, como las pondría circup.
¿Descarga algo?
La primera vez que Ejecutas un proyecto de CircuitPython se descarga el firmware, y el navegador lo conserva para cada Ejecución posterior. Cada biblioteca se descarga solo cuando un programa la importa. Un sketch de Arduino no descarga nada de esto.
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.