Placas

CircuitPython en la Pico

Ejecuta code.py en una Pico con el firmware oficial de CircuitPython: el panel de Firmware, la unidad CIRCUITPY, las bibliotecas, el REPL y las importaciones de Wokwi.

Qué placas

La Raspberry Pi Pico ejecuta CircuitPython, y también la Arduino Nano RP2040 Connect, con la compilación propia de CircuitPython para ella: el mismo RP2040, con board.LED en D13 (GPIO 6) y board.I2C() en A4 y A5. Consulta la Nano RP2040 Connect. La Raspberry Pi Pico W ejecuta su propia compilación, con su chip de radio CYW43439 modelado, así que board.LED el LED y el WiFi funcionan en la red simulada de Mokxi (mira WiFi en la Pico W). La ESP32-S3-DevKitC-1 también ejecuta CircuitPython, con su propia compilación y su REPL y unidad en el USB nativo del S3; el WiFi no se simula bajo CircuitPython ahí. La Pico también ejecuta MicroPython; mira la Pico.

Lo que se ejecuta es CircuitPython 10.3.1 para la Raspberry Pi Pico, el firmware oficial de Adafruit, byte por byte tal como lo publica circuitpython.org, sobre el RP2040 simulado de Mokxi. Nada en la página interpreta tu Python.

Elegirlo en el panel de Firmware

  1. Coloca una Raspberry Pi Pico, una Pico W, una Arduino Nano RP2040 Connect o una ESP32-S3-DevKitC-1 en el lienzo.
  2. Abre su panel de Firmware y elige CircuitPython (code.py).
  3. Los archivos de la placa pasan a ser un code.py. Si contienen trabajo tuyo, primero se te pregunta. Escribe tu programa ahí y presiona Ejecutar.

Una placa cuyos archivos tienen un code.py y ningún .ino ejecuta CircuitPython. Un sketch de Arduino o un proyecto de MicroPython en la misma placa se ejecuta como antes, y nada de CircuitPython se carga para ese.

La primera Ejecución de un proyecto de CircuitPython descarga el firmware, y el navegador lo conserva para todas las ejecuciones siguientes. Un sketch de Arduino nunca lo descarga.

La unidad CIRCUITPY y code.py

CircuitPython guarda sus archivos en una unidad llamada CIRCUITPY, en la flash de la placa. Al 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 en lib/, y toda pestaña .py, .txt, .json, .csv y .toml excepto code.py.

Luego la computadora al extremo del cable USB simulado del Pico abre el puerto serie de la placa y guarda code.py en la unidad por USB, como lo haría tu propia computadora al guardarlo desde tu editor. CircuitPython detecta el guardado y se recarga, como lo hace en un escritorio, y ejecuta code.py con el monitor serie conectado, así se muestra cada línea que imprime.

code.py imprime unos dos segundos después de Ejecutar. La mayor parte es cosa de CircuitPython: la ventana de un segundo de modo seguro al arrancar, mientras el LED en GP25 parpadea, y la espera tras un guardado antes de recargarse.

microcontroller.reset() y el watchdog conservan la unidad, así que code.py se ejecuta de nuevo; lo que imprime antes de que el puerto serie se abra otra vez se pierde, como en un escritorio. Ejecutar de nuevo parte de una unidad recién escrita.

Bibliotecas

Mokxi lee tus líneas de import y coloca por sí solo en la carpeta lib/ de la unidad las bibliotecas de Adafruit que encuentra, junto con lo que estas importan a su vez, como lo haría circup. Son los archivos .mpy compilados por la propia 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
  • neopixel

Cada una se descarga solo cuando un programa la importa. 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 (board, digitalio, analogio, pwmio, busio, time, displayio, terminalio, i2cdisplaybus y los demás) no necesitan nada.

El monitor serie y el REPL

El monitor serie es el puerto USB serie de la placa, en ambos sentidos: lo que code.py imprime, sus tracebacks, y Code done running. al terminar.

  • Ctrl-C detiene code.py con un KeyboardInterrupt.
  • Cualquier tecla entra entonces al REPL, y >>> responde ahí.
  • Ctrl-D recarga y ejecuta code.py de nuevo.

Cuando un programa se detiene con un error, CircuitPython imprime un traceback. Mokxi lo lee, marca la línea en tu archivo y dice qué suele significar el error en palabras de CircuitPython: un módulo de MicroPython en un programa de CircuitPython, una pull-up faltante, un pin ya en uso, o board.I2C(), que la Pico no tiene (usa busio.I2C(board.GP5, board.GP4)).

Lo que funciona, y lo que no

digitalio, analogio, pwmio, busio.I2C y busio.UART funcionan, así que adafruit_bme280, adafruit_ssd1306 y displayio con adafruit_display_text se comunican con los componentes del lienzo.

El PIO también se ejecuta, así que neopixel_write y la biblioteca neopixel encienden una tira WS2812, y pulseio.PulseIn lee el eco con el que adafruit_hcsr04 mide un HC-SR04.

No simulado: el segundo núcleo; audiobusio, audiopwmio y picodvi; y leer la unidad de la computadora, que solo guarda en ella.

WiFi en la Pico W

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 (que el editor pone en lib/ junto con el adafruit_connection_manager que necesita) llegan a los sitios inventados de .mokxi, como http://weather.mokxi/:

import wifi, socketpool, adafruit_requests

wifi.radio.connect("Mokxi-Lab", "breadboard")
print("Connected, IP address", wifi.radio.ipv4_address)
requests = adafruit_requests.Session(socketpool.SocketPool(wifi.radio))
print(requests.get("http://weather.mokxi/").json())

Cualquier otro nombre no se encuentra, y https:// no lleva a ningún lado. No simulado: Bluetooth, los clientes del modo punto de acceso y el ahorro de energía. wifi.radio.ap_info lanza NotImplementedError, porque el port de CircuitPython para la Pico W no lo implementa.

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 configurada en CircuitPython y se ejecuta. En otra placa su code.py se guarda como texto, y la importación dice por qué. Wokwi pudo haber usado otra versión de CircuitPython; el informe de importación dice cuál corre aquí. Ver Si vienes de Wokwi.

En una placa real

Una placa de CircuitPython no necesita compilación. Pon CircuitPython en la Pico (mantén BOOTSEL presionado 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 ahí las bibliotecas que importe en CIRCUITPY/lib (circup install lo hace por ti).

En una Pico W, arrastra el .uf2 de circuitpython.org/board/raspberry_pi_pico_w y pon el nombre y la contraseña de tu propia red en code.py. En una Nano RP2040 Connect, en su lugar puentea REC con GND mientras la conectas y arrastra el .uf2 de circuitpython.org/board/arduino_nano_rp2040_connect. En la ESP32-S3-DevKitC-1, conecta su puerto USB (el marcado USB, no UART) y usa el instalador de circuitpython.org/board/espressif_esp32s3_devkitc_1_n8.

Proyectos iniciales

Proyectos iniciales en una Pico, cada uno en su propia página: blink, un botón, un arcoíris NeoPixel, un BME280 y texto en una OLED SSD1306. El simulador de CircuitPython los recorre uno por uno.

En otras partes