Öğren

Raspberry Pi Pico'da MicroPython, kurulum gerektirmeden

Başlangıç

Ya da tüm dersleri gör.

  • 526parça tezgahta
  • 46kart şu an çalışıyor
  • 1.00xgerçek zamanlı, her kartta
Raspberry Pi Pico: MicroPython bir potansiyometre ile LED'in parlaklığını ayarlıyorcanlı0.000 s 0.00x
Düzenleyicide açmak için tıkla
Çalıştır'a bas, sonra potansiyometreyi çevir. MicroPython GP26'dan ADC ile okuma yapar ve GP15'te PWM görev döngüsünü ayarlar.

Mokxi, Raspberry Pi Pico'sunda MicroPython çalıştırır. Tuvale bir Pico koy, Firmware panelinden MicroPython (main.py) seç, main.py'yi yaz ve Çalıştır'a bas. Çalışan şey, Pico için resmi MicroPython v1.29.0 firmware'idir; gerçek bir Pico'ya sürükleyip bırakacağın dosyanın aynısı, Mokxi'nin simüle edilmiş RP2040'unda komut komut çalışır.

Çalıştır'a bastığında kart bu firmware'i başlatır ve simüle edilmiş USB kablosunun ucundaki bilgisayar, .py dosyalarını Thonny'nin yaptığı gibi kartın dosya sistemine kopyalar, sonra kartı yumuşak yeniden başlatır. MicroPython, MPY: soft reboot yazdırır ve main.py'yi çalıştırır. print() fonksiyonunun yazdığı her şey Seri Monitör'de görünür ve main.py bittiğinde REPL yanıt verir: 6*7 yaz, 42 der.

Yukarıdaki devrede GP26'da bir potansiyometre ve GP15'te bir LED var. Potansiyometreyi çevir, LED kısılıp parlaklaşır ve Seri Monitör potansiyometrenin konumunu yüzde olarak gösterir.

Program: ADC girişi, PWM çıkışı

ADC(26), RP2040'ın GP26'daki analog girişidir ve read_u16(), 0 V'da 0, 3.3 V referansta 65535 verir. Dönüştürücünün kendisi 12 bittir, yani değer yaklaşık 16'şar adım ile değişir. PWM(Pin(15)), GP15'in arkasındaki PWM dilimidir ve duty_u16() aynı 0 ile 65535 aralığını alır, böylece potansiyometrenin okuma değeri doğrudan görev döngüsü olarak verilebilir.

Süpürge uç 1.1 V'da, yani üçte bir yükseklikteyken read_u16() burada her seferinde 21845 yazdırdı: 4095 sayısının 1365'i; MicroPython bunu, gerçek bir Pico'da olduğu gibi, dört bit yukarı kaydırıp en üstteki dört bitini altına tekrarlayarak 16 bite uzatır. 32768 görev döngüsünde LED pini her 1 ms'lik periyodun yüzde 50.0'ında yüksek ölçüldü.

main.py: potansiyometre ile karartma
# 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)

machine.Pin ile yak-söndür ve bir sleep gerçekte ne kadar sürer

Pico'nun kart üzerindeki LED'i GP25'tir. Aşağıdaki program onu her 100 ms'de bir ters çevirir. Kartın pininde ölçüldüğünde, buradaki her periyot bir milisaniye içinde 200 ms oldu, çünkü time.sleep_ms(), RP2040'ın kendi mikrosaniye zamanlayıcısında bekler.

utime.ticks_us() da o zamanlayıcıyı okur. Arka arkaya dört sleep_ms(250) çağrısı burada her seferinde 1000000 mikrosaniyenin yarım milisaniyesi içinde ölçüldü. machine.freq(), Pico'nun 125 MHz'i olan 125000000 der.

main.py: kart üzerindeki LED'i yak-söndür
from machine import Pin
import time

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

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

Kesme ile buton

Pin.irq(), bir pin değiştiğinde ana döngü onu izlemeden bir fonksiyon çalıştırır. Burada GP14'ten toprağa giden bir buton, pinin dahili pull-up'ını kullanır; yani buton basılana kadar pin 1 okunur ve IRQ_FALLING, işleyiciyi her basışta bir kez çalıştırır. İşleyiciyi kısa tut: bir sayaca ekle, bir bayrak ayarla ve yazdırmayı ana döngüye bırak.

main.py: Pin.irq() ile basışları sayma
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)

Arduino kodunu MicroPython'a taşımak

Bir Arduino kodunun çoğunun tek satırlık bir MicroPython karşılığı vardır. setup() ve loop() yoktur: main.py'nin en üstü bir kez çalışır, sonundaki while True: döngüsü sonsuza dek çalışır. Pinler machine modülünden yapılan nesnelerdir ve zamanlar time modülünden gelir.

İki şey boyut değiştirir. Uno'da analogRead() 0 ile 1023 arası verir ve read_u16(), dönüştürücünün kendi çözünürlüğü ne olursa olsun 0 ile 65535 arası verir. Bir zaman farkı da time.ticks_diff() ile alınır; bu, sayaç sarmalansa da doğru kalır, basit çıkarmayla değil.

Aşağıda, potansiyometre karartma devresi üzerinde taşınmış Arduino AnalogReadSerial örneği var. Potansiyometre yarıdayken 0 ms 32743 1.65 V yazdırdı, sonra 500 ms, 1000 ms ve sonrasında aynı okuma: 32743, 4095 kademenin 2046'sıdır ve 16 bite genişletilmiştir.

Arduino çağrıları ve Pico'daki MicroPython karşılıkları
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 ile 1023ADC(26).read_u16(), 0 ile 65535 arası
analogWrite(15, 128), 0 ile 255 arasıPWM(Pin(15)).duty_u16(32768), 0 ile 65535 arası
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, taşınmış hali
# 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: machine.I2C ile bir OLED ve bir BME280

machine.I2C(0) ve machine.I2C(1), RP2040'ın iki I2C bloğudur ve bir veri yolu üzerindeki parçalar kendi adreslerinde yanıt verir: burada SSD1306 OLED, I2C0'dadır (GP4 ve GP5) ve scan() onu 0x3C (60) adresinde bulur; BME280 ise I2C1'dedir (GP6 ve GP7), 0x76 (118). Farklı adreslere sahip oldukları için ikisi aynı veri yolunu da paylaşabilir. Sürücüleri sekme olarak ekle, micropython-lib'den ssd1306.py ve bir BME280 sürücüsü; Thonny'nin kopyaladığı gibi main.py ile birlikte karta kopyalanırlar.

Veri yolu, simüle edilmiş saatte bloğun gerçekte ürettiği hızda çalışır: istenen 400 kHz, kabloda 376 kHz olur ve oled.show(), 1 KB'lık görüntü, 25.4 ms sürer. Kimse yanıtlamayan bir adres sorarsan çağrı, gerçek bir Pico'da olduğu gibi OSError: [Errno 5] EIO hatası verir. machine.SPI de aynı şekilde çalışır, DMA dahil; SoftI2C ve SoftSPI ise herhangi pinlerde çalışır.

main.py: bir SSD1306 üzerinde BME280
# 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)

Program bir hatayla durduğunda

MicroPython, sorun çıkaran bir programı durdurur ve bir geri izleme (traceback) yazdırır: dosya, satır ve hata. Mokxi bunu seri porttan okur, ilgili satırı düzenleyicide işaretler ve hatanın genelde ne anlama geldiğini söyler. NameError, bir adın değer atanmadan veya içe aktarılmadan önce kullanılmasıdır (Python adları büyük/küçük harfe duyarlıdır); SyntaxError geçerli bir Python satırı olmayan bir satırdır, genelde bir if, for, while veya def satırının sonunda eksik iki nokta üst üste işaretidir; RPi.GPIO veya gpiozero için ImportError, kodun Pico için değil Raspberry Pi bilgisayarı için yazılmış olduğu anlamına gelir.

Geri izlemeden sonra REPL yanıt verir, böylece main.py'yi değiştirmeden önce satırı elle tekrar deneyebilirsin.

Neler simüle ediliyor, neler edilmiyor

Simüle edilen: RP2040'ın Cortex-M0+ çekirdeği ve önyükleme ROM'u, ikinci aşama önyükleyici, flash çip ve üzerindeki littlefs dosya sistemi, saatler, USB portu, kendi pull-up'ları ve kesmeleriyle GPIO pinleri, PWM, sıcaklık sensörlü ADC, I2C ve SPI blokları ile DMA, zamanlayıcı, RTC ve watchdog.

Henüz simüle edilmeyenler: ikinci çekirdek, bu yüzden _thread kartı bunu belirten bir mesajla durdurur; hedef olarak I2C bloğu (machine.I2CTarget); ve CPU saati, machine.freq() neye ayarlanırsa ayarlansın 125 MHz'de kalır, ama zamanlayıcı ve her zaman ölçümü doğru kalır. PIO blokları çalışır, yani rp2.PIO ve rp2.StateMachine pinlerini sürer. Pico W, kendi MicroPython derlemesini çalıştırır ve CYW43439'si pinlerinden modellenmiştir: Pin("LED") kartın LED'ini yakar ve network.WLAN Mokxi'nin simüle edilmiş ağına katılır.

Bu devreyi düzenleyicide aç. Raspberry Pi Pico: MicroPython, bu sayfanın üstünde çalıştığı haliyle kablolanan bir LED'i bir düğme kadranı ile karartır. Bir parçayı veya değeri değiştir ve yeniden çalıştır.

Devreyi aç

Sorular

Bu gerçek MicroPython mu, yoksa bir taklidi mi?

Gerçek. Kart, micropython.org'un yayınladığı aynı .uf2 dosyası olan, Raspberry Pi Pico için resmi MicroPython v1.29.0 firmware'ini simüle edilmiş bir RP2040 üzerinde çalıştırır. Web sayfasındaki hiçbir şey Python kodunu yorumlamaz: firmware, onu simüle edilmiş çip üzerinde derler ve çalıştırır.

main.py karta nasıl geliyor?

Thonny ve mpremote'nin yaptığı şekilde. Çalıştır'da, Pico'nun USB portundaki simüle edilmiş bilgisayar seri portunu açar, raw REPL'e girer, her .py sekmesini kısa bir betikle kartın littlefs dosya sistemine yazar ve kartı yumuşak yeniden başlatır; kart da main.py'yi çalıştırır.

Kendi modüllerimi veya bir kütüphane ekleyebilir miyim?

Evet. ssd1306.py gibi modülün .py dosyasıyla bir sekme ekle ve main.py'den içe aktar. Her .py sekmesi main.py ile birlikte karta kopyalanır.

Bir şey indiriyor mu?

Bir MicroPython projesinin ilk Çalıştır'ı 229 KB'lık firmware'i indirir ve tarayıcı onu sonraki her Çalıştır için saklar. Bir Arduino projesi onu hiç indirmez.

Bunu gerçekten kur

Düzenleyiciyi aç, bir değeri değiştir ve sayının onunla birlikte değiştiğini izle. Kurulacak bir şey yok, hesaba da gerek yok.