Arduino Portenta H7

Arduino Portenta H7, STMicroelectronics STM32H747XI etrafında oluşturulmuş 66 × 25 mm boyutlarında endüstriyel bir geliştirme kartıdır — 400 MHz’lik bir Cortex‑M7 ile 200 MHz’lik bir Cortex‑M4’ü birleştiren çift çekirdekli bir SoC’dir. OpenMV aygıt yazılımı (firmware) tamamen M7 çekirdeği üzerinde çalışır ve temel Portenta H7’ye bir Himax HM01B0 / HM0360 kamera, çift PDM mikrofon ve bir microSD yuvası ekleyen Portenta Vision Shield (Ethernet veya LoRa sürümü) ile birlikte kullanılmak üzere tasarlanmıştır.

Tam veri sayfası, fotoğraflar ve boyutlar için Arduino Portenta H7 ürün sayfasına bakın.

Öne Çıkanlar

• STMicroelectronics STM32H747XI çift çekirdekli Cortex‑M7 (400 MHz) + Cortex‑M4 (200 MHz). OpenMV aygıt yazılımı yalnızca M7 çekirdeği üzerinde çalışır; M4 çekirdeği, İşlemciler Arası İletişim için openamp aracılığıyla erişilebilir hale getirilir.

• 8 MB harici SDRAM ile birlikte 2 MB dahili flash bellek ve 16 MB harici QSPI flash bellek.

• Donanımsal JPEG kodlayıcı/kod çözücü.

• Murata 1DX (CYW4343W) modülü aracılığıyla Wi‑Fi b/g/n (2.4 GHz) + Bluetooth LE 5.1 — birlikte verilen antene kart üzerindeki bir U.FL konektörü üzerinden bağlanır.

• Yüksek hızlı USB‑C (480 Mb/s).

• Arduino MKR tarzı üst başlıklarda 22 kullanıcı I/O pini — D0–D14 (dijital) ile A0–A6 (analog).

• Alttaki iki adet 80 pinli yüksek yoğunluklu konektör, STM32H747’nin tüm yapısını açığa çıkarır — DCMI, DSI, Ethernet RMII, FDCAN, SDIO, SAI/I²S, UART’lar, ek SPI/I²C/zamanlayıcılar vb. Vision Shield gibi kalkanlar bu konektörlere takılır.

• Gelişmiş hata ayıklama için alttaki HD konektörlerine ayrılmış JTAG / SWD.

• Pil desteği — 3.7 V Li‑Po JST konektörü ile birlikte kart üzerinde şarj cihazı ve pil izleyici.

Pin Dağılımı

Pin referansı

Arduino MKR tarzı üst kenar başlıklarında 22 kullanıcı pini açığa çıkarılmıştır — 15 dijital (D0-D14) ile 7 analog (A0-A6). Kalkan çalışmaları için alttaki 80 pinli yüksek yoğunluklu konektörler aracılığıyla çok daha fazla SoC pini kullanılabilir; bu eşleme için Arduino’nun tam pin dağılımı PDF’ine bakın.

Pin adı	Referans	İşlev
D0	3.3 V	TIM8 CH3N
D1	3.3 V	TIM1 CH1 / SPI5 NSS
D2	3.3 V	TIM1 CH2 / SPI5 MISO
D3	3.3 V	GPIO
D4	3.3 V	TIM3 CH2 / TIM8 CH2 / USART6 RX
D5	3.3 V	TIM3 CH1 / TIM8 CH1 / USART6 TX
D6	3.3 V	TIM1 CH1 / I2C3 SCL
D7	3.3 V	TIM5 CH4 / SPI2 NSS
D8	3.3 V	SPI2 MOSI (A3 / A5 ile paylaşılır)
D9	3.3 V	SPI2 SCK
D10	3.3 V	SPI2 MISO (A2 / A4 ile paylaşılır)
D11	3.3 V	I2C3 SDA
D12	3.3 V	I2C3 SCL
D13	3.3 V	USART1 RX / TIM1 CH3
D14	3.3 V	USART1 TX / TIM1 CH2
A0	3.3 V	ADC12 IN0 (yalnızca analog)
A1	3.3 V	ADC12 IN1 (yalnızca analog)
A2	3.3 V	ADC123 IN12 (yalnızca analog; D10 ile paylaşılır)
A3	3.3 V	ADC12 IN13 (yalnızca analog; D8 ile paylaşılır)
A4	3.3 V	ADC123 IN12 (D10 ile paylaşılır)
A5	3.3 V	ADC12 IN13 (D8 ile paylaşılır)
A6	3.3 V	DAC1 OUT1 / ADC12 IN18
A7	3.3 V	TIM3 CH1 / ADC12 IN3 (başlıklarda açığa çıkarılmaz)
D20	3.3 V	D8 / A3 / A5 için takma ad
D21	3.3 V	A6 için takma ad — DAC1 OUT1
RESET	3.3 V	sıfırlamak için kart üzerindeki anahtara basın veya GND’ye çekin
LED_RED	3.3 V	RGB LED kırmızı kanalı (aktif düşük)
LED_GREEN	3.3 V	RGB LED yeşil kanalı (aktif düşük)
LED_BLUE	3.3 V	RGB LED mavi kanalı (aktif düşük)

Not

A0-A3, STM32H747 üzerinde GPIO işlevi olmayan yalnızca analog pedlerdir — bunları yalnızca ADC girişleri olarak değerlendirin. A2/A4 ve A3/A5, fiziksel pinlerini sırasıyla D10 ve D8 ile paylaşır, bu nedenle bunları analog olarak okurken üzerlerinde PWM veya SPI çalıştıramazsınız. A7, alttaki HD konektörlerinde bulunur.

Güç pinleri

MKR başlık pinleri:

• VIN — kart üzerindeki PMIC’e giden ana sistem hattı. +5V hattından, MKR VIN pininden veya alttaki 80 pinli HD konektörlerinden bir diyot aracılığıyla beslenir.

• +5V — USB’den, ESLOV konektöründen veya MKR +5V pininin kendisinden beslenen 5 V hattı.

• +3V3 — ana 3.3 V hattı (PMIC anahtarlamalı regülatör çıkışı).

• AREF — ADC pinleri için analog gerilim referansı. Varsayılan olarak 3.3 V’dur; farklı bir referans kullanmak için harici olarak sürün.

• GND — ortak topraklama.

Pil girişi:

• Kartın ön tarafındaki Li‑Po JST, 3.7 V’luk bir Li‑Po hücresini kabul eder. +5V veya VIN mevcut olduğunda PMIC bunu şarj eder.

Portenta H7, bu yolların herhangi biri üzerinden güçlendirilebilir:

• USB‑C — kart üzerindeki PMIC’e 5 V sağlar.

• ESLOV konektörü — VESLOV üzerinde 5 V’a kadar (bkz. ESLOV konektörü).

• VIN pini — doğrudan regüle edilmiş 5 V’luk bir kaynak sürün.

• Li‑Po pil — ön taraftaki JST’ye bağlayın.

ESLOV konektörü

Kartın yan tarafında lehimsiz 5 pinli bir ESLOV konektörü bulunur:

Pin	Ad	İşlev
1	VESLOV	5 V güç çıkışı (MKR başlığının +5V ile aynı hat)
2	INT	D7 üzerindeki harici kesme girişi
3	SCL_EXT	MKR başlığının D12 pedi ile paylaşılır — kullanıcı başlığıyla aynı I²C 3 veri yolu
4	SDA_EXT	MKR başlığının D11 pedi ile paylaşılır — kullanıcı başlığıyla aynı I²C 3 veri yolu
5	GND	ortak topraklama

ESLOV’un SCL_EXT/SDA_EXT pinleri ve MKR başlığının D12/D11 pinleri aynı pinlerdir — iki konektörde açığa çıkarılan tek bir I²C 3 veri yolu.

Tüyo

Portenta H7’nin belirli bir aktif / derin uyku görev döngüsünde bir pille ne kadar süre çalışacağını modellemek için pil ömrü tahmincisini kullanın.

Kurtarma ve hata ayıklama pinleri

• RESET — hem üst başlıkta açığa çıkarılmış bir pin hem de kartın yan tarafında SoC’nin NRST hattına bağlı anlık bir anahtar. Sıfırlamak için GND’ye çekin veya düğmeye basın.

Portenta H7, Arduino’nun önyükleyicisine (bootloader) girmek için Arduino’nun standart çift dokunuşla sıfırlama yöntemini kullanır. Sıfırlama düğmesine hızlıca iki kez basın — kart, USB üzerinden bir DFU aygıtı olarak yeniden numaralandırılır ve OpenMV IDE yeni bir aygıt yazılımı imajı yükleyebilir.

STM32 SWD sinyalleri alttaki HD konektörü J1 üzerinde açığa çıkarılır:

• J1‑73 — NRST

• J1‑75 — SWDIO (PA13)

• J1‑77 — SWCLK (PA14)

• J1‑79 — SWO (PB3)

Bunları bir Portenta Breakout, resmi Arduino hata ayıklama adaptörü veya 1.27 mm başlıklı özel bir taşıyıcı aracılığıyla bağlayın. Tüm hata ayıklama sinyalleri 3.3 V referanslıdır.

Not

Portenta Vision Shield takılıyken, aynı SWD/JTAG sinyalleri kalkan üzerindeki standart 20 pinli ARM Cortex Debug JTAG başlığına (1.27 mm / 0.05″ adım) yönlendirilir.

Kart üzeri çevre birimleri

LED’ler

Portenta H7, machine.LED aracılığıyla yazılımdan kontrol edilebilen tek bir kullanıcı RGB LED’ine sahiptir:

from machine import LED

LED("LED_RED").on()
LED("LED_GREEN").on()
LED("LED_BLUE").on()

Pil JST’sinin yanındaki ayrı turuncu şarj LED’i, kart üzerindeki şarj cihazı bağlı bir Li‑Po’ya akım sağladığında yanar; kullanıcı tarafından kontrol edilemez.

Kamera sensörü (Vision Shield)

Portenta Vision Shield (Ethernet veya LoRa sürümü) takılıyken, Himax sensörü csi — kamera sensörleri modülü aracılığıyla sürülür:

import csi

cam = csi.CSI()
cam.reset()
cam.pixformat(csi.GRAYSCALE)
cam.framesize(csi.QVGA)
cam.snapshot(time=2000)       # let auto‑exposure settle

while True:
    img = cam.snapshot()

İki Vision Shield revizyonu desteklenir:

• HM01B0 — 320 × 320 tek renk.

• HM0360 — 640 × 480 tek renk.

Uyarı

Vision Shield kamerası başlatıldığında, aşağıdaki MKR başlık pinleri aygıt yazılımı tarafından sahiplenilir ve kullanılamaz:

MKR pini	Neden
D1	TIM1 CH1 — kamera ana saati
D6	TIM1 CH1 (alt) — kamera ana saati
D11	I²C 3 SDA — kamerayla paylaşılır; veri yolu kullanılabilir ancak sensörün I²C adresinden (0x24) kaçının
D12	I²C 3 SCL — kamerayla paylaşılır; veri yolu kullanılabilir ancak sensörün I²C adresinden (0x24) kaçının
A6 / D21	DCMI HSYNC — ayrıca DAC’ı devre dışı bırakır
A7	DCMI PXCLK

Makine öğrenmesi

ml — Makine Öğrenmesi, kuantize edilmiş TFLite modellerini CMSIS‑NN çekirdekleriyle Cortex‑M7 üzerinde çalıştırır — saniyede birkaç kare hızında kompakt tespit edicileri çalıştıracak kadar hızlıdır. Salt okunur /rom dosya sistemindeki modeller, RAM’e kopyalanmadan doğrudan flash bellekten yüklenir. İşte Vision Shield kamerasından gelen her karede tespit edilen yüzü ve altı işaret noktasını üzerine bindiren 128×128’lik bir BlazeFace tespit edicisi:

import csi
import time
import ml
from ml.postprocessing.mediapipe import BlazeFace

# Initialize the sensor.
csi0 = csi.CSI()
csi0.reset()
csi0.pixformat(csi.GRAYSCALE)
csi0.framesize(csi.QVGA)
csi0.window((240, 240))

# Load built-in face detection model
model = ml.Model("/rom/blazeface_front_128.tflite", postprocess=BlazeFace(threshold=0.4))
print(model)

clock = time.clock()
while True:
    clock.tick()
    img = csi0.snapshot()

    # faces is a list of ((x, y, w, h), score, keypoints) tuples
    for r, score, keypoints in model.predict([img]):
        ml.utils.draw_predictions(img, [r], ("face",), ((0, 0, 255),), format=None)

        # keypoints is a ndarray of shape (6, 2)
        ml.utils.draw_keypoints(img, keypoints, color=(255, 0, 0))

    print(clock.fps(), "fps")

M4 çekirdeği

Cortex‑M4 çekirdeği, işlemciler arası iletişim için openamp aracılığıyla açığa çıkarılır. OpenMV aygıt yazılımı yalnızca M7 üzerinde çalışır; M4’ün kendine ait bir MicroPython çalışma zamanı yoktur, bu nedenle onu kullanmak ayrı bir C aygıt yazılımı imajı oluşturmak ve bunu dosya sisteminden openamp.RemoteProc aracılığıyla yüklemek anlamına gelir. Sanal bir UART uç noktası uygulayan önceden oluşturulmuş örnek aygıt yazılımı openamp_vuart deposunda mevcuttur — vuart.elf dosyasını oluşturmak için README dosyasını izleyin:

import openamp
import time

def ept_recv_callback(src_addr, data):
    print("Received:", data.decode())

ept = openamp.Endpoint("vuart-channel", callback=ept_recv_callback)

rproc = openamp.RemoteProc("vuart.elf")
rproc.start()

count = 0
while True:
    if ept.is_ready():
        ept.send("Hello World %d!" % count, timeout=1000)
        count += 1
    time.sleep_ms(1000)

Uygulamada bu destek, çalışan bir çift çekirdekli platformdan ziyade openamp arayüzünün bir gösterimi olarak değerlendirilmesi daha uygundur — M4, M7’den bağımsız olarak sıfırlanamaz, bu nedenle M4’ü durdurmak tam bir sistem yeniden başlatmasına neden olur.

Mikrofon (Vision Shield)

Vision Shield, STM32’nin SAI4 çevre birimi üzerinden audio — Audio Modülü aracılığıyla yakalanan çift PDM mikrofon taşır. Her arabellek, DSP için ulab/numpy ile beslenmeye hazır, işaretli 16 bit PCM bytearray olarak gelir — örneğin, basit bir ses yüksekliği tespit edicisi:

import audio
from ulab import numpy as np

def loudness(pcmbuf):
    samples = np.array(np.frombuffer(pcmbuf, dtype=np.int16), dtype=np.float)
    rms = np.sqrt(np.mean(samples ** 2))
    if rms > 10000:
        print("Loud!", int(rms))

audio.init(channels=1, frequency=16000, gain_db=24)
audio.start_streaming(loudness)

while True:
    pass

Her iki mikrofondan da iç içe geçmiş örnekleri almak için audio.init fonksiyonuna channels=2 parametresini geçirin.

Pil şarj göstergesi

Maxim MAX17262 ModelGauge m5 şarj göstergesi, Li‑Po pilin gerilimini, akımını, sıcaklığını ve şarj durumunu izler. I²C 1 üzerinde 0x36 adresinde bulunur.

MAX17262 dahili akım algılamaya sahiptir, bu nedenle akım yazmacı, uygulanacak harici bir Rsense faktörü olmadan doğrudan mikroamper cinsinden okunur. Şarj göstergesini okumak zararsızdır — birlikte verilen bir sürücü yoktur, ancak MAX17262 veri sayfasında belgelenen yazmaçlar doğrudan okunabilir:

import time
import struct
from machine import I2C

FUEL_GAUGE = 0x36   # MAX17262

def read_reg(bus, addr, reg):
    return struct.unpack("<H", bus.readfrom_mem(addr, reg, 2))[0]

def read_signed(bus, addr, reg):
    v = read_reg(bus, addr, reg)
    return v - 0x10000 if v & 0x8000 else v

bus = I2C(1)

while True:
    # 0x05 RepCap — remaining capacity, raw × 0.5 mAh
    rep_cap   = read_reg(bus, FUEL_GAUGE, 0x05) * 0.5
    # 0x06 RepSOC — state of charge, raw / 256 %
    soc       = read_reg(bus, FUEL_GAUGE, 0x06) / 256
    # 0x08 Temp — die temperature, signed, raw / 256 °C
    temp      = read_signed(bus, FUEL_GAUGE, 0x08) / 256
    # 0x09 VCell — battery voltage, raw × 78.125 µV
    vcell     = read_reg(bus, FUEL_GAUGE, 0x09) * 78.125 / 1_000_000
    # 0x0A Current — signed, raw × 156.25 µA
    current   = read_signed(bus, FUEL_GAUGE, 0x0A) * 156.25 / 1000
    # 0x0B AvgCurrent — averaged current
    avg_curr  = read_signed(bus, FUEL_GAUGE, 0x0B) * 156.25 / 1000
    # 0x10 FullCapRep — learned full capacity, raw × 0.5 mAh
    full_cap  = read_reg(bus, FUEL_GAUGE, 0x10) * 0.5
    # 0x11 TTE — time-to-empty (valid while discharging), raw × 5.625 s
    tte_s     = read_reg(bus, FUEL_GAUGE, 0x11) * 5.625
    # 0x20 TTF — time-to-full   (valid while charging),  raw × 5.625 s
    ttf_s     = read_reg(bus, FUEL_GAUGE, 0x20) * 5.625
    # 0x17 Cycles — charge-cycle counter, 1% per LSB
    cycles    = read_reg(bus, FUEL_GAUGE, 0x17) / 100

    print("V:        %.3f V" % vcell)
    print("Capacity: %.1f / %.1f mAh (%.1f %%)" % (rep_cap, full_cap, soc))
    print("Temp:     %.1f C" % temp)
    print("Current:  %.1f mA  (avg %.1f mA)" % (current, avg_curr))
    print("TTE:      %.0f s   TTF: %.0f s" % (tte_s, ttf_s))
    print("Cycles:   %.2f" % cycles)
    print()
    time.sleep_ms(1000)

Current işaretli ikiye tümleyendir: şarj olurken pozitif, deşarj olurken negatiftir. TTE yalnızca akım negatifken anlamlıdır; TTF ise yalnızca akım pozitifken.

Güç yönetimi IC’si

NXP PF1550 PMIC, Portenta H7 üzerindeki her regülatörü yönetir — +3V3 ana hattı, +1V8 SoC çekirdeği / I/O hattı ve Li‑Po şarj cihazı. I²C 1 üzerinde 0x08 adresinde bulunur.

Uyarı

PMIC yazmaçlarını okumak sorun değildir; onlara yazmak tehlikelidir. Bir buck regülatörünü veya şarj cihazı ayarını yanlış yapılandırmak kartı, pili veya her ikisini de kalıcı olarak hasara uğratabilir. Ne yaptığınızı tam olarak bilmiyorsanız PMIC’i salt okunur olarak değerlendirin.

PMIC’in size söylediği, şarj göstergesinin söyleyemediği en yararlı şey şarj cihazı durum makinesidir — kartın şu anda USB / ESLOV / VIN üzerinden çalışıp çalışmadığı, Li‑Po’nun şarj döngüsünün hangi aşamasında olduğu ve şarj cihazının bir termal veya bekçi köpeği hatasında olup olmadığı. Şarj cihazı yazmaçları, PF1550’nin ana I²C adres alanında 0x80 ofsetinde bulunur (bkz. PF1550 veri sayfası §22.2), bu nedenle örneğin şarj cihazı adresi 0x04‘teki CHG_INT_OK, PMIC yazmacı 0x84‘ten okunur:

import time
from machine import I2C

PMIC = 0x08

# Charger state machine (low nibble of CHG_SNS, register 0x87)
CHG_STATES = {
    0x0: "precharge",
    0x1: "fast charge (constant current)",
    0x2: "fast charge (constant voltage)",
    0x3: "end of charge",
    0x4: "done",
    0x6: "timer fault",
    0x7: "thermistor suspend",
    0x8: "off — input invalid or charger disabled",
    0x9: "battery overvoltage",
    0xA: "thermal shutdown",
    0xC: "linear mode (not charging)",
}

bus = I2C(1)

while True:
    # 0x84 CHG_INT_OK — single-bit indicators
    ok = bus.readfrom_mem(PMIC, 0x84, 1)[0]
    vbus_ok = bool(ok & (1 << 5))   # bit 5 — VBUS valid (USB/VIN)
    bat_ok  = bool(ok & (1 << 2))   # bit 2 — battery OK
    chg_ok  = bool(ok & (1 << 3))   # bit 3 — charger actively charging
    thm_ok  = bool(ok & (1 << 7))   # bit 7 — thermistor in normal range

    # 0x87 CHG_SNS — charger state + thermal regulation flag
    chg_sns = bus.readfrom_mem(PMIC, 0x87, 1)[0]
    state   = CHG_STATES.get(chg_sns & 0x0F, "reserved")
    treg    = bool(chg_sns & (1 << 7))   # thermal regulation active

    print("VBUS valid:         ", vbus_ok)
    print("battery OK:         ", bat_ok)
    print("charger active:     ", chg_ok)
    print("thermistor normal:  ", thm_ok)
    print("thermal reg active: ", treg)
    print("state:              ", state)
    print()
    time.sleep_ms(1000)

Veri sayfasında incelemeye değer diğer salt okunur yazmaçlar (tümü şarj cihazı ofseti 0x80‘de): 0x80 CHG_INT (mandallanmış şarj cihazı kesmeleri — hata bayrakları), 0x86 VBUS_SNS (OVLO / UVLO / DPM dahil çok bitli VBUS durumu) ve 0x88 BATT_SNS (pil varlığı ve aşırı akım durumu).

Wi‑Fi

Kart üzerindeki Murata 1DX (CYW4343W), network — ağ yapılandırması aracılığıyla bir istasyon arayüzü olarak açığa çıkarılır. Radyoyu çalıştırmadan önce birlikte verilen anteni kart üzerindeki U.FL konektörüne bağlayın:

import network, time

wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect("ssid", "password")
while not wlan.isconnected():
    time.sleep(1)
print("Wi‑Fi IP:", wlan.ipconfig("addr4")[0])

Bluetooth

Aynı Murata 1DX ayrıca Bluetooth LE 5.1’i de açığa çıkarır. asyncio dostu BLE için aioble — Asenkron BLE kullanın — örneğin, bir çevre birimi olarak reklam yapın ve bir merkezi cihazın bağlanmasını bekleyin:

import asyncio
import aioble

async def run():
    while True:
        conn = await aioble.advertise(250_000, name="Portenta-H7")
        print("Connected:", conn.device)
        await conn.disconnected()

asyncio.run(run())

LoRa (Vision Shield)

Vision Shield’in LoRa sürümü, Portenta H7’ye UART üzerinden bağlı bir Murata CMWX1ZZABZ LoRaWAN modülü ekler. lora modülü, AT komutu aygıt yazılımını sarmalar ve OTAA veya ABP katılımı, yukarı bağlantı ve aşağı bağlantıyı destekler:

from lora import Lora
from lora import BAND_EU868
from lora import LoraErrorTimeout

lora = Lora(band=BAND_EU868, poll_ms=60000)
print("Device EUI:", lora.get_device_eui())

appEui = "1234567890123456"
appKey = "12345678901234567890123456789012"

try:
    lora.join_OTAA(appEui, appKey)
except LoraErrorTimeout as e:
    print("Join timed out — try moving near a window:", e)

lora.set_port(3)
lora.send_data("HeLoRA world!", True)

while True:
    if lora.available():
        data = lora.receive_data()
        if data:
            print("Port:", data["port"], "Data:", data["data"])
    lora.poll()

AB dışı bölgeler için BAND_US915 / BAND_AS923 / BAND_AU915 vb. kullanın ve ağ sunucunuz ABP etkinleştirmesi kullanıyorsa lora.Lora.join_ABP() yöntemine geçin.

Uyarı

LoRa modülü kullanımdayken, sürücü aşağıdaki MKR başlık pinlerini Murata CMWX1ZZABZ için kontrol hatları olarak sahiplenir — bunlar kullanılamaz:

MKR pini	Neden
D3	LoRa modülü BOOT pini
D5	LoRa modülü RST pini

Ethernet (Vision Shield)

Vision Shield’in Ethernet sürümü, STM32H747’nin 10/100 Ethernet MAC’ine RMII üzerinden bağlı manyetiklere sahip bir RJ45 jakı ekler. Bir Ethernet kablosu takın; PHY bir LAN arayüzü olarak görünür; bağlantı kurulduğunda DHCP otomatik olarak çalışır:

import network
import time

lan = network.LAN()
lan.active(True)
while not lan.isconnected():
    time.sleep(1)
print("Ethernet IP:", lan.ipconfig("addr4")[0])

microSD kart (Vision Shield)

Bir kart takıldığında otomatik olarak /sdcard konumuna bağlanır ve normal dosya sistemi aracılığıyla kullanılabilir:

import os

for entry in os.listdir("/sdcard"):
    print(entry)

Veri yolu referansı

GPIO

Serigrafili pinlerden herhangi birini okumak veya sürmek için machine.Pin kullanın. Çıkışlar 3.3 V CMOS’tur ve pin başına 20 mA’ya kadar (tüm başlık genelinde toplam 140 mA) çekebilir/kaynak sağlayabilir.

from machine import Pin

out = Pin("D0", Pin.OUT)
out.on()
out.off()
out.value(1)

inp = Pin("D1", Pin.IN, Pin.PULL_UP)
print(inp.value())

Herhangi bir giriş pini ayrıca kenar geçişlerinde bir kesme tetikleyebilir:

def handler(pin):
    print("triggered:", pin)

Pin("D1", Pin.IN, Pin.PULL_UP).irq(
    handler, Pin.IRQ_FALLING | Pin.IRQ_RISING,
)

UART

Veri yolu	TX	RX
UART1	D14	D13
UART6	D5	D4

from machine import UART

uart = UART(1, baudrate=115200)
uart.write("hello")
uart.read(5)

I²C

Veri yolu	SCL	SDA
I2C3	D12	D11

from machine import I2C

i2c = I2C(3, freq=400_000)
i2c.scan()
i2c.writeto(0x76, b"hi")

MKR başlığındaki D11/D12 pedleri ve ESLOV konektörünün SDA_EXT/SCL_EXT pinleri aynı I²C 3 veri yoluna bağlanır — ESLOV pin dağılımı için yukarıdaki ESLOV konektörü bölümüne bakın.

Aynı donanım, bir bellek bölgesini başka bir I²C denetleyicisine açığa çıkarmak için machine.I2CTarget aracılığıyla hedef (slave) modunda da kullanılabilir:

from machine import I2CTarget

buf = bytearray(32)
target = I2CTarget(3, addr=0x42, mem=buf)

SPI

Veri yolu	MOSI	MISO	SCK	CS
SPI2	D8	D10	D9	D7

from machine import SPI
from machine import Pin

spi = SPI(2, baudrate=10_000_000)
cs = Pin("D7", Pin.OUT, value=1)   # CS is not driven by the SPI peripheral

cs.value(0)
spi.write(b"hello")
cs.value(1)

ADC

Portenta H7, A0–A7 üzerinde sekiz adet 12 bit ADC kanalı açığa çıkarır. Tümü 3.3 V referanslıdır — read_u16, pinde 0–3.3 V aralığında 0–65535 değerini döndürür:

from machine import ADC
import time

adc = ADC("A0")
while True:
    voltage = adc.read_u16() * 3.3 / 65535
    print(voltage)
    time.sleep_ms(100)

DAC

DAC1 (A6 / D21) üzerinde pyb.DAC aracılığıyla tek bir 12 bit DAC kanalı açığa çıkarılır:

from pyb import DAC

dac = DAC("DAC1")
dac.write(int(0.5 * 255))   # 8‑bit output, ~1.65 V

PWM

Pin	Zamanlayıcı / kanal
D0	TIM8 CH3N
D1	TIM1 CH1, TIM8 CH3N
D2	TIM1 CH2, TIM8 CH2N
D4	TIM3 CH2, TIM8 CH2
D5	TIM3 CH1, TIM8 CH1
D6	TIM1 CH1
D7	TIM5 CH4
D13	TIM1 CH3
D14	TIM1 CH2
A7	TIM3 CH1

Bunlardan herhangi birini machine.PWM aracılığıyla sürün:

from machine import Pin, PWM

pwm = PWM(Pin("D4"), freq=1_000, duty_u16=32768)

Not

Birkaç pin zamanlayıcı kanallarını paylaşır:

• TIM1 CH1, D1 ve D6 üzerindedir.

• TIM1 CH2, D2 ve D14 üzerindedir.

• TIM8 CH3N, D0 ve D1 üzerindedir.

Zamanlayıcı kanalı başına bir tüketici seçin.

Uyarı

Vision Shield csi — kamera sensörleri aracılığıyla başlatıldığında TIM1, kamera ana saati için ayrılmıştır — kamera aktifken D1, D2, D6, D13 ve D14 PWM ile sürülemez.

Yazılımla bit-banging yapılan veri yolları

Ekstra bir veri yoluna ihtiyacınız varsa machine.SoftI2C ve machine.SoftSPI herhangi bir GPIO üzerinde çalışır.

Termal sensör (kart dışı)

Aygıt yazılımı, harici olarak bağlanan termal görüntüleyiciler için fir — termal sensör sürücüsü (fir == far infrared) sürücüsünü içerir:

• MLX90621 — 16 × 4 IR dizisi

• MLX90640 — 32 × 24 IR dizisi

• MLX90641 — 16 × 12 IR dizisi

• AMG8833 — 8 × 8 IR dizisi

Modülü kartın I²C veri yoluna bağlayın ve fir.init() + fir.snapshot() ile kareleri okuyun:

import time
import image
import fir

fir.init()                          # auto‑detects the sensor
clock = time.clock()

while True:
    clock.tick()
    try:
        img = fir.snapshot(x_scale=5, y_scale=5,
                           color_palette=image.PALETTE_IRONBOW,
                           hint=image.BICUBIC,
                           copy_to_fb=True)
    except OSError:
        continue
    print(clock.fps())

fir sürücüsü sensörle yalnızca I²C 3 üzerinden iletişim kurar — modülü D12 (SCL) ve D11 (SDA) pinlerine bağlayın.

Zamanlama

time

time modülü; engelleyici gecikmeleri, monoton tıklamaları ve geçen süre ölçümünü kapsar:

import time

time.sleep(1)              # seconds
time.sleep_ms(500)
time.sleep_us(10)

start = time.ticks_ms()
# ...do work...
elapsed = time.ticks_diff(time.ticks_ms(), start)

Sanal zamanlayıcılar

machine.Timer, bir donanım zamanlayıcı yuvası tüketmeden periyodik veya tek seferlik geri çağırmalar (callback) zamanlar. Sanal (yazılımsal) bir zamanlayıcı kullanmak için id olarak -1 geçirin:

from machine import Timer

one_shot = Timer(-1)
one_shot.init(period=5_000, mode=Timer.ONE_SHOT,
              callback=lambda t: print("once"))

periodic = Timer(-1)
periodic.init(period=2_000, mode=Timer.PERIODIC,
              callback=lambda t: print("tick"))

Periyot değerleri milisaniye cinsindendir. Yuvayı durdurmak ve serbest bırakmak için deinit() çağırın.

Gerçek zamanlı saat

machine.RTC, sıfırlamalar arasında duvar saati zamanını korur. HD konektörü ayrıca, güç kaybı sırasında RTC’yi bir CR2032 ile besleyebilen bir COINCELL pedi açığa çıkarır:

from machine import RTC

rtc = RTC()
rtc.datetime((2026, 4, 30, 4, 12, 0, 0, 0))   # Y, M, D, weekday, h, m, s, subsec
print(rtc.datetime())

Bekçi köpeği

machine.WDT, uygulama takılırsa kartı sıfırlar. Başlatıldıktan sonra durdurulamaz veya yeniden yapılandırılamaz — ana döngünüzün içinde periyodik olarak besleyin:

from machine import WDT

wdt = WDT(timeout=5_000)   # 5 second window
while True:
    # ...do work...
    wdt.feed()

Önyükleme ve çalışma zamanı bilgileri

Aygıt yazılımı güncellemesi (DFU)

Portenta H7, Arduino’nun önyükleyicisine (bootloader) girmek için Arduino’nun standart çift dokunuşla sıfırlama yöntemini kullanır. Sıfırlama düğmesine hızlıca iki kez basın — kart, USB üzerinden bir DFU aygıtı olarak yeniden numaralandırılır ve OpenMV IDE yeni bir aygıt yazılımı imajı yükleyebilir.

Çalışan bir betik, machine.bootloader() çağrısıyla istek üzerine önyükleyiciye yeniden girebilir:

import machine

machine.bootloader()

Dosya sistemi ve önyükleme sırası

Portenta H7 aygıt yazılımı, önyüklemede en fazla üç dosya sistemini bağlar:

• Dahili flash bellek — her zaman /flash konumuna bağlanır. Varsayılan olarak main.py ve README.txt dosyalarını barındırır; ilk önyüklemede oluşturulur.

• microSD kart — bir Vision Shield takılıysa ve bir kart yerleştirilmişse, /sdcard konumuna bağlanır.

• ROMFS — başlangıçta MicroPython tarafından otomatik olarak /rom konumuna bağlanan salt okunur, belleğe eşlenmiş dosya sistemi.

Bağlamanın ardından, kart mevcutsa çalışma dizini /sdcard, aksi takdirde /flash olarak ayarlanır. Yorumlayıcı daha sonra betikleri o dizinden çalıştırır:

• boot.py, her yazılımsal sıfırlamada (soğuk önyükleme, REPL’den Ctrl‑D veya çalışan betiğin her döndüğünde) çalıştırılır.

• main.py, yalnızca soğuk önyüklemede, boot.py dosyasından hemen sonra çalıştırılır. Sonraki yazılımsal sıfırlamalar boot.py dosyasını yeniden çalıştırır ancak doğrudan REPL’e düşer — main.py dosyasını yeniden çalıştırmak için kartı tamamen sıfırlamanız gerekir.

SD karta bir boot.py veya main.py dosyası bırakmak, flash bellekteki kopyaya dokunmadan onu geçersiz kılar — her iki dosya da önyükleme dizininde (kart bağlıyken /sdcard, aksi takdirde /flash) aranır.

Yeni flaşlanmış bir kartta birlikte verilen varsayılan main.py, bir kalp atışı olarak yalnızca kullanıcı RGB LED’inin mavi kanalını yanıp söndürür (iki kısa darbe, kısa boşluk), böylece herhangi bir ana bilgisayar bağlı olmadan aygıt yazılımının temiz bir şekilde önyüklendiğini anlayabilirsiniz.

sys.path, her üç dosya sistemini ve onların lib/ alt dizinlerini içerecek şekilde genişletilir, böylece içe aktarılabilir modüller /flash/lib, /sdcard/lib veya /rom/lib içinde bulunabilir.

Sistemi takılı bir SD kartı yok saymaya zorlamak için (örneğin bir kart mevcut olsa bile flash main.py dosyasını çalıştırmak için), /flash kök dizininde SKIPSD adlı boş bir dosya oluşturun.

USB üzerinden bağlandığında, önyükleme dosya sistemi (kart mevcutsa /sdcard, aksi takdirde /flash) ayrıca ana bilgisayarda bir USB yığın depolama sürücüsü olarak numaralandırılır ve boot.py, main.py ile diğer dosyaları doğrudan düzenlemenize olanak tanır. Ana bilgisayarın önbelleğe alınmış yazmalarını boşaltması için kartı sıfırlamadan önce sürücüyü çıkarın.

Not

İşletim sistemi sürücüyü pasif bir blok aygıtı olarak değerlendirdiğinden, kamerada çalışan kod tarafından oluşturulan veya değiştirilen dosyalar, ana bilgisayar sürücüyü yeniden bağlayana kadar görünmez. Hem işletim sistemi hem de kamera aynı dosya sistemine aynı anda yazarsa, işletim sistemi kazanır ve kamera tarafından yapılan değişikliklerin üzerine yazar. Betiğin geri yazdığı veriler için SD kartı kullanın ve bu dosyaları ana bilgisayardan okumadan önce yeniden bağlayın.

Not

Ana bilgisayar USB yığın depolama sürücüsünden okurken veya ona yazarken kullanıcı RGB LED’inin kırmızı kanalı kısa bir süre yanabilir — bu bir hata değil, aygıt yazılımı tarafından yönlendirilen bir etkinlik göstergesidir.

Depolama boyutları

Portenta H7 şunlarla birlikte gelir:

• /flash — 11 MB FAT dosya sistemi, okuma/yazma.

• /rom — 4 MB salt okunur belleğe eşlenmiş ROMFS, sıfır kopyalı mmap erişiminden yararlanan betikleri ve ML modellerini sevk etmek için kullanılır.

• /sdcard — bir Vision Shield’e takılı microSD kartın tam boyutu (mevcut olduğunda), okuma/yazma.

Donanım hatası (hard fault) göstergesi

Kullanıcı RGB LED’i tüm renkler arasında hızla geçiş yapıyorsa — belirgin tonlardan ziyade bir parıldayan beyaz LED gibi görünecek kadar hızlı — aygıt yazılımı kurtarılamaz bir donanım hatasına (hard fault) ulaşmıştır. Kurtarmak için aygıt yazılımını yeniden flaşlayın; yeniden flaşlamak yardımcı olmazsa kart fiziksel olarak hasar görmüş olabilir.

Yazılım kütüphaneleri

Tüm modüllerin tam listesi için — Portenta H7 derlemesine özgü olanlar dahil — kütüphane dizinine bakın.