Placas

CircuitPython no Pico

Rode o code.py em uma Pico com o firmware oficial do CircuitPython: o painel de Firmware, a unidade CIRCUITPY, bibliotecas, o REPL e importações do Wokwi.

Quais placas

O Raspberry Pi Pico roda CircuitPython, e o Arduino Nano RP2040 Connecttambém, com a própria compilação do CircuitPython para ele: o mesmo RP2040, com board.LED no D13 (GPIO 6) e board.I2C() no A4 e A5. Veja o Nano RP2040 Connect. O Raspberry Pi Pico W roda sua própria compilação, com o chip de rádio CYW43439 modelado, então board.LED o LED e o WiFi funcionam na rede simulada do Mokxi (veja WiFi no Pico W). O ESP32-S3-DevKitC-1 também roda CircuitPython, com sua própria compilação e o REPL e a unidade no USB nativo do S3; o WiFi não é simulado sob CircuitPython lá. O Pico também roda MicroPython; veja a Pico.

O que roda é CircuitPython 10.3.1 para o Raspberry Pi Pico, o firmware oficial da Adafruit, byte por byte como a circuitpython.org o publica, no RP2040 simulado do Mokxi. Nada na página interpreta o seu Python.

Escolhendo-o no painel Firmware

  1. Coloque um Raspberry Pi Pico, um Pico W, um Arduino Nano RP2040 Connect ou um ESP32-S3-DevKitC-1 no canvas.
  2. Abra o painel Firmware dele e escolha CircuitPython (code.py).
  3. Os arquivos da placa viram um code.py. Se eles tiverem algo seu, você é avisado antes. Escreva seu programa ali e aperte Rodar.

Uma placa cujos arquivos têm um code.py e nenhum .ino roda CircuitPython. Um sketch do Arduino ou um projeto MicroPython na mesma placa roda como antes, e nada do CircuitPython é carregado para ele.

A primeira execução de um projeto CircuitPython baixa o firmware, e o navegador o guarda para todas as execuções seguintes. Um sketch do Arduino nunca o baixa.

A unidade CIRCUITPY e o code.py

O CircuitPython guarda seus arquivos numa unidade chamada CIRCUITPY, na flash da placa. Ao Rodar, o Mokxi grava essa unidade antes de a placa ligar: o boot_out.txt do próprio firmware, as bibliotecas da Adafruit que seu programa importa em lib/, e toda aba .py, .txt, .json, .csv e .toml, exceto a code.py.

Depois o computador na ponta do cabo USB simulado do Pico abre a porta serial da placa e salva o code.py na unidade por USB, como o seu próprio computador faz quando você o salva do seu editor. O CircuitPython vê a gravação e recarrega, como faz numa bancada, e roda o code.py com o monitor serial conectado, então cada linha que ele imprime aparece.

O code.py imprime cerca de dois segundos depois de Rodar. A maior parte disso é do próprio CircuitPython: a janela de um segundo de modo seguro na inicialização, enquanto o LED no GP25 pisca, e a espera depois de uma gravação antes de recarregar.

O microcontroller.reset() e o watchdog mantêm a unidade, então o code.py roda de novo; o que ele imprime antes de a porta serial abrir de novo se perde, como numa bancada. Rodar de novo começa com uma unidade recém-gravada.

Bibliotecas

O Mokxi lê suas linhas de import e coloca sozinho as bibliotecas da Adafruit que encontra na pasta lib/ da unidade, junto com o que elas importam por sua vez, como o circup faria. São os arquivos .mpy compilados pela própria Adafruit no pacote deles de CircuitPython 10.x, sem alteração:

  • adafruit_bme280
  • adafruit_display_text (com adafruit_ticks)
  • adafruit_displayio_ssd1306
  • adafruit_framebuf (com o font5x8.bin dele na raiz da unidade)
  • adafruit_hcsr04
  • adafruit_requests (com adafruit_connection_manager)
  • adafruit_ssd1306
  • neopixel

Cada uma só é baixada quando um programa a importa. Uma aba com o nome de uma biblioteca, como neopixel.py, é sua e é usada no lugar dela. Os módulos incluídos no firmware (board, digitalio, analogio, pwmio, busio, time, displayio, terminalio, i2cdisplaybus e o resto) não precisam de nada.

O monitor serial e o REPL

O monitor serial é a porta serial USB da placa, nos dois sentidos: o que o code.py imprime, seus tracebacks e o Code done running. quando ele termina.

  • Ctrl-C interrompe o code.py com um KeyboardInterrupt.
  • Qualquer tecla entra então no REPL, e >>> responde ali.
  • Ctrl-D recarrega e roda o code.py de novo.

Quando um programa para com um erro, o CircuitPython imprime um traceback. O Mokxi o lê, marca a linha no seu arquivo e diz o que o erro costuma significar nas palavras do CircuitPython: um módulo MicroPython num programa CircuitPython, um pull-up faltando, um pino já em uso, ou board.I2C(), que o Pico não tem (use busio.I2C(board.GP5, board.GP4)).

O que funciona, e o que não funciona

digitalio, analogio, pwmio, busio.I2C e busio.UART funcionam, então adafruit_bme280, adafruit_ssd1306 e displayio com adafruit_display_text conversam com os componentes no canvas.

O PIO também roda, então neopixel_write e a biblioteca neopixel acendem uma fita WS2812, e pulseio.PulseIn lê o eco que adafruit_hcsr04 usa para medir um HC-SR04.

Não simulados: o segundo núcleo; audiobusio, audiopwmio e picodvi; e ler o drive pelo computador, que só salva nele.

WiFi no Pico W

wifi.radio.connect() conecta ao ponto de acesso simulado do Mokxi. O nome e a senha dele são as propriedades de WiFi da placa, que começam como Mokxi-Lab e breadboard. socketpool e adafruit_requests (que o editor coloca em lib/ junto com o adafruit_connection_manager de que precisa) alcançam os sites fictícios .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())

Qualquer outro nome não é encontrado, e https:// não tem para onde ir. Não simulados: Bluetooth, os clientes do modo ponto de acesso e a economia de energia. wifi.radio.ap_info levanta NotImplementedError, porque a porta do CircuitPython para o Pico W não o implementa.

Importando do Wokwi

Um projeto Wokwi para o Pico, o Pico W, o Nano RP2040 Connect ou o ESP32-S3-DevKitC-1 com um code.py é importado com a placa configurada para CircuitPython, e roda. Em outra placa, o code.py é mantido como texto, e a importação diz o porquê. O Wokwi pode ter usado outra versão do CircuitPython; o relatório de importação diz qual roda aqui. Veja Vindo do Wokwi.

Numa placa de verdade

Uma placa CircuitPython não precisa de compilação. Coloque o CircuitPython no Pico (segure BOOTSEL enquanto o conecta, depois arraste o .uf2 de circuitpython.org/board/raspberry_pi_pico para o drive RPI-RP2), então salve code.py no drive CIRCUITPY que aparece e copie as bibliotecas que ele importa para CIRCUITPY/lib (o circup install faz isso por você).

Num Pico W, arraste o .uf2 de circuitpython.org/board/raspberry_pi_pico_w em vez disso, e coloque o nome e a senha da sua própria rede em code.py. Num Nano RP2040 Connect, ligue REC ao GND com um jumper enquanto o conecta, e arraste o .uf2 de circuitpython.org/board/arduino_nano_rp2040_connect. No ESP32-S3-DevKitC-1, conecte a porta USB dele (a marcada como USB, não UART) e use o instalador em circuitpython.org/board/espressif_esp32s3_devkitc_1_n8.

Projetos iniciais

Projetos iniciais num Pico, cada um na sua página: blink, um botão, um arco-íris de NeoPixel, um BME280 e texto num OLED SSD1306. O simulador de CircuitPython passa por eles.

Em outros lugares