Arduino Portenta H7¶

Arduino Portenta H7 je průmyslová vývojová deska o rozměrech 66 × 25 mm postavená kolem čipu STMicroelectronics STM32H747XI — dvoujádrového SoC kombinujícího Cortex‑M7 na 400 MHz s Cortex‑M4 na 200 MHz. Firmware OpenMV běží výhradně na jádru M7 a je navržen pro použití s deskou Portenta Vision Shield (edice Ethernet nebo LoRa), která k základní desce Portenta H7 přidává kameru Himax HM01B0 / HM0360, dvojici PDM mikrofonů a slot pro microSD.

Úplný katalogový list, fotografie a rozměry najdete na produktové stránce Arduino Portenta H7.

Hlavní vlastnosti¶

STMicroelectronics STM32H747XI s dvojicí Cortex‑M7 (400 MHz) + Cortex‑M4 (200 MHz). Firmware OpenMV běží pouze na jádru M7; jádro M4 je zpřístupněno prostřednictvím openamp pro meziprocesorovou komunikaci.
8 MB externí SDRAM plus 2 MB interní flash paměti a 16 MB externí QSPI flash paměti.
Hardwarový JPEG kodér/dekodér.
Wi‑Fi b/g/n (2,4 GHz) + Bluetooth LE 5.1 prostřednictvím modulu Murata 1DX (CYW4343W) — připojuje se k dodávané anténě přes U.FL konektor na desce.
Vysokorychlostní USB‑C (480 Mb/s).
22 uživatelských I/O pinů na horních headerech ve stylu Arduino MKR — D0–D14 (digitální) plus A0–A6 (analogové).
Dva 80‑pinové vysokohustotní konektory na spodní straně zpřístupňují celou strukturu STM32H747 — DCMI, DSI, Ethernet RMII, FDCAN, SDIO, SAI/I²S, UARTy, další SPI/I²C/časovače a tak dále. K těmto konektorům se připojují shieldy, jako je Vision Shield.
JTAG / SWD vyvedené na spodních HD konektorech pro pokročilé ladění.
Podpora baterie — JST konektor pro 3,7 V Li‑Po článek plus nabíječka a monitor baterie na desce.

Rozložení pinů¶

Referenční přehled pinů¶

22 uživatelských pinů je vyvedeno na horních hranových headerech ve stylu Arduino MKR — 15 digitálních (D0-D14) plus 7 analogových (A0-A6). Mnoho dalších pinů SoC je dostupných přes spodní 80‑pinové vysokohustotní konektory pro práci se shieldy; toto mapování najdete v úplném PDF s rozložením pinů od Arduina.

Název pinu	Reference	Funkce
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 (sdíleno s A3 / A5)
D9	3.3 V	SPI2 SCK
D10	3.3 V	SPI2 MISO (sdíleno s A2 / A4)
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 (pouze analogový)
A1	3.3 V	ADC12 IN1 (pouze analogový)
A2	3.3 V	ADC123 IN12 (pouze analogový; sdíleno s D10)
A3	3.3 V	ADC12 IN13 (pouze analogový; sdíleno s D8)
A4	3.3 V	ADC123 IN12 (sdíleno s D10)
A5	3.3 V	ADC12 IN13 (sdíleno s D8)
A6	3.3 V	DAC1 OUT1 / ADC12 IN18
A7	3.3 V	TIM3 CH1 / ADC12 IN3 (není vyvedeno na headerech)
D20	3.3 V	alias pro `D8` / `A3` / `A5`
D21	3.3 V	alias pro `A6` — DAC1 OUT1
RESET	3.3 V	stiskněte tlačítko na desce nebo stáhněte na GND pro reset
LED_RED	3.3 V	červený kanál RGB LED (aktivní v nule)
LED_GREEN	3.3 V	zelený kanál RGB LED (aktivní v nule)
LED_BLUE	3.3 V	modrý kanál RGB LED (aktivní v nule)

Poznámka

A0-A3 jsou pouze analogové plošky na STM32H747 bez GPIO funkce — používejte je výhradně jako ADC vstupy. A2/A4 a A3/A5 sdílejí své fyzické piny s D10 a D8 v tomto pořadí, takže na nich nelze řídit PWM nebo SPI a zároveň je číst jako analogové. A7 se nachází na spodních HD konektorech.

Napájecí piny¶

Piny MKR headeru:

VIN — hlavní systémová napájecí větev vedoucí do PMIC na desce. Napájeno přes diodu z větve +5V, z pinu MKR VIN nebo ze spodních 80‑pinových HD konektorů.
+5V — 5 V větev napájená z USB, z konektoru ESLOV nebo ze samotného pinu MKR +5V.
+3V3 — hlavní 3,3 V větev (výstup spínaného regulátoru PMIC).
AREF — analogová referenční napětí pro ADC piny. Výchozí hodnota je 3,3 V; pro použití jiné reference jej napájejte externě.
GND — společná zem.

Vstup baterie:

Li‑Po JST na přední straně desky přijímá 3,7 V Li‑Po článek. PMIC jej nabíjí, kdykoli je přítomno +5V nebo VIN.

Portenta H7 lze napájet kteroukoli z těchto cest:

USB‑C — dodává 5 V do PMIC na desce.
Konektor ESLOV — až 5 V na VESLOV (viz Konektor ESLOV).
Pin VIN — přiveďte regulované 5 V napájení přímo.
Li‑Po baterie — připojte k JST konektoru na přední straně.

Konektor ESLOV¶

Na boku desky je 5‑pinový bezpájecí konektor ESLOV:

Pin	Název	Funkce
1	VESLOV	výstup napájení 5 V (stejná větev jako `+5V` MKR headeru)
2	INT	vstup externího přerušení na `D7`
3	SCL_EXT	sdíleno s ploškou `D12` MKR headeru — stejná I²C 3 sběrnice jako uživatelský header
4	SDA_EXT	sdíleno s ploškou `D11` MKR headeru — stejná I²C 3 sběrnice jako uživatelský header
5	GND	společná zem

SCL_EXT/SDA_EXT konektoru ESLOV a D12/D11 MKR headeru jsou stejné piny — jedna I²C 3 sběrnice vyvedená na dvou konektorech.

Tip

Pomocí odhadovače výdrže baterie můžete modelovat, jak dlouho Portenta H7 vydrží na baterii pro daný poměr aktivního a hlubokého spánku.

Piny pro obnovu a ladění¶

RESET — jak vyvedený pin na horním headeru, tak momentové tlačítko na boku desky, propojené s linkou NRST čipu SoC. Stáhněte na GND nebo stiskněte tlačítko pro reset.

Portenta H7 používá standardní dvojí stisk resetu od Arduina pro vstup do bootloaderu Arduina. Rychle stiskněte tlačítko reset dvakrát — deska se přihlásí přes USB jako DFU zařízení a OpenMV IDE může nahrát nový firmware obraz.

SWD signály STM32 jsou vyvedeny na spodním HD konektoru J1:

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

Připojte je prostřednictvím Portenta Breakout, oficiálního ladicího adaptéru Arduino nebo vlastní nosné desky s headerem s roztečí 1,27 mm. Všechny ladicí signály jsou vztaženy k 3,3 V.

Poznámka

Když je připojen Portenta Vision Shield, jsou stejné SWD/JTAG signály vedeny na standardní 20‑pinový ladicí JTAG header ARM Cortex Debug na shieldu (rozteč 1,27 mm / 0,05″).

Periferie na desce¶

LED diody¶

Portenta H7 má jedinou uživatelskou RGB LED, softwarově ovladatelnou prostřednictvím machine.LED

from machine import LED

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

Samostatná oranžová nabíjecí LED vedle JST baterie se rozsvítí, když nabíječka na desce dodává proud do připojeného Li‑Po; není uživatelsky ovladatelná.

Senzor kamery (Vision Shield)¶

S připojeným Portenta Vision Shield (edice Ethernet nebo LoRa) je senzor Himax řízen prostřednictvím modulu csi — kamerové senzory

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

Podporovány jsou dvě revize Vision Shieldu:

HM01B0 — 320 × 320 monochromatický.
HM0360 — 640 × 480 monochromatický.

Varování

Dokud je kamera Vision Shieldu inicializována, jsou následující piny MKR headeru obsazeny firmwarem a nelze je použít:

Pin MKR	Důvod
`D1`	TIM1 CH1 — hlavní hodiny kamery
`D6`	TIM1 CH1 (alt.) — hlavní hodiny kamery
`D11`	I²C 3 SDA — sdíleno s kamerou; sběrnice je použitelná, ale vyhněte se I²C adrese senzoru (`0x24`)
`D12`	I²C 3 SCL — sdíleno s kamerou; sběrnice je použitelná, ale vyhněte se I²C adrese senzoru (`0x24`)
`A6` / `D21`	DCMI HSYNC — také zakáže DAC
`A7`	DCMI PXCLK

Strojové učení¶

ml — Strojové učení spouští kvantizované TFLite modely na Cortex‑M7 s jádry CMSIS‑NN — dostatečně rychle pro kompaktní detektory při několika snímcích za sekundu. Modely na souborovém systému /rom určeném pouze ke čtení se načítají přímo z flash paměti bez kopírování do RAM. Zde je 128×128 BlazeFace detektor překrývající detekovaný obličej a jeho šest význačných bodů na každém snímku z kamery Vision Shieldu:

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

Jádro M4¶

Jádro Cortex‑M4 je zpřístupněno prostřednictvím openamp pro meziprocesorovou komunikaci. Firmware OpenMV běží pouze na M7; M4 nemá vlastní MicroPython běhové prostředí, takže jeho použití znamená sestavit samostatný C firmware obraz a načíst jej ze souborového systému přes openamp.RemoteProc. Předem sestavený ukázkový firmware, který implementuje virtuální UART koncový bod, je k dispozici v repozitáři openamp_vuart — postupujte podle jeho README pro sestavení 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)

V praxi je nejlepší považovat tuto podporu spíše za demonstraci rozhraní openamp než za funkční dvoujádrovou platformu — M4 nelze resetovat nezávisle na M7, takže zastavení M4 vynutí úplný restart systému.

Mikrofon (Vision Shield)¶

Vision Shield nese dvojici PDM mikrofonů zachycovaných prostřednictvím audio — Modul Audio přes periferii SAI4 čipu STM32. Každý buffer přichází jako 16bitový PCM se znaménkem v podobě bytearray, připravený k předání do ulab/numpy pro DSP — například jednoduchý detektor hlasitosti:

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

Předáním channels=2 do audio.init získáte prokládané vzorky z obou mikrofonů.

Měřič stavu baterie¶

Měřič stavu baterie Maxim MAX17262 ModelGauge m5 sleduje napětí, proud, teplotu a stav nabití Li‑Po baterie. Nachází se na I²C 1 na adrese 0x36.

MAX17262 má interní snímání proudu, takže proudový registr se vyčítá přímo v mikroampérech bez nutnosti aplikovat externí faktor Rsense. Čtení měřiče stavu baterie je neškodné — žádný ovladač není dodáván, ale registry zdokumentované v katalogovém listu MAX17262 lze číst přímo:

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 je se znaménkem ve dvojkovém doplňku: kladný při nabíjení, záporný při vybíjení. TTE má význam pouze tehdy, když je proud záporný; TTF pouze tehdy, když je proud kladný.

Obvod správy napájení¶

PMIC NXP PF1550 obsluhuje každý regulátor na Portenta H7 — hlavní větev +3V3, větev jádra / I/O SoC +1V8 a Li‑Po nabíječku. Nachází se na I²C 1 na adrese 0x08.

Varování

Čtení registrů PMIC je v pořádku; zápis do nich je nebezpečný. Nesprávná konfigurace nastavení spínaného regulátoru nebo nabíječky může trvale poškodit desku, baterii nebo obojí. Považujte PMIC za určený pouze ke čtení, pokud přesně nevíte, co děláte.

Nejužitečnější věc, kterou vám PMIC sdělí a kterou měřič stavu baterie nezná, je stavový automat nabíječky — zda deska aktuálně běží na USB / ESLOV / VIN, v jaké fázi nabíjecího cyklu se Li‑Po nachází a zda je nabíječka v teplotní nebo watchdog poruše. Registry nabíječky se nacházejí na offsetu 0x80 v hlavním I²C adresovém prostoru PF1550 (viz §22.2 katalogového listu PF1550), takže například CHG_INT_OK na adrese nabíječky 0x04 se čte z registru PMIC 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)

Další registry určené pouze ke čtení, na které se vyplatí podívat v katalogovém listu (vše na offsetu nabíječky 0x80): 0x80 CHG_INT (zachycená přerušení nabíječky — příznaky poruch), 0x86 VBUS_SNS (vícebitový stav VBUS včetně OVLO / UVLO / DPM) a 0x88 BATT_SNS (přítomnost baterie a stav nadproudu).

Wi‑Fi¶

Modul Murata 1DX (CYW4343W) na desce je zpřístupněn prostřednictvím network — konfigurace sítě jako stanicové rozhraní. Před zapnutím rádia připojte dodávanou anténu k U.FL konektoru na desce:

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¶

Stejný modul Murata 1DX zpřístupňuje také Bluetooth LE 5.1. Pro asyncio‑přívětivé BLE použijte aioble — Asynchronní BLE — například inzerujte jako periferie a čekejte na připojení centrálního zařízení:

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

LoRa edice Vision Shieldu přidává modul Murata CMWX1ZZABZ LoRaWAN připojený k Portenta H7 přes UART. Modul lora obaluje firmware s AT‑příkazy a podporuje připojení OTAA nebo ABP, uplink a 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()

Pro neevropské regiony použijte BAND_US915 / BAND_AS923 / BAND_AU915 atd. a přepněte na lora.Lora.join_ABP(), pokud váš síťový server používá aktivaci ABP.

Varování

Dokud je modul LoRa v provozu, ovladač obsazuje následující piny MKR headeru jako řídicí linky pro Murata CMWX1ZZABZ — nelze je použít:

Pin MKR	Důvod
`D3`	pin BOOT modulu LoRa
`D5`	pin RST modulu LoRa

Ethernet (Vision Shield)¶

Ethernet edice Vision Shieldu přidává RJ45 zdířku s magnetikou připojenou k 10/100 Ethernet MAC čipu STM32H747 přes RMII. Zapojte Ethernet kabel a PHY se objeví jako rozhraní LAN; DHCP se spustí automaticky, jakmile se linka aktivuje:

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

Po vložení karty je automaticky připojena na /sdcard a je použitelná prostřednictvím běžného souborového systému:

import os

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

Referenční přehled sběrnic¶

GPIO¶

Pomocí machine.Pin můžete číst nebo řídit kterýkoli z popsaných pinů. Výstupy jsou 3,3 V CMOS a mohou pohlcovat/dodávat až 20 mA na pin (140 mA celkem přes celý header).

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

Kterýkoli vstupní pin může také vyvolat přerušení při hranových přechodech:

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

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

UART¶

Sběrnice	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¶

Sběrnice	SCL	SDA
I2C3	D12	D11

from machine import I2C

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

Plošky D11/D12 na MKR headeru a piny SDA_EXT/SCL_EXT konektoru ESLOV ústí na stejnou I²C 3 sběrnici — rozložení pinů ESLOV najdete výše v Konektor ESLOV.

Stejný hardware lze použít také v cílovém (slave) režimu prostřednictvím machine.I2CTarget ke zpřístupnění paměťové oblasti jinému I²C řadiči:

from machine import I2CTarget

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

SPI¶

Sběrnice	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 zpřístupňuje osm 12bitových ADC kanálů na A0–A7. Všechny jsou vztaženy k 3,3 V — read_u16 vrací 0–65535 v rozsahu 0–3,3 V na pinu:

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¶

Jediný 12bitový DAC kanál je zpřístupněn na DAC1 (A6 / D21) prostřednictvím pyb.DAC

from pyb import DAC

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

PWM¶

Pin	Časovač / kanál
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

Řiďte kterýkoli z nich prostřednictvím machine.PWM

from machine import Pin, PWM

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

Poznámka

Několik pinů sdílí kanály časovačů:

TIM1 CH1 je na D1 i D6.
TIM1 CH2 je na D2 i D14.
TIM8 CH3N je na D0 i D1.

Vyberte jednoho spotřebitele na kanál časovače.

Varování

TIM1 je vyhrazen pro hlavní hodiny kamery, když je Vision Shield inicializován prostřednictvím csi — kamerové senzory — D1, D2, D6, D13 a D14 nelze řídit PWM, dokud je kamera aktivní.

Softwarově bit‑bangované sběrnice¶

machine.SoftI2C a machine.SoftSPI fungují na kterémkoli GPIO, pokud potřebujete další sběrnici.

Tepelný senzor (mimo desku)¶

Firmware obsahuje ovladač fir — ovladač termálního senzoru (fir == far infrared, vzdálené infračervené záření) pro externě zapojené tepelné kamery:

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

Zapojte modul k I²C sběrnici desky a čtěte snímky pomocí 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())

Ovladač fir komunikuje se senzorem pouze přes I²C 3 — zapojte modul k D12 (SCL) a D11 (SDA).

Časování¶

time¶

Modul time pokrývá blokující zpoždění, monotónní tiky a měření uplynulého času:

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ální časovače¶

machine.Timer plánuje periodické nebo jednorázové callbacky bez spotřebování slotu hardwarového časovače. Předejte -1 jako id pro použití virtuálního (softwarového) časovače:

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

Hodnoty periody jsou v milisekundách. Pro zastavení a uvolnění slotu zavolejte deinit().

Hodiny reálného času¶

machine.RTC udržuje skutečný čas napříč resety. HD konektor také zpřístupňuje plošku COINCELL, která může napájet RTC z článku CR2032 při výpadku napájení:

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¶

machine.WDT resetuje desku, pokud aplikace zamrzne. Po spuštění jej nelze zastavit ani překonfigurovat — periodicky jej krmte uvnitř hlavní smyčky:

from machine import WDT

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

Informace o spuštění a běhu¶

Aktualizace firmwaru (DFU)¶

Běžící skript může na vyžádání znovu vstoupit do bootloaderu zavoláním machine.bootloader()

import machine

machine.bootloader()

Souborový systém a pořadí spouštění¶

Firmware Portenta H7 připojuje při spuštění až tři souborové systémy:

Interní flash — vždy připojen na /flash. Ve výchozím stavu obsahuje main.py a README.txt; vytvořen při úplně prvním spuštění.
microSD karta — pokud je připojen Vision Shield a vložena karta, je připojena na /sdcard.
ROMFS — souborový systém určený pouze ke čtení, mapovaný do paměti na /rom, připojený automaticky MicroPythonem při startu.

Po připojení je pracovní adresář nastaven na /sdcard, pokud je karta přítomna, jinak na /flash. Interpret poté spouští skripty z tohoto adresáře:

boot.py se spustí při každém softwarovém resetu (studený start, Ctrl‑D z REPL nebo kdykoli běžící skript skončí).
main.py se spustí pouze při studeném startu, ihned po boot.py. Následné softwarové resety znovu spustí boot.py, ale přejdou rovnou do REPL — pro opětovné spuštění main.py musíte desku zcela resetovat.

Umístění souboru boot.py nebo main.py na SD kartu přepíše kopii ve flash paměti, aniž by se jí dotklo — oba soubory se vyhledávají ve spouštěcím adresáři (/sdcard, když je karta připojena, jinak /flash).

Výchozí main.py dodávaný na čerstvě naflashované desce pouze bliká modrým kanálem uživatelské RGB LED jako tep (dva krátké pulzy, krátká pauza), takže poznáte, že se firmware spustil čistě, aniž by byl připojen jakýkoli hostitel.

sys.path je rozšířen tak, aby zahrnoval všechny tři souborové systémy a jejich podadresáře lib/, takže importovatelné moduly mohou být v /flash/lib, /sdcard/lib nebo /rom/lib.

Chcete-li donutit systém ignorovat vloženou SD kartu (například ke spuštění main.py z flash paměti i s přítomnou kartou), vytvořte prázdný soubor s názvem SKIPSD v kořeni /flash.

Při připojení přes USB se spouštěcí souborový systém (/sdcard, pokud je karta přítomna, jinak /flash) také přihlásí jako USB úložiště typu mass‑storage na hostiteli, což vám umožní upravovat boot.py, main.py a jakékoli další soubory přímo. Před resetem desky disk vysuňte, aby hostitel vyprázdnil své uložené zápisy.

Poznámka

Protože OS považuje disk za pasivní blokové zařízení, soubory vytvořené nebo upravené kódem běžícím na kameře se neobjeví, dokud hostitel disk znovu nepřipojí. Pokud OS i kamera zapisují do stejného souborového systému ve stejnou dobu, OS zvítězí a přepíše změny provedené kamerou. Pro jakákoli data, která skript zapisuje zpět, použijte SD kartu a před čtením těchto souborů z hostitele disk znovu připojte.

Poznámka

Červený kanál uživatelské RGB LED se může krátce rozsvítit, když hostitel čte z USB úložiště typu mass‑storage nebo do něj zapisuje — jedná se o firmwarem řízený indikátor aktivity, nikoli o poruchu.

Velikosti úložiště¶

Portenta H7 se dodává s:

/flash — 11 MB FAT souborový systém, pro čtení/zápis.
/rom — 4 MB ROMFS určený pouze ke čtení, mapovaný do paměti, používaný k dodávání skriptů a ML modelů, které těží z přístupu mmap bez kopírování.
/sdcard — plná velikost jakékoli microSD karty vložené ve Vision Shieldu (pokud je přítomna), pro čtení/zápis.

Indikátor hard‑fault¶

Pokud uživatelská RGB LED rychle cykluje přes všechny barvy — dostatečně rychle, že to spíše vypadá jako blikající bílá LED než jako jednotlivé odstíny — firmware narazil na neopravitelnou závažnou chybu (hard fault). Pro obnovu firmware přeflashujte; pokud přeflashování nepomůže, deska může být fyzicky poškozena.

Softwarové knihovny¶

Úplný seznam modulů — včetně těch, které jsou jedinečné pro sestavení Portenta H7 — najdete v indexu knihoven.