Aprender

MicroPython no Raspberry Pi Pico, sem instalar nada

Iniciante

Ou veja todas as aulas.

  • 526componentes na bancada
  • 46placas rodando agora
  • 1.00xtempo real, em todas as placas
Raspberry Pi Pico: MicroPython controla o brilho de um LED com um potenciômetroao vivo0.000 s 0.00x
Clique para abrir no editor
Aperte Rodar e gire o potenciômetro. O MicroPython lê o GP26 com ADC e define o duty do PWM no GP15.

O Mokxi roda MicroPython no seu Raspberry Pi Pico. Coloque uma Pico no canvas, escolha MicroPython (main.py) no painel de Firmware dela, escreva o main.py e aperte Rodar. O que roda é o firmware oficial do MicroPython v1.29.0 para a Pico, o mesmo arquivo que você arrastaria para uma placa de verdade, no RP2040 simulado do Mokxi, instrução por instrução.

Quando você aperta Rodar, a placa inicializa esse firmware, e o computador na ponta do seu cabo USB simulado copia seus arquivos .py para o sistema de arquivos da placa como o Thonny faz, e depois faz um soft reboot. O MicroPython imprime MPY: soft reboot e roda o main.py. Tudo que o print() diz aparece no monitor serial, e quando o main.py termina o REPL responde: digite 6*7 e ele diz 42.

O circuito acima é um potenciômetro no GP26 e um LED no GP15. Gire o potenciômetro e o LED diminui e aumenta de brilho, e o monitor serial mostra a posição do potenciômetro em porcentagem.

O programa: ADC na entrada, PWM na saída

ADC(26) é a entrada analógica do RP2040 no GP26, e read_u16() dá 0 a 0 V e 65535 na referência de 3,3 V. O conversor em si tem 12 bits, então o valor muda em passos de cerca de 16. PWM(Pin(15)) é a fatia de PWM por trás do GP15, e duty_u16() aceita a mesma faixa de 0 a 65535, então a leitura do potenciômetro pode ir direto como duty.

Com o cursor a 1,1 V, um terço do percurso, read_u16() imprimiu 21845 todas as vezes aqui: 1365 contagens de 4095, que o MicroPython estica para 16 bits deslocando quatro bits para cima e repetindo seus quatro bits mais altos embaixo, como numa Pico de verdade. Com um duty de 32768, o pino do LED mediu alto por 50,0% de cada período de 1 ms.

main.py: o dimmer de potenciômetro
# 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)

Piscar com machine.Pin, e quanto tempo um sleep realmente leva

O LED embutido de uma Pico é o GP25. O programa abaixo alterna o estado dele a cada 100 ms. Medido no pino da placa, cada período aqui teve 200 ms com precisão de um milissegundo, porque time.sleep_ms() espera no próprio temporizador de microssegundos do RP2040.

utime.ticks_us() também lê esse temporizador. Quatro chamadas de sleep_ms(250) em sequência mediram dentro de meio milissegundo de 1000000 microssegundos todas as vezes aqui. machine.freq() diz 125000000, os 125 MHz da Pico.

main.py: piscar o LED embutido
from machine import Pin
import time

led = Pin(25, Pin.OUT)   # the Pico's green LED

while True:
    led.toggle()
    time.sleep_ms(100)

Um botão com interrupção

Pin.irq() executa uma função quando um pino muda, sem que o laço principal fique vigiando. Aqui um botão do GP14 para o terra usa o pull-up interno do pino, então o pino lê 1 até o botão ser pressionado, e IRQ_FALLING executa o handler uma vez por pressionada. Mantenha o handler curto: some a um contador, defina uma flag, e deixe o laço principal fazer a impressão.

main.py: contar pressionadas com Pin.irq()
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)

Portando um sketch Arduino para MicroPython

A maior parte de um sketch Arduino tem um equivalente em MicroPython de uma linha. Não existem setup() e loop(): o topo do main.py roda uma vez, e um laço while True: no final roda para sempre. Os pinos são objetos criados a partir do módulo machine, e os tempos vêm do módulo time.

Duas coisas mudam de tamanho. analogRead() em um Uno dá de 0 a 1023, e read_u16() dá de 0 a 65535, independentemente da resolução própria do conversor. E uma diferença de tempo é calculada com time.ticks_diff(), que continua correta quando o contador dá a volta, em vez de ser feita por subtração.

Abaixo está o exemplo AnalogReadSerial do Arduino, portado, no circuito do dimmer de potenciômetro. Com o potenciômetro na metade, ele imprimiu 0 ms 32743 1.65 V, depois a mesma leitura em 500 ms, 1000 ms e assim por diante: 32743 é 2046 de 4095 contagens, esticado para 16 bits.

Chamadas do Arduino e seus equivalentes em MicroPython no Pico
ArduinoMicroPython
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), 0 a 1023ADC(26).read_u16(), 0 a 65535
analogWrite(15, 128), 0 a 255PWM(Pin(15)).duty_u16(32768), 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=...)
main.py: AnalogReadSerial, portado
# 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: um OLED e um BME280 com machine.I2C

machine.I2C(0) e machine.I2C(1) são os dois blocos de I2C do RP2040, e os componentes em um barramento respondem em seus endereços: aqui o OLED SSD1306 está no I2C0 (GP4 e GP5), e scan() o encontra em 0x3C (60), e o BME280 está no I2C1 (GP6 e GP7) em 0x76 (118). Os dois também podem compartilhar um barramento, já que têm endereços diferentes. Adicione os drivers como abas, ssd1306.py da micropython-lib e um driver de BME280, e eles são copiados para a placa junto com o main.py, como o Thonny os copia.

O barramento roda no relógio simulado à velocidade que o bloco realmente gera: 400 kHz pedidos são 376 kHz no fio, e oled.show(), 1 KB de imagem, leva 25.4 ms. Pergunte a um endereço que ninguém responde e a chamada levanta OSError: [Errno 5] EIO, como em um Pico de verdade. machine.SPI funciona da mesma forma, com DMA e tudo, e SoftI2C e SoftSPI funcionam em quaisquer pinos.

main.py: um BME280 em um SSD1306
# 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)

Quando o programa para com um erro

O MicroPython para um programa que dá errado e imprime um traceback: o arquivo, a linha e o erro. O Mokxi lê isso pela porta serial, marca a linha no editor e diz o que o erro normalmente significa. Um NameError é um nome usado antes de receber um valor ou ser importado (nomes em Python diferenciam maiúsculas de minúsculas); um SyntaxError é uma linha que não é um Python válido, geralmente um dois-pontos faltando no fim de uma linha if, for, while ou def; um ImportError de RPi.GPIO ou gpiozero significa código escrito para um computador Raspberry Pi, não para o Pico.

Depois do traceback o REPL responde, então você pode tentar a linha de novo à mão antes de alterar o main.py.

O que é simulado, e o que não é

Simulado: o núcleo Cortex-M0+ do RP2040 e sua ROM de boot, o bootloader de segundo estágio, o chip de flash e o sistema de arquivos littlefs nele, os clocks, a porta USB, os pinos GPIO com seus pull-ups e interrupções, PWM, o ADC com o sensor de temperatura, os blocos I2C e SPI e o DMA, o timer, o RTC e o watchdog.

Ainda não simulado: o segundo núcleo, então _thread para a placa com uma mensagem avisando disso; o bloco I2C como destino (machine.I2CTarget); e o clock da CPU, que fica em 125 MHz não importa o valor definido em machine.freq(), embora o timer e toda medição de tempo continuem corretos. Os blocos PIO funcionam, então rp2.PIO e rp2.StateMachine controlam seus pinos. O Pico W roda sua própria compilação do MicroPython, com o CYW43439 modelado a partir de seus pinos: Pin("LED") acende o LED da placa e network.WLAN entra na rede simulada do Mokxi.

Abra este circuito no editor. Raspberry Pi Pico: o MicroPython controla o brilho de um LED com um potenciômetro, ligado como no circuito que roda no topo desta página. Troque um componente ou um valor e rode de novo.

Abrir o circuito

Perguntas

Isto é MicroPython de verdade ou uma imitação?

É de verdade. A placa roda o firmware oficial do MicroPython v1.29.0 para o Raspberry Pi Pico, o mesmo arquivo .uf2 que o micropython.org publica, em um RP2040 simulado. Nada na página web interpreta o seu Python: o firmware compila e executa o código no chip simulado.

Como o main.py chega à placa?

Do mesmo jeito que o Thonny e o mpremote fazem. Ao Rodar, o computador simulado na porta USB do Pico abre a porta serial, entra no raw REPL, grava cada aba .py no sistema de arquivos littlefs da placa com um script curto e faz um soft-reboot, e a placa então roda o main.py.

Posso adicionar meus próprios módulos ou uma biblioteca?

Sim. Adicione uma aba com o arquivo .py do módulo, como ssd1306.py, e importe-o no main.py. Toda aba .py é copiada para a placa junto com o main.py.

Ele baixa alguma coisa?

O primeiro Rodar de um projeto MicroPython baixa o firmware, 229 KB, e o navegador o guarda para todos os Rodar seguintes. Um projeto Arduino nunca o baixa.

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.