Belajar

MicroPython di Raspberry Pi Pico, tanpa perlu memasang apa pun

Pemula

Atau lihat semua pelajaran.

  • 526komponen di meja kerja
  • 46board sedang berjalan
  • 1.00xwaktu nyata, di semua board
Raspberry Pi Pico: MicroPython meredupkan LED dari knoblive0.000 s 0.00x
Klik untuk membukanya di editor
Tekan Jalankan, lalu putar knob-nya. MicroPython membaca GP26 dengan ADC dan mengatur duty PWM di GP15.

Mokxi menjalankan MicroPython di Raspberry Pi Pico-nya. Letakkan sebuah Pico di kanvas, pilih MicroPython (main.py) di panel Firmware-nya, tulis main.py dan tekan Jalankan. Yang berjalan adalah firmware MicroPython v1.29.0 resmi untuk Pico, file yang sama yang akan kamu seret ke Pico sungguhan, di RP2040 simulasi Mokxi, instruksi demi instruksi.

Saat kamu menekan Jalankan, board mem-boot firmware itu, dan komputer di ujung kabel USB simulasinya menyalin file .py-mu ke filesystem board seperti yang dilakukan Thonny, lalu melakukan soft-reboot. MicroPython mencetak MPY: soft reboot dan menjalankan main.py. Semua yang dikatakan print() tampil di Serial Monitor, dan saat main.py selesai, REPL menjawab: ketik 6*7 dan ia menjawab 42.

Rangkaian di atas adalah potensiometer di GP26 dan LED di GP15. Putar knob-nya dan LED meredup dan terang, dan Serial Monitor menampilkan posisi knob dalam persen.

Programnya: ADC masuk, PWM keluar

ADC(26) adalah input analog RP2040 di GP26, dan read_u16() memberi 0 pada 0 V dan 65535 pada referensi 3.3 V. Konverternya sendiri punya 12 bit, jadi nilainya bergerak dalam langkah sekitar 16. PWM(Pin(15)) adalah slice PWM di balik GP15, dan duty_u16() menerima rentang 0 sampai 65535 yang sama, jadi hasil baca knob bisa langsung dipakai sebagai duty.

Dengan wiper di 1.1 V, sepertiga dari bawah, read_u16() di sini selalu mencetak 21845: 1365 dari 4095 hitungan, yang MicroPython renggangkan ke 16 bit dengan menggesernya naik empat bit dan mengulang empat bit teratasnya di bawah, seperti di Pico sungguhan. Pada duty 32768, pin LED terukur tinggi selama 50.0% dari setiap periode 1 ms.

main.py: peredup dengan knob
# 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)

Blink dengan machine.Pin, dan berapa lama sebuah sleep sebenarnya

LED bawaan Pico ada di GP25. Program di bawah menogglenya setiap 100 ms. Diukur di pin board, setiap periode di sini 200 ms dengan toleransi satu milidetik, karena time.sleep_ms() menunggu lewat timer mikrodetik milik RP2040 sendiri.

utime.ticks_us() juga membaca timer itu. Empat panggilan sleep_ms(250) berurutan di sini selalu terukur dalam setengah milidetik dari 1000000 mikrodetik. machine.freq() menyebut 125000000, yaitu 125 MHz milik Pico.

main.py: blink LED bawaan
from machine import Pin
import time

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

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

Tombol dengan interrupt

Pin.irq() menjalankan sebuah fungsi saat pin berubah, tanpa perlu dipantau loop utama. Di sini tombol dari GP14 ke ground memakai pull-up internal pin, jadi pin terbaca 1 sampai tombol ditekan, dan IRQ_FALLING menjalankan handler sekali per tekan. Buat handler tetap singkat: tambah ke counter, set sebuah flag, dan biarkan loop utama yang mencetak.

main.py: hitung tekanan tombol dengan 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)

Memindahkan sketch Arduino ke MicroPython

Sebagian besar sketch Arduino punya kembaran MicroPython satu baris. Tidak ada setup() dan loop(): bagian atas main.py berjalan sekali, dan loop while True: di akhir berjalan selamanya. Pin adalah objek yang dibuat dari modul machine, dan waktu berasal dari modul time.

Dua hal berubah ukuran. analogRead() di Uno memberi 0 sampai 1023, dan read_u16() memberi 0 sampai 65535 berapa pun resolusi konverternya sendiri. Dan selisih waktu diambil dengan time.ticks_diff(), yang tetap benar saat counter wrap, bukan dengan pengurangan biasa.

Di bawah adalah contoh AnalogReadSerial Arduino, yang dipindahkan, di rangkaian peredup knob tadi. Dengan knob di tengah ia mencetak 0 ms 32743 1.65 V, lalu bacaan yang sama pada 500 ms, 1000 ms dan seterusnya: 32743 adalah 2046 dari 4095 hitungan, direnggangkan ke 16 bit.

Panggilan Arduino dan padanan MicroPython-nya di 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 sampai 1023ADC(26).read_u16(), 0 sampai 65535
analogWrite(15, 128), 0 sampai 255PWM(Pin(15)).duty_u16(32768), 0 sampai 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, hasil pindahan
# 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: OLED dan BME280 dengan machine.I2C

machine.I2C(0) dan machine.I2C(1) adalah dua blok I2C milik RP2040, dan komponen di satu bus menjawab di alamatnya: di sini SSD1306 OLED berada di I2C0 (GP4 dan GP5) dan scan() menemukannya di 0x3C (60), sedangkan BME280 berada di I2C1 (GP6 dan GP7) di 0x76 (118). Keduanya juga bisa berbagi satu bus, karena alamatnya berbeda. Tambahkan driver sebagai tab, ssd1306.py dari micropython-lib dan driver BME280, dan keduanya akan disalin ke board bersama main.py, seperti cara Thonny menyalinnya.

Bus berjalan di jam tersimulasi dengan kecepatan yang benar-benar dihasilkan bloknya: 400 kHz yang diminta jadi 376 kHz di kabel, dan oled.show(), 1 KB gambar, memakan 25.4 ms. Tanya ke alamat yang tidak dijawab siapa pun dan panggilan memunculkan OSError: [Errno 5] EIO, seperti di Pico sungguhan. machine.SPI bekerja dengan cara yang sama, lengkap dengan DMA, dan SoftI2C serta SoftSPI bekerja di pin mana pun.

main.py: BME280 di 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)

Saat program berhenti karena error

MicroPython menghentikan program yang bermasalah dan mencetak traceback: file, baris, dan errornya. Mokxi membacanya dari serial port, menandai barisnya di editor dan menjelaskan arti error tersebut. NameError berarti sebuah nama dipakai sebelum diberi nilai atau diimpor (nama di Python peka huruf besar/kecil); SyntaxError berarti ada baris yang bukan Python yang valid, biasanya titik dua yang kurang di akhir baris if, for, while, atau def; ImportError untuk RPi.GPIO atau gpiozero berarti kodenya ditulis untuk komputer Raspberry Pi, bukan untuk Pico.

Setelah traceback, REPL menjawab, jadi kamu bisa mencoba baris itu lagi secara manual sebelum mengubah main.py.

Apa yang disimulasi, dan apa yang tidak

Disimulasikan: core Cortex-M0+ milik RP2040 beserta boot ROM-nya, bootloader tahap kedua, chip flash dan filesystem littlefs di dalamnya, clock, USB port, pin GPIO beserta pull-up dan interrupt-nya, PWM, ADC dengan sensor suhunya, blok I2C dan SPI serta DMA, timer, RTC, dan watchdog.

Belum disimulasikan: core kedua, jadi _thread menghentikan board dengan pesan yang menjelaskannya; blok I2C sebagai target (machine.I2CTarget); dan clock CPU, yang tetap di 125 MHz apa pun pengaturan machine.freq(), meskipun timer dan setiap pengukuran waktu tetap akurat. Blok PIO tetap berjalan, jadi rp2.PIO dan rp2.StateMachine menggerakkan pin-nya. Pico W menjalankan build MicroPython-nya sendiri, dengan CYW43439 yang dimodelkan dari pin-pinnya: Pin("LED") menyalakan LED board dan network.WLAN bergabung ke jaringan simulasi Mokxi.

Buka rangkaian ini di editor. Raspberry Pi Pico: MicroPython meredupkan LED dengan sebuah knob, dirangkai seperti yang berjalan di bagian atas halaman ini. Ubah komponen atau nilainya dan jalankan lagi.

Buka rangkaian ini

Pertanyaan

Apakah ini MicroPython sungguhan atau tiruannya?

Sungguhan. Board menjalankan firmware MicroPython v1.29.0 resmi untuk Raspberry Pi Pico, file .uf2 yang sama dengan yang dipublikasikan micropython.org, di atas RP2040 simulasi. Tidak ada bagian dari halaman web yang menafsirkan Python-mu: firmware-lah yang mengompilasi dan menjalankannya di chip simulasi.

Bagaimana main.py bisa masuk ke board?

Seperti cara Thonny dan mpremote. Saat dijalankan, komputer simulasi di USB port Pico membuka serial port-nya, masuk ke raw REPL, menulis setiap tab .py ke filesystem littlefs board dengan skrip singkat, lalu soft-reboot board, yang kemudian menjalankan main.py.

Bisakah aku menambahkan modul atau library sendiri?

Bisa. Tambahkan tab dengan file .py modulnya, misalnya ssd1306.py, lalu impor dari main.py. Setiap tab .py disalin ke board bersama main.py.

Apakah ini mengunduh sesuatu?

Run pertama proyek MicroPython mengunduh firmware, 229 KB, dan browser menyimpannya untuk setiap Run berikutnya. Proyek Arduino tidak pernah mengunduhnya.

Rakit versi nyatanya

Buka editor, ubah sebuah nilai, dan lihat angkanya ikut berubah. Tidak ada yang perlu dipasang, dan tidak perlu akun.