Arduino Portenta H7¶

Arduino Portenta H7 on 66 × 25 mm:n teollisuuskäyttöön tarkoitettu kehitysalusta, joka rakentuu STMicroelectronicsin STM32H747XI:n ympärille — kaksiytiminen SoC, jossa yhdistyvät 400 MHz:n Cortex‑M7 ja 200 MHz:n Cortex‑M4. OpenMV‑laiteohjelmisto toimii kokonaan M7‑ytimellä ja on suunniteltu käytettäväksi Portenta Vision Shield ‑laajennuksen (Ethernet‑ tai LoRa‑versio) kanssa, joka lisää perus‑Portenta H7:ään Himax HM01B0 / HM0360 ‑kameran, kaksi PDM‑mikrofonia ja microSD‑paikan.

Täydellinen datalehti, kuvat ja mitat löytyvät Arduino Portenta H7 ‑tuotesivulta.

Kohokohdat¶

STMicroelectronics STM32H747XI kaksi ydintä Cortex‑M7 (400 MHz) + Cortex‑M4 (200 MHz). OpenMV‑laiteohjelmisto toimii vain M7‑ytimellä; M4‑ydin on käytettävissä openamp ‑rajapinnan kautta prosessorien väliseen viestintään.
8 Mt ulkoista SDRAM‑muistia sekä 2 Mt sisäistä flash‑muistia ja 16 Mt ulkoista QSPI flash‑muistia.
Laitteistopohjainen JPEG‑enkooderi/dekooderi.
Wi‑Fi b/g/n (2,4 GHz) + Bluetooth LE 5.1 Murata 1DX (CYW4343W) ‑moduulin kautta — kytkeytyy mukana toimitettuun antenniin piirilevyllä olevan U.FL‑liittimen kautta.
Suurnopeuksinen USB‑C (480 Mb/s).
22 käyttäjän I/O‑nastaa Arduino MKR‑tyylisissä yläosan riveissä — D0–D14 (digitaaliset) sekä A0–A6 (analogiset).
Kaksi 80‑nastaista korkean tiheyden liitintä pohjassa tuovat esiin koko STM32H747‑rakenteen — DCMI, DSI, Ethernet RMII, FDCAN, SDIO, SAI/I²S, UART‑väylät, lisää SPI/I²C/ajastimia ja niin edelleen. Vision Shieldin kaltaiset laajennukset kiinnittyvät näihin liittimiin.
JTAG / SWD on tuotu esiin pohjan HD‑liittimissä edistynyttä virheenkorjausta varten.
Akkutuki — 3,7 V Li‑Po JST‑liitin sekä piirilevyllä oleva laturi ja akkuvalvonta.

Nastajärjestys¶

Nastojen viiteopas¶

22 käyttäjän nastaa on tuotu esiin Arduino MKR‑tyylisissä yläreunan riveissä — 15 digitaalista (D0-D14) sekä 7 analogista (A0-A6). Paljon enemmän SoC‑nastoja on käytettävissä pohjan 80‑nastaisten korkean tiheyden liittimien kautta laajennustyöskentelyyn; katso tämä kytkentäkartta Arduinon täydellisestä nastajärjestys‑PDF:stä.

Nastan nimi	Viite	Toiminto
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 (jaettu A3:n / A5:n kanssa)
D9	3.3 V	SPI2 SCK
D10	3.3 V	SPI2 MISO (jaettu A2:n / A4:n kanssa)
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 (vain analoginen)
A1	3.3 V	ADC12 IN1 (vain analoginen)
A2	3.3 V	ADC123 IN12 (vain analoginen; jaettu D10:n kanssa)
A3	3.3 V	ADC12 IN13 (vain analoginen; jaettu D8:n kanssa)
A4	3.3 V	ADC123 IN12 (jaettu D10:n kanssa)
A5	3.3 V	ADC12 IN13 (jaettu D8:n kanssa)
A6	3.3 V	DAC1 OUT1 / ADC12 IN18
A7	3.3 V	TIM3 CH1 / ADC12 IN3 (ei tuotu esiin riveihin)
D20	3.3 V	`D8` / `A3` / `A5` ‑alias
D21	3.3 V	`A6` ‑alias — DAC1 OUT1
RESET	3.3 V	paina piirilevyllä olevaa kytkintä tai vedä GND:hen nollataksesi
LED_RED	3.3 V	RGB‑LEDin punainen kanava (aktiivinen alhaalla)
LED_GREEN	3.3 V	RGB‑LEDin vihreä kanava (aktiivinen alhaalla)
LED_BLUE	3.3 V	RGB‑LEDin sininen kanava (aktiivinen alhaalla)

Muista

A0-A3 ovat vain analogisia STM32H747:n kontaktipintoja ilman GPIO‑toimintoa — käsittele niitä ainoastaan ADC‑tuloina. A2/A4 ja A3/A5 jakavat fyysiset nastansa vastaavasti D10:n ja D8:n kanssa, joten et voi ohjata PWM‑ tai SPI‑toimintoa niillä samalla kun luet niitä analogisina. A7 sijaitsee pohjan HD‑liittimissä.

Virtanastat¶

MKR‑rivin nastat:

VIN — pääjärjestelmän syöttölinja piirilevyllä olevaan PMIC:hen. Syötetään diodin kautta +5V ‑linjasta, MKR VIN ‑nastasta tai pohjan 80‑nastaisista HD‑liittimistä.
+5V — 5 V:n linja, joka syötetään USB:stä, ESLOV‑liittimestä tai itse MKR +5V ‑nastasta.
+3V3 — pää‑3,3 V:n linja (PMIC:n hakkuriregulaattorin lähtö).
AREF — analoginen jännitereferenssi ADC‑nastoille. Oletusarvo 3,3 V; ohjaa ulkoisesti käyttääksesi eri referenssiä.
GND — yhteinen maa.

Akkutulo:

Li‑Po JST levyn etuosassa ottaa vastaan 3,7 V:n Li‑Po‑kennon. PMIC lataa sitä aina kun +5V tai VIN on läsnä.

Portenta H7:lle voidaan syöttää virtaa millä tahansa näistä reiteistä:

USB‑C — syöttää 5 V piirilevyllä olevaan PMIC:hen.
ESLOV‑liitin — enintään 5 V VESLOV‑nastassa (katso ESLOV‑liitin).
VIN‑nasta — syötä säädelty 5 V:n teho suoraan.
Li‑Po‑akku — kytke etuosan JST‑liittimeen.

ESLOV‑liitin¶

Levyn sivulla on 5‑nastainen juottamaton ESLOV‑liitin:

Nasta	Nimi	Toiminto
1	VESLOV	5 V:n virtalähtö (sama linja kuin MKR‑rivin `+5V`)
2	INT	ulkoinen keskeytystulo nastassa `D7`
3	SCL_EXT	jaettu MKR‑rivin `D12` ‑kontaktipinnan kanssa — sama I²C 3 ‑väylä kuin käyttäjärivissä
4	SDA_EXT	jaettu MKR‑rivin `D11` ‑kontaktipinnan kanssa — sama I²C 3 ‑väylä kuin käyttäjärivissä
5	GND	yhteinen maa

ESLOVin SCL_EXT/SDA_EXT ja MKR‑rivin D12/D11 ovat samat nastat — yksi I²C 3 ‑väylä, joka on tuotu esiin kahteen liittimeen.

Vihje

Käytä akun keston arviointityökalua mallintamaan, kuinka kauan Portenta H7 toimii akulla annetulla aktiivisuus‑/syväuniaika‑suhteella.

Palautus‑ ja virheenkorjausnastat¶

RESET — sekä yläosan riviin tuotu nasta että levyn sivulla oleva hetkellinen kytkin, jotka on kytketty SoC:n NRST‑linjaan. Vedä GND:hen tai paina painiketta nollataksesi.

Portenta H7 käyttää Arduinon vakiomuotoista kaksoisnapautusnollausta siirtyäkseen Arduinon käynnistyslataimeen. Paina nollauspainiketta nopeasti kahdesti — levy ilmoittautuu uudelleen USB:n kautta DFU‑laitteena ja OpenMV IDE voi ohjelmoida uuden laiteohjelmistokuvan.

STM32:n SWD‑signaalit on tuotu esiin pohjan HD‑liittimessä J1:

J1‑73 — NRST
J1‑75 — SWDIO (PA13)
J1‑77 — SWCLK (PA14)
J1‑79 — SWO (PB3)

Kytke ne Portenta Breakoutin, virallisen Arduinon virheenkorjaussovittimen tai mukautetun kantolevyn kautta, jossa on 1,27 mm:n rivi. Kaikki virheenkorjaussignaalit ovat 3,3 V:n referenssillä.

Muista

Kun Portenta Vision Shield on kiinnitetty, samat SWD/JTAG‑signaalit reititetään ylös laajennuksen vakiomuotoiseen 20‑nastaiseen ARM Cortex Debug JTAG ‑riviin (1,27 mm / 0,05″ jako).

Piirilevyllä olevat oheislaitteet¶

LEDit¶

Portenta H7:ssä on yksi käyttäjän RGB‑LED, joka on ohjelmallisesti hallittavissa machine.LED ‑rajapinnan kautta:

from machine import LED

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

Erillinen oranssi lataus‑LED akun JST‑liittimen vieressä syttyy, kun piirilevyllä oleva laturi syöttää virtaa kytkettyyn Li‑Po‑akkuun; se ei ole käyttäjän hallittavissa.

Kamerasensori (Vision Shield)¶

Kun Portenta Vision Shield (Ethernet‑ tai LoRa‑versio) on kiinnitetty, Himax‑sensoria ohjataan csi — kennot ‑moduulin kautta:

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

Kahta Vision Shield ‑versiota tuetaan:

HM01B0 — 320 × 320 yksivärinen.
HM0360 — 640 × 480 yksivärinen.

Varoitus

Kun Vision Shieldin kamera on alustettu, laiteohjelmisto varaa seuraavat MKR‑rivin nastat, eikä niitä voi käyttää:

MKR‑nasta	Syy
`D1`	TIM1 CH1 — kameran pääkello
`D6`	TIM1 CH1 (vaihtoehtoinen) — kameran pääkello
`D11`	I²C 3 SDA — jaettu kameran kanssa; väylä on käytettävissä, mutta vältä sensorin I²C‑osoitetta (`0x24`)
`D12`	I²C 3 SCL — jaettu kameran kanssa; väylä on käytettävissä, mutta vältä sensorin I²C‑osoitetta (`0x24`)
`A6` / `D21`	DCMI HSYNC — poistaa myös DAC:n käytöstä
`A7`	DCMI PXCLK

Koneoppiminen¶

ml — Koneoppiminen suorittaa kvantisoituja TFLite‑malleja Cortex‑M7:llä CMSIS‑NN ‑ytimillä — riittävän nopeasti kompakteille tunnistimille muutamalla kuvalla sekunnissa. Vain luku ‑muotoisessa /rom ‑tiedostojärjestelmässä olevat mallit latautuvat suoraan flash‑muistista ilman kopiointia RAM‑muistiin. Tässä on 128×128 BlazeFace ‑tunnistin, joka piirtää tunnistetut kasvot ja niiden kuusi maamerkkiä jokaiseen Vision Shieldin kameran kehykseen:

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‑ydin¶

Cortex‑M4‑ydin on käytettävissä openamp ‑rajapinnan kautta prosessorien väliseen viestintään. OpenMV‑laiteohjelmisto toimii vain M7:llä; M4:llä ei ole omaa MicroPython‑ajoympäristöä, joten sen käyttäminen tarkoittaa erillisen C‑laiteohjelmistokuvan rakentamista ja sen lataamista tiedostojärjestelmästä openamp.RemoteProc ‑luokan kautta. Valmiiksi rakennettu esimerkki‑laiteohjelmisto, joka toteuttaa virtuaalisen UART‑päätepisteen, on saatavilla openamp_vuart ‑repositoriosta — seuraa sen README‑tiedostoa rakentaaksesi vuart.elf

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)

Käytännössä tätä tukea on parasta pitää openamp‑rajapinnan esittelynä eikä toimivana kaksiydinalustana — M4:tä ei voi nollata M7:stä riippumatta, joten M4:n pysäyttäminen pakottaa koko järjestelmän uudelleenkäynnistyksen.

Mikrofoni (Vision Shield)¶

Vision Shieldissä on kaksi PDM‑mikrofonia, joista kerätään dataa audio — Audio-moduuli ‑rajapinnan kautta STM32:n SAI4‑oheislaitteen yli. Jokainen puskuri saapuu etumerkillisenä 16‑bittisenä PCM bytearray ‑muodossa, valmiina syötettäväksi ulab/numpy ‑kirjastoon DSP‑käsittelyä varten — esimerkiksi yksinkertainen äänenvoimakkuuden tunnistin:

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

Anna channels=2 ‑parametri audio.init ‑kutsuun saadaksesi lomitetut näytteet molemmista mikrofoneista.

Akun varaustilamittari¶

Maximin MAX17262 ModelGauge m5 ‑varaustilamittari seuraa Li‑Po‑akun jännitettä, virtaa, lämpötilaa ja varaustilaa. Se sijaitsee I²C 1 ‑väylässä osoitteessa 0x36.

MAX17262:ssa on sisäinen virranmittaus, joten virtarekisteri lukee suoraan mikroampeereina ilman ulkoista Rsense‑kerrointa. Varaustilamittarin lukeminen on vaaratonta — mukana ei toimiteta ajuria, mutta MAX17262‑datalehdessä dokumentoidut rekisterit voidaan lukea suoraan:

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 on etumerkillinen kahden komplementti: positiivinen latauksen aikana, negatiivinen purkauksen aikana. TTE on merkityksellinen vain virran ollessa negatiivinen; TTF vain virran ollessa positiivinen.

Tehonhallintapiiri¶

NXP:n PF1550‑PMIC hoitaa kaikki Portenta H7:n regulaattorit — +3V3‑päälinjan, +1V8 SoC‑ydin‑/I/O‑linjan ja Li‑Po‑laturin. Se sijaitsee I²C 1 ‑väylässä osoitteessa 0x08.

Varoitus

PMIC‑rekisterien lukeminen on turvallista; niihin kirjoittaminen on vaarallista. Hakkuriregulaattorin tai laturiasetuksen väärin määrittäminen voi vahingoittaa pysyvästi levyä, akkua tai molempia. Käsittele PMIC:tä vain luku ‑muotoisena, ellet tiedä tarkalleen mitä teet.

Hyödyllisin asia, jonka PMIC kertoo ja jota varaustilamittari ei voi, on laturin tilakone — toimiiko levy parhaillaan USB:llä / ESLOVilla / VIN:llä, missä latausjakson vaiheessa Li‑Po on ja onko laturi lämpö‑ tai vahtikoiravikatilassa. Laturirekisterit sijaitsevat 0x80:n siirtymällä PF1550:n pää‑I²C‑osoiteavaruudessa (katso PF1550‑datalehden §22.2), joten esimerkiksi CHG_INT_OK laturiosoitteessa 0x04 luetaan PMIC‑rekisteristä 0x84

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)

Muita datalehdessä silmäilyn arvoisia vain luku ‑rekistereitä (kaikki laturisiirtymällä 0x80): 0x80 CHG_INT (salvatut laturikeskeytykset — vikaliput), 0x86 VBUS_SNS (monibittinen VBUS‑tila mukaan lukien OVLO / UVLO / DPM) ja 0x88 BATT_SNS (akun läsnäolo‑ ja ylivirtatila).

Wi‑Fi¶

Piirilevyllä oleva Murata 1DX (CYW4343W) on tuotu esiin network — verkkomääritykset ‑rajapinnan kautta asemaliitäntänä. Kytke mukana toimitettu antenni piirilevyllä olevaan U.FL‑liittimeen ennen radion käynnistämistä:

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¶

Sama Murata 1DX tuo esiin myös Bluetooth LE 5.1:n. Käytä aioble — Asynkroninen BLE ‑kirjastoa asyncio‑ystävälliseen BLE‑toimintaan — esimerkiksi mainosta oheislaitteena ja odota keskuslaitteen yhdistämistä:

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 Shieldin LoRa‑versio lisää Murata CMWX1ZZABZ LoRaWAN ‑moduulin, joka on kytketty Portenta H7:ään UART:n kautta. lora‑moduuli kapseloi AT‑komentolaiteohjelmiston ja tukee OTAA‑ tai ABP‑liittymistä, lähetystä (uplink) ja vastaanottoa (downlink):

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

Käytä BAND_US915 / BAND_AS923 / BAND_AU915 jne. EU:n ulkopuolisille alueille, ja vaihda lora.Lora.join_ABP() ‑metodiin, jos verkkopalvelimesi käyttää ABP‑aktivointia.

Varoitus

Kun LoRa‑moduuli on käytössä, ajuri varaa seuraavat MKR‑rivin nastat Murata CMWX1ZZABZ:n ohjauslinjoiksi — niitä ei voi käyttää:

MKR‑nasta	Syy
`D3`	LoRa‑moduulin BOOT‑nasta
`D5`	LoRa‑moduulin RST‑nasta

Ethernet (Vision Shield)¶

Vision Shieldin Ethernet‑versio lisää RJ45‑liittimen magneettiineineen, joka on kytketty STM32H747:n 10/100 Ethernet MAC:hen RMII:n kautta. Kytke Ethernet‑kaapeli, niin PHY näkyy LAN‑liitäntänä; DHCP käynnistyy automaattisesti, kun yhteys muodostuu:

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‑kortti (Vision Shield)¶

Kun kortti asetetaan paikalleen, se liitetään automaattisesti polkuun /sdcard ja on käytettävissä tavallisen tiedostojärjestelmän kautta:

import os

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

Väylien viiteopas¶

GPIO¶

Käytä machine.Pin ‑rajapintaa lukeaksesi tai ohjataksesi mitä tahansa silkkipainetuista nastoista. Lähdöt ovat 3,3 V CMOS ja voivat upottaa/syöttää enintään 20 mA per nasta (140 mA yhteensä koko rivissä).

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

Mikä tahansa tulonasta voi myös laukaista keskeytyksen reunan siirtymissä:

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

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

UART¶

Väylä	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¶

Väylä	SCL	SDA
I2C3	D12	D11

from machine import I2C

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

MKR‑rivin D11/D12 ‑kontaktipinnat ja ESLOV‑liittimen SDA_EXT/SCL_EXT ‑nastat sijaitsevat samalla I²C 3 ‑väylällä — katso ESLOV‑nastajärjestys edellä kohdasta ESLOV‑liitin.

Samaa laitteistoa voidaan käyttää myös kohde‑ (slave‑) tilassa machine.I2CTarget ‑rajapinnan kautta tuomaan muistialue toisen I²C‑ohjaimen käyttöön:

from machine import I2CTarget

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

SPI¶

Väylä	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 tuo esiin kahdeksan 12‑bittistä ADC‑kanavaa nastoissa A0–A7. Kaikki ovat 3,3 V:n referenssillä — read_u16 palauttaa 0–65535 välillä 0–3,3 V nastassa:

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¶

Yksi 12‑bittinen DAC‑kanava on tuotu esiin nastassa DAC1 (A6 / D21) pyb.DAC ‑luokan kautta:

from pyb import DAC

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

PWM¶

Nasta	Ajastin / kanava
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

Ohjaa mitä tahansa niistä machine.PWM ‑rajapinnan kautta:

from machine import Pin, PWM

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

Muista

Useat nastat jakavat ajastinkanavia:

TIM1 CH1 on nastoissa D1 ja D6.
TIM1 CH2 on nastoissa D2 ja D14.
TIM8 CH3N on nastoissa D0 ja D1.

Valitse yksi kuluttaja per ajastinkanava.

Varoitus

TIM1 on varattu kameran pääkellolle, kun Vision Shield alustetaan csi — kennot ‑rajapinnan kautta — D1, D2, D6, D13 ja D14 eivät voi olla PWM‑ohjattuja kameran ollessa aktiivinen.

Ohjelmistopohjaiset bit‑banged‑väylät¶

machine.SoftI2C ja machine.SoftSPI toimivat millä tahansa GPIO:lla, jos tarvitset ylimääräisen väylän.

Lämpösensori (levyn ulkopuolinen)¶

Laiteohjelmisto sisältää fir — lämpösensorin ajuri (fir == far infrared) ‑ajurin ulkoisesti kytketyille lämpökuvaajille:

MLX90621 — 16 × 4 IR‑matriisi
MLX90640 — 32 × 24 IR‑matriisi
MLX90641 — 16 × 12 IR‑matriisi
AMG8833 — 8 × 8 IR‑matriisi

Kytke moduuli levyn I²C‑väylään ja lue kehyksiä komennoilla fir.init() + fir.snapshot()

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‑ajuri kommunikoi sensorin kanssa vain I²C 3 ‑väylän kautta — kytke moduuli nastoihin D12 (SCL) ja D11 (SDA).

Ajoitus¶

time¶

time ‑moduuli kattaa estävät viiveet, monotoniset tikitykset ja kuluneen ajan mittauksen:

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)

Virtuaaliajastimet¶

machine.Timer ajoittaa jaksottaisia tai kertaluonteisia takaisinkutsuja kuluttamatta laitteistoajastinpaikkaa. Anna -1 id:ksi käyttääksesi virtuaalista (ohjelmistopohjaista) ajastinta:

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

Jaksoarvot ovat millisekunteina. Kutsu deinit() pysäyttääksesi ja vapauttaaksesi paikan.

Reaaliaikakello¶

machine.RTC pitää seinäkelloaikaa nollausten yli. HD‑liitin tuo esiin myös COINCELL ‑kontaktipinnan, joka voi varmistaa RTC:n CR2032:lla virtakatkon yli:

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

Vahtikoira¶

machine.WDT nollaa levyn, jos sovellus jumiutuu. Kun se on käynnistetty, sitä ei voi pysäyttää tai määrittää uudelleen — ruoki sitä säännöllisesti pääsilmukassasi:

from machine import WDT

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

Käynnistys‑ ja ajonaikaiset tiedot¶

Laiteohjelmiston päivitys (DFU)¶

Käynnissä oleva skripti voi siirtyä takaisin käynnistyslataimeen pyynnöstä kutsumalla machine.bootloader()

import machine

machine.bootloader()

Tiedostojärjestelmä ja käynnistysjärjestys¶

Portenta H7 ‑laiteohjelmisto liittää käynnistyksessä enintään kolme tiedostojärjestelmää:

Sisäinen flash‑muisti — aina liitettynä polkuun /flash. Sisältää oletuksena main.py‑ ja README.txt‑tiedostot; luodaan aivan ensimmäisellä käynnistyksellä.
microSD‑kortti — jos Vision Shield on kiinnitetty ja kortti asetettu paikalleen, se liitetään polkuun /sdcard.
ROMFS — vain luku ‑muotoinen, muistiin kartoitettu tiedostojärjestelmä polussa /rom, jonka MicroPython liittää automaattisesti käynnistyksessä.

Liittämisen jälkeen työhakemistoksi asetetaan /sdcard, kun kortti on paikallaan, muutoin /flash. Tämän jälkeen tulkki suorittaa skriptejä kyseisestä hakemistosta:

boot.py suoritetaan jokaisella pehmeällä nollauksella (kylmäkäynnistys, Ctrl‑D REPL:stä tai aina kun käynnissä oleva skripti palaa).
main.py suoritetaan vain kylmäkäynnistyksellä, heti boot.py:n jälkeen. Seuraavat pehmeät nollaukset suorittavat boot.py:n uudelleen mutta siirtyvät suoraan REPL:iin — suorittaaksesi main.py:n uudelleen sinun on nollattava levy täysin.

boot.py‑ tai main.py‑tiedoston pudottaminen SD‑kortille ohittaa flash‑muistissa olevan kopion koskematta siihen — molemmat tiedostot haetaan käynnistyshakemistosta (/sdcard, kun kortti on liitetty, muutoin /flash).

Tuoreesti ohjelmoidulla levyllä toimitettu oletus‑main.py vain vilkuttaa käyttäjän RGB‑LEDin sinistä kanavaa sykkeenä (kaksi lyhyttä pulssia, lyhyt tauko), joten voit todeta laiteohjelmiston käynnistyneen puhtaasti ilman mitään isäntälaitetta kytkettynä.

sys.path laajennetaan sisältämään kaikki kolme tiedostojärjestelmää ja niiden lib/ ‑alihakemistot, joten tuotavat moduulit voivat sijaita hakemistoissa /flash/lib, /sdcard/lib tai /rom/lib.

Pakottaaksesi järjestelmän ohittamaan paikalleen asetetun SD‑kortin (esimerkiksi suorittaaksesi flash‑muistin main.py:n vaikka kortti olisi paikallaan), luo tyhjä tiedosto nimeltä SKIPSD /flash:n juureen.

Kun yhteys on USB:n kautta, käynnistystiedostojärjestelmä (/sdcard, jos kortti on paikallaan, muutoin /flash) ilmoittautuu myös USB‑massamuistiasemana isäntälaitteessa, jolloin voit muokata tiedostoja boot.py, main.py ja mitä tahansa muita suoraan. Poista asema turvallisesti ennen levyn nollaamista, jotta isäntälaite tyhjentää välimuistissa olevat kirjoitukset.

Muista

Koska käyttöjärjestelmä käsittelee asemaa passiivisena lohkolaitteena, kameralla suoritettavan koodin luomat tai muokkaamat tiedostot eivät näy ennen kuin isäntälaite liittää aseman uudelleen. Jos sekä käyttöjärjestelmä että kamera kirjoittavat samaan tiedostojärjestelmään samanaikaisesti, käyttöjärjestelmä voittaa ja korvaa kameran tekemät muutokset. Käytä SD‑korttia kaikelle datalle, jota skripti kirjoittaa takaisin, ja liitä uudelleen ennen kuin luet noita tiedostoja isäntälaitteesta.

Muista

Käyttäjän RGB‑LEDin punainen kanava voi syttyä hetkellisesti, kun isäntälaite lukee USB‑massamuistiasemasta tai kirjoittaa siihen — tämä on laiteohjelmiston ohjaama toiminnan ilmaisin, ei vika.

Tallennustilan koot¶

Portenta H7 toimitetaan seuraavilla:

/flash — 11 Mt FAT‑tiedostojärjestelmä, luku/kirjoitus.
/rom — 4 Mt vain luku ‑muotoinen muistiin kartoitettu ROMFS, jota käytetään sellaisten skriptien ja ML‑mallien toimittamiseen, jotka hyötyvät nollakopiointi‑mmap‑käytöstä.
/sdcard — Vision Shieldiin asetetun microSD‑kortin (kun paikalla) koko koko, luku/kirjoitus.

Vakavan vian ilmaisin¶

Jos käyttäjän RGB‑LED kiertää nopeasti läpi kaikki värit — niin nopeasti, että se näyttää yleensä tuikkivalta valkoiselta LEDiltä erillisten värisävyjen sijaan — laiteohjelmisto on kohdannut korjaamattoman vakavan vian. Ohjelmoi laiteohjelmisto uudelleen palautuaksesi; jos uudelleenohjelmointi ei auta, levy voi olla fyysisesti vaurioitunut.

Ohjelmistokirjastot¶

Katso kirjastohakemistosta täydellinen luettelo moduuleista — mukaan lukien ne, jotka ovat ainutlaatuisia Portenta H7 ‑versiolle.