Arduino Portenta H7

Az Arduino Portenta H7 egy 66 × 25 mm-es ipari fejlesztőpanel, amely az STMicroelectronics STM32H747XI köré épül — ez egy kétmagos SoC, amely egy 400 MHz-es Cortex‑M7-et egyesít egy 200 MHz-es Cortex‑M4-gyel. Az OpenMV firmware teljes egészében az M7 magon fut, és úgy tervezték, hogy a Portenta Vision Shield (Ethernet vagy LoRa kiadás) kiegészítővel használják, amely egy Himax HM01B0 / HM0360 kamerát, két PDM mikrofont és egy microSD kártyahelyet ad az alap Portenta H7-hez.

A teljes adatlapért, fényképekért és méretekért lásd az Arduino Portenta H7 termékoldalt.

Kiemelt jellemzők

• STMicroelectronics STM32H747XI kétmagos Cortex‑M7 (400 MHz) + Cortex‑M4 (200 MHz). Az OpenMV firmware csak az M7 magon fut; az M4 mag a openamp modulon keresztül érhető el a processzorok közötti kommunikációhoz.

• 8 MB külső SDRAM valamint 2 MB belső flash memória és 16 MB külső QSPI flash memória.

• Hardveres JPEG kódoló/dekódoló.

• Wi‑Fi b/g/n (2,4 GHz) + Bluetooth LE 5.1 a Murata 1DX (CYW4343W) modulon keresztül — a mellékelt antennához egy panelre szerelt U.FL csatlakozón keresztül csatlakozik.

• Nagy sebességű USB‑C (480 Mb/s).

• 22 felhasználói I/O láb az Arduino MKR-stílusú felső tűsorokon — D0–D14 (digitális) plusz A0–A6 (analóg).

• Két 80 lábú, nagy sűrűségű csatlakozó az alján kivezeti a teljes STM32H747 felépítményt — DCMI, DSI, Ethernet RMII, FDCAN, SDIO, SAI/I²S, UART-ok, további SPI/I²C/időzítők és így tovább. Az olyan kiegészítők, mint a Vision Shield, ezekhez a csatlakozókhoz illeszkednek.

• JTAG / SWD az alsó HD csatlakozókon kivezetve a haladó hibakereséshez.

• Akkumulátortámogatás — 3,7 V-os Li‑Po JST csatlakozó valamint panelre szerelt töltő és akkumulátormonitor.

Lábkiosztás

Lábkiosztási referencia

22 felhasználói láb van kivezetve az Arduino MKR-stílusú felső peremtűsorokon — 15 digitális (D0-D14) plusz 7 analóg (A0-A6). Sokkal több SoC láb érhető el az alsó 80 lábú, nagy sűrűségű csatlakozókon keresztül a kiegészítőkhöz; ehhez a leképezéshez lásd az Arduino teljes lábkiosztási PDF-jét.

Láb neve	Referencia	Funkció
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 (megosztva A3 / A5 lábbal)
D9	3.3 V	SPI2 SCK
D10	3.3 V	SPI2 MISO (megosztva A2 / A4 lábbal)
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 (csak analóg)
A1	3.3 V	ADC12 IN1 (csak analóg)
A2	3.3 V	ADC123 IN12 (csak analóg; megosztva D10 lábbal)
A3	3.3 V	ADC12 IN13 (csak analóg; megosztva D8 lábbal)
A4	3.3 V	ADC123 IN12 (megosztva D10 lábbal)
A5	3.3 V	ADC12 IN13 (megosztva D8 lábbal)
A6	3.3 V	DAC1 OUT1 / ADC12 IN18
A7	3.3 V	TIM3 CH1 / ADC12 IN3 (a tűsorokon nincs kivezetve)
D20	3.3 V	a D8 / A3 / A5 aliasza
D21	3.3 V	az A6 aliasza — DAC1 OUT1
RESET	3.3 V	nyomd meg a panelre szerelt kapcsolót vagy húzd GND-re az alaphelyzetbe állításhoz
LED_RED	3.3 V	RGB LED vörös csatornája (aktív alacsony)
LED_GREEN	3.3 V	RGB LED zöld csatornája (aktív alacsony)
LED_BLUE	3.3 V	RGB LED kék csatornája (aktív alacsony)

Megjegyzés

Az A0-A3 csak analóg kivezetések az STM32H747-en, GPIO funkció nélkül — kezeld őket kizárólag ADC bemenetként. Az A2/A4 és az A3/A5 a fizikai lábaikat a D10 illetve a D8 lábbal osztják meg, így nem tudsz PWM-et vagy SPI-t vezérelni rajtuk, miközben analógként olvasod őket. Az A7 az alsó HD csatlakozókon található.

Tápláb

MKR tűsor lábai:

• VIN — a fő rendszersín a panelre szerelt PMIC-be. Egy diódán keresztül táplálva a +5V sínről, az MKR VIN lábról vagy az alsó 80 lábú HD csatlakozókról.

• +5V — 5 V-os sín, amelyet az USB, az ESLOV csatlakozó vagy maga az MKR +5V láb táplál.

• +3V3 — fő 3,3 V-os sín (a PMIC kapcsolóüzemű szabályozójának kimenete).

• AREF — analóg feszültségreferencia az ADC lábakhoz. Alapértelmezetten 3,3 V; kívülről hajtsd meg, ha más referenciát szeretnél használni.

• GND — közös föld.

Akkumulátor bemenet:

• A panel elején lévő Li‑Po JST egy 3,7 V-os Li‑Po cellát fogad. A PMIC tölti azt, amikor +5V vagy VIN jelen van.

A Portenta H7 az alábbi útvonalak bármelyikén keresztül táplálható:

• USB‑C — 5 V-ot szolgáltat a panelre szerelt PMIC-nek.

• ESLOV csatlakozó — legfeljebb 5 V a VESLOV lábon (lásd ESLOV csatlakozó).

• VIN láb — közvetlenül egy szabályozott 5 V-os tápot hajts meg.

• Li‑Po akkumulátor — csatlakoztasd az elülső JST-hez.

ESLOV csatlakozó

A panel oldalán egy 5 lábú, forrasztásmentes ESLOV csatlakozó található:

Láb	Név	Funkció
1	VESLOV	5 V-os tápkimenet (ugyanaz a sín, mint az MKR tűsor +5V lába)
2	INT	külső megszakítás bemenet a D7 lábon
3	SCL_EXT	megosztva az MKR tűsor D12 kivezetésével — ugyanaz az I²C 3 busz, mint a felhasználói tűsoron
4	SDA_EXT	megosztva az MKR tűsor D11 kivezetésével — ugyanaz az I²C 3 busz, mint a felhasználói tűsoron
5	GND	közös föld

Az ESLOV SCL_EXT/SDA_EXT és az MKR tűsor D12/D11 lábai ugyanazok — egyetlen I²C 3 busz, két csatlakozón kivezetve.

Javaslat

Használd a akkumulátor-élettartam becslőt annak modellezésére, hogy a Portenta H7 egy adott aktív / mélyalvás kitöltési tényező mellett mennyi ideig fog működni akkumulátorról.

Helyreállítási és hibakeresési lábak

• RESET — egyrészt egy kivezetett láb a felső tűsoron, másrészt egy pillanatkapcsoló a panel oldalán, mindkettő a SoC NRST vonalához kötve. Húzd GND-re vagy nyomd meg a gombot az alaphelyzetbe állításhoz.

A Portenta H7 az Arduino szabványos dupla koppintásos resetjét használja az Arduino rendszerbetöltőjébe való belépéshez. Nyomd meg gyorsan kétszer a reset gombot — a panel DFU eszközként újra felsorolódik az USB-n, és az OpenMV IDE új firmware-képet tud flashelni.

Az STM32 SWD jeleit az alsó HD csatlakozó J1 vezeti ki:

• J1‑73 — NRST

• J1‑75 — SWDIO (PA13)

• J1‑77 — SWCLK (PA14)

• J1‑79 — SWO (PB3)

Vezetékezd be őket egy Portenta Breakouton, a hivatalos Arduino hibakereső adapteren vagy egy 1,27 mm-es tűsorral ellátott egyedi hordozópanelen keresztül. Minden hibakeresési jel 3,3 V-ra referált.

Megjegyzés

Amikor a Portenta Vision Shield csatlakoztatva van, ugyanazok az SWD/JTAG jelek a kiegészítőn lévő szabványos 20 lábú ARM Cortex Debug JTAG tűsorra vannak vezetve (1,27 mm / 0,05″ osztás).

Panelre szerelt perifériák

LED-ek

A Portenta H7 egyetlen felhasználói RGB LED-del rendelkezik, amely szoftveresen vezérelhető a machine.LED segítségével:

from machine import LED

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

Egy különálló narancssárga töltés LED az akkumulátor JST mellett akkor világít, amikor a panelre szerelt töltő áramot táplál egy csatlakoztatott Li‑Po cellába; ez nem felhasználó által vezérelhető.

Kamera-érzékelő (Vision Shield)

A csatlakoztatott Portenta Vision Shield (Ethernet vagy LoRa kiadás) esetén a Himax érzékelő a csi — kameraérzékelők modulon keresztül vezérelhető:

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()

Két Vision Shield változat támogatott:

• HM01B0 — 320 × 320 monokróm.

• HM0360 — 640 × 480 monokróm.

Figyelem

Amíg a Vision Shield kamera inicializálva van, az alábbi MKR tűsor lábakat a firmware lefoglalja, és nem használhatók:

MKR láb	Ok
D1	TIM1 CH1 — kamera mesterórajel
D6	TIM1 CH1 (alt) — kamera mesterórajel
D11	I²C 3 SDA — megosztva a kamerával; a busz használható, de kerüld az érzékelő I²C címét (0x24)
D12	I²C 3 SCL — megosztva a kamerával; a busz használható, de kerüld az érzékelő I²C címét (0x24)
A6 / D21	DCMI HSYNC — egyúttal letiltja a DAC-ot
A7	DCMI PXCLK

Gépi tanulás

A ml — Gépi tanulás kvantált TFLite modelleket futtat a Cortex‑M7-en CMSIS‑NN kernelekkel — elég gyorsan ahhoz, hogy kompakt detektorokat néhány képkocka/másodperc sebességgel futtasson. A csak olvasható /rom fájlrendszeren lévő modellek közvetlenül a flash memóriából töltődnek be, RAM-ba másolás nélkül. Íme egy 128×128-as BlazeFace detektor, amely az észlelt arcot és annak hat jellemzőpontját rávetíti a Vision Shield kamera minden képkockájára:

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 mag

A Cortex‑M4 mag a openamp modulon keresztül érhető el a processzorok közötti kommunikációhoz. Az OpenMV firmware csak az M7-en fut; az M4-nek nincs saját MicroPython futtatókörnyezete, így a használata azt jelenti, hogy külön C firmware-képet kell készíteni és azt a fájlrendszerből betölteni az openamp.RemoteProc segítségével. Egy előre elkészített példa firmware, amely egy virtuális UART végpontot valósít meg, elérhető az openamp_vuart tárolóban — kövesd a README-jét a vuart.elf elkészítéséhez:

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)

A gyakorlatban ezt a támogatást leginkább az openamp interfész demonstrációjának érdemes tekinteni, nem pedig működő kétmagos platformnak — az M4 nem állítható alaphelyzetbe az M7-től függetlenül, így az M4 leállítása a teljes rendszer újraindítását kényszeríti ki.

Mikrofon (Vision Shield)

A Vision Shield két PDM mikrofont hordoz, amelyeket a audio — Audio modul segítségével rögzít az STM32 SAI4 perifériáján keresztül. Minden puffer előjeles 16 bites PCM bytearray formában érkezik, készen arra, hogy betápláld a ulab/numpy modulba DSP-hez — például egy egyszerű hangerő-érzékelőhöz:

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

Add át a channels=2 paramétert az audio.init függvénynek, hogy mindkét mikrofonból egymásba fűzött mintákat kapj.

Akkumulátor töltöttségmérő

A Maxim MAX17262 ModelGauge m5 töltöttségmérő követi a Li‑Po akkumulátor feszültségét, áramát, hőmérsékletét és töltöttségi állapotát. Az I²C 1 buszon helyezkedik el a 0x36 címen.

A MAX17262 belső árammérővel rendelkezik, így az áramregiszter közvetlenül mikroamperben olvasható ki, külső Rsense tényező alkalmazása nélkül. A töltöttségmérő olvasása ártalmatlan — nincs hozzá szállított illesztőprogram, de a MAX17262 adatlapban dokumentált regiszterek közvetlenül olvashatók:

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)

A Current előjeles kettes komplemensű érték: pozitív töltés közben, negatív kisütés közben. A TTE csak akkor értelmes, amikor az áram negatív; a TTF csak akkor, amikor az áram pozitív.

Energiagazdálkodási IC

Az NXP PF1550 PMIC kezeli a Portenta H7 összes szabályozóját — a +3V3 fő sínt, a +1V8 SoC mag / I/O sínt és a Li‑Po töltőt. Az I²C 1 buszon helyezkedik el a 0x08 címen.

Figyelem

A PMIC regiszterek olvasása rendben van; az írásuk viszont veszélyes. Egy buck szabályozó vagy töltőbeállítás hibás konfigurálása maradandóan károsíthatja a panelt, az akkumulátort vagy mindkettőt. Kezeld a PMIC-et csak olvashatóként, hacsak nem tudod pontosan, mit csinálsz.

A leghasznosabb dolog, amit a PMIC elárul, és amit a töltöttségmérő nem tud, a töltő állapotgépe — hogy a panel jelenleg USB-ről / ESLOV-ról / VIN-ről fut-e, a Li‑Po a töltési ciklus melyik szakaszában van, és hogy a töltő termikus vagy watchdog hibában van-e. A töltő regiszterei a PF1550 fő I²C címterében 0x80 eltolással helyezkednek el (lásd a PF1550 adatlap 22.2. szakaszát), így például a 0x04 töltőcímen lévő CHG_INT_OK a PMIC 0x84 regiszteréből olvasható:

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)

További, az adatlapban érdemes megnézendő, csak olvasható regiszterek (mind 0x80 töltő-eltolással): 0x80 CHG_INT (rögzített töltő megszakítások — hibajelzők), 0x86 VBUS_SNS (a többbites VBUS állapot, beleértve az OVLO / UVLO / DPM értékeket) és 0x88 BATT_SNS (akkumulátor jelenléte és túláram állapota).

Wi‑Fi

A panelre szerelt Murata 1DX (CYW4343W) a network — hálózati konfiguráció modulon keresztül érhető el állomás (station) interfészként. Csatlakoztasd a mellékelt antennát a panelre szerelt U.FL csatlakozóhoz, mielőtt elindítod a rádiót:

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

Ugyanaz a Murata 1DX a Bluetooth LE 5.1-et is kivezeti. Használd az aioble — Aszinkron BLE modult az asyncio-barát BLE-hez — például hirdesd magad perifériaként, és várd, hogy egy központi eszköz csatlakozzon:

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)

A Vision Shield LoRa kiadása egy Murata CMWX1ZZABZ LoRaWAN modult ad hozzá, amely UART-on keresztül van a Portenta H7-hez vezetékezve. A lora modul becsomagolja az AT-parancsos firmware-t, és támogatja az OTAA vagy ABP csatlakozást, a feltöltést és a letöltést:

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()

Használd a BAND_US915 / BAND_AS923 / BAND_AU915 stb. értékeket az EU-n kívüli régiókhoz, és válts a lora.Lora.join_ABP() metódusra, ha a hálózati kiszolgálód ABP aktiválást használ.

Figyelem

Amíg a LoRa modul használatban van, az illesztőprogram az alábbi MKR tűsor lábakat foglalja le vezérlővonalakként a Murata CMWX1ZZABZ számára — ezek nem használhatók:

MKR láb	Ok
D3	LoRa modul BOOT lába
D5	LoRa modul RST lába

Ethernet (Vision Shield)

A Vision Shield Ethernet kiadása egy RJ45 csatlakozót ad hozzá mágnesekkel, amely az STM32H747 10/100 Ethernet MAC-jához van vezetékezve RMII-n keresztül. Dugj be egy Ethernet kábelt, és a PHY LAN interfészként jelenik meg; a DHCP automatikusan lefut, amint a kapcsolat létrejön:

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 kártya (Vision Shield)

Amikor egy kártyát behelyezel, az automatikusan felcsatolódik a /sdcard helyre, és a szokásos fájlrendszeren keresztül használható:

import os

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

Buszreferencia

GPIO

Használd a machine.Pin osztályt bármelyik szitanyomott láb olvasásához vagy meghajtásához. A kimenetek 3,3 V-os CMOS szintűek, és lábanként legfeljebb 20 mA-t tudnak nyelni/forrásolni (a teljes tűsoron összesen 140 mA).

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())

Bármelyik bemeneti láb megszakítást is kiválthat élváltásokkor:

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

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

UART

Busz	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

Busz	SCL	SDA
I2C3	D12	D11

from machine import I2C

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

Az MKR tűsor D11/D12 kivezetései és az ESLOV csatlakozó SDA_EXT/SCL_EXT lábai ugyanarra az I²C 3 buszra futnak — az ESLOV lábkiosztásához lásd a fenti ESLOV csatlakozó részt.

Ugyanaz a hardver cél (slave) módban is használható a machine.I2CTarget segítségével, hogy egy memóriaterületet egy másik I²C vezérlő számára tegyen elérhetővé:

from machine import I2CTarget

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

SPI

Busz	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

A Portenta H7 nyolc 12 bites ADC csatornát vezet ki az A0–A7 lábakon. Mindegyik 3,3 V-ra referált — a read_u16 0–65535 értéket ad vissza a 0–3,3 V tartományban a lábon:

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

Egyetlen 12 bites DAC csatorna van kivezetve a DAC1-en (A6 / D21) a pyb.DAC osztályon keresztül:

from pyb import DAC

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

PWM

Láb	Időzítő / csatorna
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

Hajtsd meg bármelyiket a machine.PWM segítségével:

from machine import Pin, PWM

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

Megjegyzés

Több láb is osztozik időzítő-csatornákon:

• A TIM1 CH1 a D1 és a D6 lábon van.

• A TIM1 CH2 a D2 és a D14 lábon van.

• A TIM8 CH3N a D0 és a D1 lábon van.

Válassz egyetlen fogyasztót időzítő-csatornánként.

Figyelem

A TIM1 a kamera mesterórajel számára van fenntartva, amikor a Vision Shield a csi — kameraérzékelők modulon keresztül inicializálódik — a D1, D2, D6, D13 és D14 lábak nem hajthatók meg PWM-mel, amíg a kamera aktív.

Szoftveresen kapcsolgatott (bit‑banged) buszok

A machine.SoftI2C és a machine.SoftSPI bármely GPIO-n működik, ha egy extra buszra van szükséged.

Hőérzékelő (paneltől különálló)

A firmware tartalmazza a fir — hőérzékelő-meghajtó (fir == far infrared, távoli infravörös) illesztőprogramot a kívülről bekötött hőkamerákhoz:

• MLX90621 — 16 × 4 IR tömb

• MLX90640 — 32 × 24 IR tömb

• MLX90641 — 16 × 12 IR tömb

• AMG8833 — 8 × 8 IR tömb

Vezetékezd a modult a panel I²C buszára, és olvass be képkockákat a fir.init() + fir.snapshot() segítségével:

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())

A fir illesztőprogram csak az I²C 3 buszon kommunikál az érzékelővel — vezetékezd a modult a D12 (SCL) és a D11 (SDA) lábra.

Időzítés

time

A time modul lefedi a blokkoló késleltetéseket, a monoton ütemeket és az eltelt idő mérését:

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)

Virtuális időzítők

A machine.Timer periodikus vagy egyszeri visszahívásokat ütemez anélkül, hogy hardveres időzítő-helyet foglalna le. Add át a -1 értéket azonosítóként egy virtuális (szoftveres) időzítő használatához:

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"))

A periódusértékek ezredmásodpercben vannak megadva. Hívd meg a deinit() metódust a leállításhoz és a hely felszabadításához.

Valós idejű óra

A machine.RTC resetek között is megtartja a faliórán mért időt. A HD csatlakozó kivezet egy COINCELL kivezetést is, amely egy CR2032-ről táplálhatja az RTC-t áramkimaradás esetén:

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())

Watchdog

A machine.WDT alaphelyzetbe állítja a panelt, ha az alkalmazás lefagy. Az elindítása után nem állítható le és nem konfigurálható újra — periodikusan tápláld a fő ciklusodon belül:

from machine import WDT

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

Indítási és futásidejű információk

Firmware-frissítés (DFU)

A Portenta H7 az Arduino szabványos dupla koppintásos resetjét használja az Arduino rendszerbetöltőjébe való belépéshez. Nyomd meg gyorsan kétszer a reset gombot — a panel DFU eszközként újra felsorolódik az USB-n, és az OpenMV IDE új firmware-képet tud flashelni.

Egy futó szkript igény szerint újra beléphet a rendszerbetöltőbe a machine.bootloader() meghívásával:

import machine

machine.bootloader()

Fájlrendszer és indítási sorrend

A Portenta H7 firmware induláskor legfeljebb három fájlrendszert csatol fel:

• Belső flash memória — mindig a /flash helyre csatolva. Alapértelmezetten a main.py és a README.txt fájlokat tartalmazza; a legelső indításkor jön létre.

• microSD kártya — ha egy Vision Shield csatlakoztatva van és egy kártya be van helyezve, akkor a /sdcard helyre csatolódik.

• ROMFS — csak olvasható, memóriába leképezett fájlrendszer a /rom helyen, amelyet a MicroPython induláskor automatikusan felcsatol.

A felcsatolás után a munkakönyvtár a /sdcard lesz, ha a kártya jelen van, egyébként a /flash. Az értelmező ezután abból a könyvtárból futtatja a szkripteket:

• A boot.py minden szoftveres reset alkalmával lefut (hidegindítás, Ctrl‑D a REPL-ből, vagy amikor a futó szkript visszatér).

• A main.py csak hidegindításkor fut le, közvetlenül a boot.py után. A későbbi szoftveres resetek újrafuttatják a boot.py-t, de egyből a REPL-re ugranak — a main.py újrafuttatásához teljesen alaphelyzetbe kell állítanod a panelt.

Egy boot.py vagy main.py fájl SD kártyára helyezése felülírja a flash memóriában lévő példányt anélkül, hogy hozzányúlna — mindkét fájlt az indítási könyvtárban keresi a rendszer (/sdcard, amikor a kártya fel van csatolva, egyébként /flash).

A frissen flashelt panelen szállított alapértelmezett main.py csak a felhasználói RGB LED kék csatornáját villogtatja szívverésként (két rövid impulzus, rövid szünet), így anélkül is megtudhatod, hogy a firmware tisztán elindult-e, hogy bármilyen gazdagép csatlakoztatva lenne.

A sys.path kibővül, hogy mindhárom fájlrendszert és azok lib/ alkönyvtárait tartalmazza, így az importálható modulok élhetnek a /flash/lib, /sdcard/lib vagy /rom/lib helyen.

Ahhoz, hogy a rendszert egy behelyezett SD kártya figyelmen kívül hagyására kényszerítsd (például, hogy a flash main.py-t futtasd akkor is, ha kártya van jelen), hozz létre egy SKIPSD nevű üres fájlt a /flash gyökerében.

Amikor USB-n keresztül csatlakozik, az indítási fájlrendszer (/sdcard, ha kártya van jelen, egyébként /flash) USB háttértár-meghajtóként is felsorolódik a gazdagépen, lehetővé téve a boot.py, a main.py és bármely más fájl közvetlen szerkesztését. Vesd ki a meghajtót, mielőtt alaphelyzetbe állítod a panelt, hogy a gazdagép kiürítse a gyorsítótárazott írásokat.

Megjegyzés

Mivel az operációs rendszer a meghajtót passzív blokkeszközként kezeli, a kamerán futó kód által létrehozott vagy módosított fájlok nem jelennek meg, amíg a gazdagép újra fel nem csatolja a meghajtót. Ha az operációs rendszer és a kamera egyszerre írja ugyanazt a fájlrendszert, az operációs rendszer nyer, és felülírja a kamera által végrehajtott módosításokat. Használd az SD kártyát minden olyan adathoz, amit a szkript visszaír, és csatold fel újra, mielőtt ezeket a fájlokat a gazdagépről olvasnád.

Megjegyzés

A felhasználói RGB LED vörös csatornája röviden felvillanhat, amíg a gazdagép az USB háttértár-meghajtóról olvas vagy arra ír — ez egy firmware által vezérelt tevékenységjelző, nem hiba.

Tárolóméretek

A Portenta H7 az alábbiakkal érkezik:

• /flash — 11 MB FAT fájlrendszer, írható/olvasható.

• /rom — 4 MB csak olvasható, memóriába leképezett ROMFS, amelyet olyan szkriptek és ML modellek szállítására használnak, amelyek profitálnak a másolásmentes mmap hozzáférésből.

• /sdcard — a Vision Shieldbe behelyezett microSD kártya teljes mérete (ha jelen van), írható/olvasható.

Hard‑fault jelző

Ha a felhasználói RGB LED gyorsan végigfut az összes színen — elég gyorsan ahhoz, hogy inkább csillámló fehér LED-nek tűnjön, mint különálló árnyalatoknak —, akkor a firmware helyrehozhatatlan hard faultba ütközött. A helyreállításhoz flasheld újra a firmware-t; ha az újraflashelés nem segít, a panel fizikailag megsérülhetett.

Szoftverkönyvtárak

A modulok teljes listájáért lásd a könyvtárindexet — beleértve azt is, hogy melyikek egyediek a Portenta H7 buildhez.