MicroPython Nedir? Temel Komutlar, REPL ve İlk Programlar

MicroPython, Python 3 dilinin mikrodenetleyiciler için yeniden yazılmış, küçük ve hızlı bir sürümüdür. Raspberry Pi Pico ya da ESP32 gibi bir karta MicroPython yüklediğinde kart, Python kodunu doğrudan kendi içinde çalıştırır: derleme beklemeden bir komut yazar, LED'in anında yandığını görürsün. Python'u okulda ya da bilgisayarda öğrendiysen aynı sözdizimiyle pin okuyabilir, motor sürebilir, sensörlerden veri alabilir ve Wi-Fi'ye bağlanabilirsin.

Bu rehberde MicroPython'un normal Python'dan farklarını, kartla anında konuşmanı sağlayan REPL'i ve en çok kullanacağın modülleri, yani machine.Pin, PWM, ADC ve I2C'yi örnek kodlarla öğreneceksin. Ardından time.sleep ile ticks_ms arasındaki farkı, açılışta çalışan main.py ve boot.py dosyalarını, Thonny ve mpremote ile dosya yüklemeyi, mip ile kütüphane eklemeyi ve Pico ile ESP32'ye firmware yüklemeyi göreceksin. Son bölümde MicroPython'u Arduino C++ ile yan yana karşılaştırıyoruz.

MicroPython nedir, Python'dan farkı ne?

MicroPython, 2013'te Damien George tarafından küçük bir kart için başlatılan açık kaynaklı bir projedir ve bugün onlarca mikrodenetleyiciyi destekler. Karta yüklediğin firmware, Python yorumlayıcısını, temel modülleri ve küçük bir dosya sistemini içerir. Yazdığın kod kart üzerinde önce bytecode'a çevrilir, sonra yorumlayıcı bu bytecode'u satır satır çalıştırır. Bilgisayarındaki Python'un tamamını birkaç yüz KB'lık RAM'e sığdırmak mümkün olmadığı için dil aynı kalır, ama kütüphanelerin büyük kısmı ya küçültülmüştür ya da hiç yoktur. Buna karşılık bilgisayardaki Python'da bulunmayan bir şey eklenmiştir: donanıma doğrudan erişen machine modülü.

MicroPython çalışan kartlar

Pico ve ESP32'ye MicroPython firmware'i yüklemek

1. Pico: Kartın üzerindeki BOOTSEL düğmesini basılı tutarak USB kablosunu tak, sonra düğmeyi bırak. Bilgisayarda RPI-RP2 adlı bir sürücü belirir (Pico 2'de RP2350).
2. MicroPython'un resmi indirme sayfasından kartına uygun .uf2 dosyasını indir (Pico için RPI_PICO, Pico W için RPI_PICO_W) ve bu sürücünün içine sürükle.
3. Kopyalama bitince kart kendiliğinden yeniden başlar ve sürücü kaybolur; MicroPython kurulmuştur. Thonny'de Araçlar > Seçenekler > Yorumlayıcı bölümünden MicroPython (Raspberry Pi Pico) seç.
4. ESP32: Bilgisayarına Python kuruluysa komut satırında pip install esptool yaz. Kartı bağla ve portunu öğren (Windows'ta COM3, Linux'ta /dev/ttyUSB0 gibi).
5. Önce flaşı sil: esptool.py --chip esp32 --port COM3 erase_flash. Kart bağlanamazsa komut çalışırken BOOT düğmesini basılı tut.
6. Firmware'i yaz: esptool.py --chip esp32 --port COM3 --baud 460800 write_flash -z 0x1000 ESP32_GENERIC-....bin. ESP32-S3 ve ESP32-C3'te adres 0x0'dır. Thonny'deki Install or update MicroPython (esptool) seçeneği aynı işi pencereden yapar.

REPL: kartla anında konuşmak

REPL (Read-Eval-Print Loop), kartın seri port üzerinden sana açtığı komut satırıdır. Thonny'nin alt kısmındaki Shell penceresinde gördüğün >>> işareti REPL'in seni beklediğini gösterir. Buraya 1 + 1 yazarsan kart hesaplayıp 2 döndürür; from machine import Pin ve ardından Pin("LED", Pin.OUT).value(1) yazarsan Pico'nun LED'i o anda yanar. Derleme ve yükleme beklemeden bir sensörün değerini okumak, bir pinin doğru bağlanıp bağlanmadığını denemek ya da bir kütüphanenin nasıl çalıştığını keşfetmek için REPL'den daha hızlı bir yol yoktur.

İlk program ve Arduino C++ karşılığı

1# İlk program: dahili LED'i yakıp söndür / First program: blink the onboard LED
2from machine import Pin
3import time
4
5led = Pin("LED", Pin.OUT)        # Pico ve Pico W; ESP32'de Pin(2, Pin.OUT) / Pico and Pico W; Pin(2, Pin.OUT) on ESP32
6
7while True:
8    led.value(1)                 # yak / on
9    time.sleep(0.5)              # saniye cinsinden / in seconds
10    led.value(0)                 # söndür / off
11    time.sleep(0.5)

1// Aynı program Arduino C++ ile / The same program in Arduino C++
2void setup() {
3  pinMode(LED_BUILTIN, OUTPUT);
4}
5
6void loop() {
7  digitalWrite(LED_BUILTIN, HIGH);
8  delay(500);                    // milisaniye cinsinden / in milliseconds
9  digitalWrite(LED_BUILTIN, LOW);
10  delay(500);
11}

İki program aynı işi yapar ama yapıları farklıdır. MicroPython'da setup() ve loop() yoktur: dosya yukarıdan aşağı bir kez çalışır, sonsuz döngüyü sen while True: ile kurarsın. Süslü parantez ve noktalı virgül yerine girinti kullanılır; döngünün içindeki satırların hepsi aynı miktarda (genellikle 4 boşluk) içeride olmalıdır. Bekleme süresi de farklı birimdedir: time.sleep(0.5) saniye, Arduino'daki delay(500) milisaniye alır. MicroPython'da milisaniye için time.sleep_ms(), mikrosaniye için time.sleep_us() kullanılır. Arduino tarafının temelleri Arduino programlama temelleri yazısında.

machine.Pin: dijital giriş ve çıkış

time.sleep ve ticks_ms: beklemeden zaman ölçmek

time.sleep() kartı tamamen bekletir; o sırada buton okunmaz, sensöre bakılmaz. Birden çok işi aynı anda yürütmek için Arduino'daki millis() mantığının MicroPython karşılığını kullanırsın: time.ticks_ms() açılıştan beri geçen milisaniyeyi verir, time.ticks_diff(yeni, eski) de iki an arasındaki farkı hesaplar. Farkı çıkarma işlemiyle değil ticks_diff ile almak önemlidir; sayaç belli bir değere ulaşınca başa döner ve düz çıkarma o anda yanlış sonuç verir. Aşağıdaki kod LED'i beklemeden yakıp söndürürken butonu bir kesme (IRQ) ile dinler; butona her basışta yanıp sönme hızı değişir.

1# delay kullanmadan iki iş: LED yanıp söner, buton kesmeyle modu değiştirir
2# Two jobs without blocking: the LED blinks, a button interrupt switches the mode
3from machine import Pin
4import time
5
6led = Pin(15, Pin.OUT)                       # LED + 220 Ω, GP15
7buton = Pin(14, Pin.IN, Pin.PULL_UP)         # buton GP14 ile GND arasında / button between GP14 and GND
8
9hizli = False
10son_basma = 0
11son_degisim = time.ticks_ms()
12
13def buton_kesme(pin):                        # kesme fonksiyonu kısa olmalı / keep the handler short
14    global hizli, son_basma
15    simdi = time.ticks_ms()
16    if time.ticks_diff(simdi, son_basma) > 200:   # 200 ms debounce / 200 ms debounce
17        son_basma = simdi
18        hizli = not hizli
19
20buton.irq(trigger=Pin.IRQ_FALLING, handler=buton_kesme)   # basınca HIGH'dan LOW'a iner / goes HIGH to LOW when pressed
21
22while True:
23    aralik = 100 if hizli else 500
24    if time.ticks_diff(time.ticks_ms(), son_degisim) >= aralik:   # taşmaya karşı güvenli / safe against wrap-around
25        son_degisim = time.ticks_ms()
26        led.value(not led.value())
27    # burada başka işler yapılabilir / other work can run here

PWM: parlaklık, servo ve ses

1# PWM: LED parlaklığı ve servo açısı / PWM: LED brightness and servo angle
2from machine import Pin, PWM
3import time
4
5led = PWM(Pin(15))
6led.freq(1000)                               # 1 kHz: titreme görünmez / no visible flicker
7
8for d in range(0, 65536, 2048):              # duty_u16: 0 (kapalı) ... 65535 (tam) / 0 (off) ... 65535 (full)
9    led.duty_u16(d)
10    time.sleep_ms(20)
11led.duty_u16(0)
12
13servo = PWM(Pin(16))
14servo.freq(50)                               # servolar 50 Hz (20 ms) ister / servos expect 50 Hz (20 ms)
15
16def servo_aci(derece):
17    us = 500 + derece * 2000 // 180          # 0° = 0,5 ms, 180° = 2,5 ms; servona göre ayarla / tune for your servo
18    servo.duty_ns(us * 1000)
19
20for a in (0, 90, 180, 90):
21    servo_aci(a)
22    time.sleep(1)

PWM nesnesi bir pini çok hızlı açıp kapatarak ortalama bir güç ayarlar. freq() saniyedeki tekrar sayısını, duty_u16() da pinin ne kadar süre açık kalacağını 0 ile 65535 arasında bir sayıyla belirler; 32768 yaklaşık yüzde 50 demektir. Bu ölçek Arduino'daki analogWrite'ın 0–255 aralığından çok daha ince adımlar verir. Servolar 50 Hz'lik bir sinyal ve 0,5–2,5 ms arasında bir darbe genişliği bekler; duty_ns() darbe süresini doğrudan nanosaniye olarak verdiği için servo kodunu çok sadeleştirir. Pasif bir buzzer'a farklı freq() değerleri vererek nota da çalabilirsin. Duty cycle ve frekans kavramlarının ayrıntısı PWM nedir yazısında.

ADC: analog okuma

1# ADC: potansiyometre ve Pico'nun dahili sıcaklık sensörü
2# ADC: a potentiometer and the Pico's internal temperature sensor
3from machine import ADC, Pin
4import time
5
6pot = ADC(Pin(26))                           # GP26 = ADC0; ESP32'de ADC(Pin(34)) / ADC(Pin(34)) on ESP32
7yonga = ADC(4)                               # 4. kanal: dahili sıcaklık / channel 4: internal temperature
8
9def ortalama(adc, n=16):                     # gürültüyü azalt / reduce noise
10    toplam = 0
11    for _ in range(n):
12        toplam += adc.read_u16()
13    return toplam // n
14
15while True:
16    ham = ortalama(pot)                      # 0-65535 (12 bit ölçüm 16 bite ölçeklenir) / 12-bit reading scaled to 16 bits
17    volt = ham * 3.3 / 65535
18    v_t = ortalama(yonga) * 3.3 / 65535
19    derece = 27 - (v_t - 0.706) / 0.001721   # RP2040 veri sayfasındaki formül / formula from the RP2040 datasheet
20    print("Pot: {} ({:.2f} V)  Yonga / chip: {:.1f} C".format(ham, volt, derece))
21    time.sleep(1)

read_u16() her kartta 0–65535 arasında bir değer döndürür; böylece aynı kod Pico'da da ESP32'de de çalışır. Pico'nun ADC'si gerçekte 12 bitliktir ve okuma 16 bite ölçeklenir. Pico'da kullanıcıya açık üç analog pin vardır: GP26 (ADC0), GP27 (ADC1) ve GP28 (ADC2); dördüncü kanal yonganın içindeki sıcaklık sensörüdür ve ortam sıcaklığını değil yonganın sıcaklığını ölçer. ESP32'de tam 0–3,3 V aralığını okumak için adc.atten(ADC.ATTN_11DB) ayarı gerekir ve Wi-Fi açıkken ADC2 pinleri kullanılamaz; bu yüzden GPIO 32–39 arasındaki ADC1 pinlerini seç. Koddaki 16 ölçümlük ortalama, ADC gürültüsünü belirgin şekilde azaltır. Çözünürlük ve referans gerilimi gibi kavramlar ADC nedir yazısında.

I2C: sensör ve ekran bağlamak

1# I2C: hattı tara ve SSD1306 OLED'e yaz / I2C: scan the bus and write to an SSD1306 OLED
2from machine import Pin, I2C
3import ssd1306                               # önce: mpremote mip install ssd1306 / first: mpremote mip install ssd1306
4
5i2c = I2C(0, sda=Pin(4), scl=Pin(5), freq=400000)   # Pico; ESP32'de I2C(0, sda=Pin(21), scl=Pin(22))
6adresler = i2c.scan()
7print("Bulunan / found:", [hex(a) for a in adresler])   # OLED genelde 0x3c / OLED is usually 0x3c
8
9if 0x3C in adresler:
10    oled = ssd1306.SSD1306_I2C(128, 64, i2c)
11    oled.fill(0)
12    oled.text("MicroPython", 0, 0)
13    oled.text("I2C: " + hex(adresler[0]), 0, 16)
14    oled.show()

I2C(0, sda=..., scl=...) donanım I2C birimini seçtiğin pinlerle başlatır, scan() da hatta cevap veren bütün cihazların adreslerini liste olarak döndürür. Bir sensör çalışmıyorsa ilk iş bu taramayı yapmaktır: liste boşsa sorun kablolamadadır, adres beklediğinden farklıysa koddaki adresi düzeltirsin. Pico'da her I2C biriminin kullanabildiği pinler sabittir; örneğin I2C0 için GP0-GP1, GP4-GP5 ya da GP8-GP9 çiftleri çalışır, yanlış bir çift seçersen ValueError alırsın. ESP32'de ise hemen her pine I2C atanabilir. Ekranın ayrıntıları OLED ekran, protokolün kendisi I2C nedir yazısında.

main.py ve boot.py: açılışta çalışan kod

Thonny'de Çalıştır düğmesine bastığında kod karta kaydedilmeden yalnızca o an çalışır; USB'yi çıkarınca kaybolur. Kodun kart her açıldığında kendiliğinden çalışması için dosyayı kartın içine main.py adıyla kaydetmelisin. Açılışta önce boot.py, ardından main.py çalışır. boot.py, Wi-Fi bağlantısı ya da saat ayarı gibi bir kez yapılacak hazırlıklar için kullanılır; ESP32 firmware'i bu dosyayı kendisi oluşturur, Pico'da ise genellikle yoktur. Asıl programın her zaman main.py'de durur. Başka dosyalara yazdığın fonksiyonları import ile main.py'ye çağırabilir, ölçümleri karttaki dosya sistemine open() ile kaydedebilirsin.

1# main.py: kart her açıldığında otomatik çalışır / runs automatically every time the board starts
2import time
3from machine import Pin
4
5time.sleep(3)                                # Ctrl+C ile durdurmak için güvenlik payı / a safety window for Ctrl+C
6led = Pin("LED", Pin.OUT)
7sayac = 0
8
9try:
10    while True:
11        sayac += 1
12        led.value(sayac % 2)
13        print("Calisiyor / running", sayac)
14        time.sleep(1)
15except KeyboardInterrupt:                    # Thonny'de Stop ya da Ctrl+C / Stop in Thonny or Ctrl+C
16    led.value(0)
17    print("Durduruldu / stopped")

Dosya yükleme: Thonny ve mpremote

Yeni başlıyorsan Thonny en kolay yoldur: kodunu yaz, Dosya > Farklı kaydet de, açılan pencerede Raspberry Pi Pico ya da MicroPython device seçeneğini seçip dosya adını main.py yap. Görünüm > Dosyalar menüsünü açarsan bilgisayarındaki ve karttaki dosyaları yan yana görür, sağ tıkla birinden diğerine kopyalarsın. Komut satırını sevenler ve VS Code gibi bir editör kullananlar için resmi araç mpremote'tur; pip install mpremote ile kurulur ve ilk bulduğu MicroPython kartına kendiliğinden bağlanır.

Kütüphane eklemek: mip

MicroPython'da pip yoktur; onun yerine küçük paket yöneticisi mip kullanılır. Pico W ya da ESP32 gibi internete bağlanabilen bir kartta önce Wi-Fi'ye bağlanır, sonra REPL'de import mip ve mip.install("ssd1306") yazarsın; paket resmi micropython-lib deposundan indirilip kartın /lib klasörüne yerleşir. GitHub'daki bir sürücüyü mip.install("github:kullanici/depo") biçiminde de kurabilirsin. Wi-Fi'si olmayan Pico için aynı işi bilgisayardan mpremote mip install komutuyla ya da Thonny'nin Araçlar > Paketleri yönet menüsüyle yaparsın. Tek dosyalık bir sürücüyü (ör. bir sensör için yazılmış .py dosyası) karta kopyalamak da yeterlidir; dosya kökte ya da /lib içinde durduğu sürece import ile çağrılır. Wi-Fi bağlantısının adımları Pico W Wi-Fi yazısında.

MicroPython mu, Arduino C++ mı?

Pratikte seçimi projen belirler. Bir sensörü okuyup Wi-Fi ile göndermek, bir web sayfası sunmak ya da bir ekran sürmek MicroPython'da daha az satırla ve daha hızlı biter. Mikrosaniye hassasiyetinde sinyal üretmek, yüzlerce LED'i çok hızlı güncellemek ya da yalnızca Uno gibi küçük bir kartın olması ise C++'ı öne çıkarır. Yavaş kalan bir fonksiyonu @micropython.native dekoratörüyle hızlandırabilir, döngü içinde yeni liste ve metin oluşturmaktan kaçınarak çöp toplayıcının duraklamalarını azaltabilirsin. Kart seçimi için Arduino mu ESP32 mi yazısına da bakabilirsin.

Sık hatalar ve çözümleri

MicroPython, mikrodenetleyici dünyasına Python bilerek girmenin en kısa yoludur: REPL'de bir pini denediğin anda sonucu görür, birkaç satırla sensör okuyup Wi-Fi'ye bağlanırsın. Temel modülleri, main.py mantığını ve ticks_ms ile beklemeden zaman ölçmeyi öğrendiğinde projelerin hızla büyür. BlueGrays uygulamasında Raspberry Pi Pico ile LED, trafik lambası, buton ve PWM projelerini devre şemaları ve MicroPython kodlarıyla adım adım bulabilirsin.