Aprender

Simulador de CircuitPython: o firmware oficial num Pico, online

Iniciante

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
Raspberry Pi Pico: CircuitPython pisca um LEDao vivo0.000 s 0.00x
Clique para abrir no editor
Aperte Rodar. O firmware oficial do CircuitPython inicializa, o code.py é salvo na unidade CIRCUITPY e os dois LEDs piscam.

O Mokxi roda CircuitPython no Raspberry Pi Pico, no Pico W, no Arduino Nano RP2040 Connect e no ESP32-S3-DevKitC-1. Coloque um Pico no canvas, escolha CircuitPython (code.py) no painel Firmware dele, escreva o code.py e aperte Rodar. O que roda é o firmware oficial da Adafruit, CircuitPython 10.3.1 para o Raspberry Pi Pico, byte por byte como o circuitpython.org publica, sobre o RP2040 em nível de instrução do Mokxi. Nada na página interpreta o seu Python.

A placa inicializa como uma de verdade: o CircuitPython monta sua unidade CIRCUITPY, espera a janela de um segundo de modo seguro enquanto o LED do GP25 pisca e inicia o USB. O computador na ponta do cabo USB simulado da placa então abre sua porta serial e salva o code.py na unidade, como o seu próprio computador faz quando você salva do seu editor, e o auto-reload do CircuitPython o executa.

O circuito acima é o primeiro dos projetos iniciais abaixo: board.LED pisca o próprio LED do Pico e um LED vermelho no GP15, e o Monitor Serial diz on e off.

Como o code.py chega à placa

O CircuitPython guarda seus arquivos numa unidade chamada CIRCUITPY, na flash do Pico. 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, menos o code.py.

O code.py em si é salvo por USB, bloco por bloco, do jeito que um sistema operacional grava um arquivo numa unidade USB. O CircuitPython recebe o salvamento na flash e recarrega, e o code.py roda com o Monitor Serial conectado, então cada linha que imprime aparece. Ele imprime uns dois segundos depois de Rodar, a maior parte disso a janela de modo seguro do próprio CircuitPython e a espera após um salvamento antes de recarregar.

Piscar com digitalio

digitalio.DigitalInOut(board.LED) é o próprio LED do Pico no GP25, e board.GP15 acende um LED vermelho através de 220 ohms até o terra. Os dois acendem juntos, e o Monitor Serial imprime on e off depois da linha saída do code.py: do CircuitPython.

code.py: piscar um LED
# 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)

Um botão com o pull-up do pino

Um botão do GP14 ao terra, com switch_to_input(pull=digitalio.Pull.UP): o pino lê True até o botão ser apertado e False enquanto está pressionado. O programa imprime Aperte o botão, acende o LED da placa enquanto você o segura e conta cada apertada uma única vez.

code.py: um botão acende o LED
# 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)

Um arco-íris de NeoPixels com a biblioteca neopixel

Oito LEDs WS2812 no GP16. A biblioteca neopixel da Adafruit vai para lib/ sozinha, e ela envia os bits da fita por uma das máquinas de estado PIO do Pico, como num Pico de verdade. As cores giram pela fita, e a cada 64 passos o programa imprime o passo e a cor do primeiro pixel, começando com step 64 first pixel.

code.py: um arco-íris de NeoPixels
# 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)

Um BME280 com adafruit_bme280

busio.I2C(board.GP5, board.GP4) é o I2C0 do Pico, SCL primeiro e depois SDA. A biblioteca adafruit_bme280 da Adafruit lê o sensor; você não a adiciona em lugar nenhum, pois o editor a coloca na pasta lib/ da unidade quando o code.py a importa. Com o componente configurado para 22.5 C e 45% ele imprime 22.5 C 45.0 % humidity e a pressão a cada dois segundos, e quando você muda a temperatura no componente a próxima leitura a acompanha.

code.py: um BME280 no Monitor Serial
# 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 num OLED SSD1306 com displayio

displayio desenha no OLED através de adafruit_displayio_ssd1306, e adafruit_display_text cria os rótulos, com a própria fonte terminalio do firmware. As duas bibliotecas, e a adafruit_ticks que a adafruit_display_text precisa, vão para lib/ sozinhas. O programa escreve um título e um contador que aumenta uma vez por segundo, e imprime count 0, count 1 e assim por diante.

code.py: texto em um OLED SSD1306
# 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 no Pico W

A Pico W roda a própria compilação do CircuitPython para ela, com seu chip de rádio CYW43439 modelado a partir de seus pinos: board.LED é o LED do chip de rádio, e wifi.radio.connect() conecta ao ponto de acesso simulado do Mokxi. Seu nome e senha são as propriedades de WiFi da placa, que começam como Mokxi-Lab e breadboard. socketpool e a biblioteca adafruit_requests da Adafruit, com a adafruit_connection_manager de que ela precisa, já postas em lib/ para você, buscam os sites fictícios .mokxi da rede simulada, como http://weather.mokxi/.

A rede é simulada: nomes fora de .mokxi não são encontrados, e https:// não tem para onde ir. Bluetooth, os clientes do modo ponto de acesso e a economia de energia não são simulados, e wifi.radio.ap_info levanta NotImplementedError, pois a port do CircuitPython para a Pico W não o implementa.

As bibliotecas que vão para lib/ sozinhas

O Mokxi lê cada linha de import e coloca 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 próprios arquivos .mpy compilados da Adafruit, do pacote CircuitPython 10.x, sem alteração: adafruit_bme280, adafruit_display_text (com adafruit_ticks), adafruit_displayio_ssd1306, adafruit_framebuf (com seu font5x8.bin na raiz da unidade), adafruit_hcsr04, adafruit_requests (com adafruit_connection_manager), adafruit_ssd1306 e neopixel. Uma aba com o nome de uma biblioteca, como neopixel.py, é sua e é usada em vez dela.

Módulos embutidos no firmware não precisam de nada: board, digitalio, analogio, pwmio, busio, time, displayio, terminalio, i2cdisplaybus e os demais.

O REPL

O monitor serial é a porta serial USB da Pico, nos dois sentidos: o que code.py imprime, seus tracebacks, e Code done running. quando ele termina. Ctrl-C para o code.py com um KeyboardInterrupt, qualquer tecla entra então no REPL, onde >>> responde, e Ctrl-D recarrega e roda o code.py de novo.

Quando um programa para com um erro, o Mokxi marca a linha no seu arquivo e diz o que o erro costuma significar nas palavras do CircuitPython: um módulo do MicroPython como machine em um programa CircuitPython, um pull-up faltando, um pino em uso, ou board.I2C(), que a Pico não tem.

O que funciona, e o que não funciona

Funcionando: digitalio, analogio, pwmio, busio.I2C e busio.UART, com os componentes no canvas; adafruit_bme280, adafruit_ssd1306 com adafruit_framebuf e displayio com adafruit_display_text. 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 cronometrar um HC-SR04. Um reset de dentro, com microcontroller.reset() ou o watchdog, mantém o drive, então o code.py roda de novo.

Ainda não simulados: o segundo núcleo; audiobusio, audiopwmio e picodvi; e a leitura da unidade pelo computador, que só salva nela. O ESP32-S3-DevKitC-1 também roda CircuitPython, com sua própria compilação e seu REPL e unidade no USB nativo do S3, mas o WiFi não é simulado sob CircuitPython lá.

Importando do Wokwi

Um projeto do Wokwi para a Pico, a Pico W, a Nano RP2040 Connect ou o ESP32-S3-DevKitC-1 com um code.py é importado com sua placa configurada para CircuitPython, e roda. Em outra placa o code.py é guardado 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.

O mesmo código em uma Pico de verdade

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

Abra este circuito no editor. Raspberry Pi Pico: CircuitPython pisca um LED, ligado como aparece rodando no topo desta página. Troque um componente ou um valor e rode de novo.

Abrir o circuito

Perguntas

Isto é CircuitPython de verdade?

Sim. A placa roda o firmware oficial do CircuitPython 10.3.1 para a Raspberry Pi Pico, o mesmo .uf2 que o circuitpython.org publica, byte por byte, em um RP2040 simulado. Nada na página web interpreta o seu Python.

Quais placas rodam CircuitPython?

A Raspberry Pi Pico; a Pico W, com WiFi na rede simulada; a Arduino Nano RP2040 Connect com a própria compilação do CircuitPython para ela, onde `board.LED` é o LED no D13 e `board.I2C()` está em A4 e A5; e o ESP32-S3-DevKitC-1. Escolha CircuitPython (code.py) no painel de Firmware da placa. A mesma Pico pode rodar MicroPython (main.py) ou um sketch do Arduino em vez disso.

Preciso instalar bibliotecas?

Não. As bibliotecas da Adafruit que um programa importa, entre as que o Mokxi tem, vão para a pasta lib/ da unidade ao Rodar sozinhas, com o que precisam por sua vez, como o circup as colocaria lá.

Ele baixa alguma coisa?

A primeira vez que você roda um projeto CircuitPython, o firmware é baixado, e o navegador o guarda para toda rodada seguinte. Cada biblioteca só é baixada quando um programa a importa. Um sketch do Arduino nunca baixa nada.

Monte isto de verdade

Abra o editor, mude um valor e veja o número mudar junto. Nada para instalar, e não precisa de conta.