Arduino Portenta H7¶

L’Arduino Portenta H7 est une carte de développement industrielle de 66 × 25 mm construite autour du STMicroelectronics STM32H747XI — un SoC à double cœur combinant un Cortex‑M7 à 400 MHz avec un Cortex‑M4 à 200 MHz. Le micrologiciel OpenMV s’exécute entièrement sur le cœur M7 et est conçu pour être utilisé avec le Portenta Vision Shield (édition Ethernet ou LoRa), qui ajoute une caméra Himax HM01B0 / HM0360, deux microphones PDM et un emplacement microSD à la carte Portenta H7 de base.

Pour la fiche technique complète, les photos et les dimensions, voir la page produit de l’Arduino Portenta H7.

Points forts¶

STMicroelectronics STM32H747XI double Cortex‑M7 (400 MHz) + Cortex‑M4 (200 MHz). Le micrologiciel OpenMV s’exécute uniquement sur le cœur M7 ; le cœur M4 est exposé via openamp pour la communication inter‑processeurs.
8 Mo de SDRAM externe plus 2 Mo de mémoire flash interne et 16 Mo de mémoire flash QSPI externe.
Encodeur/décodeur JPEG matériel.
Wi‑Fi b/g/n (2,4 GHz) + Bluetooth LE 5.1 via le module Murata 1DX (CYW4343W) — se connecte à l’antenne fournie via un connecteur U.FL embarqué.
USB‑C haute vitesse (480 Mb/s).
22 broches d’E/S utilisateur sur les en‑têtes supérieurs de type Arduino MKR — D0–D14 (numériques) plus A0–A6 (analogiques).
Deux connecteurs haute densité à 80 broches sur la face inférieure exposent l’ensemble de la matrice du STM32H747 — DCMI, DSI, Ethernet RMII, FDCAN, SDIO, SAI/I²S, UART, SPI/I²C/minuteurs supplémentaires, etc. Des shields comme le Vision Shield s’enfichent sur ces connecteurs.
JTAG / SWD sortis sur les connecteurs HD inférieurs pour le débogage avancé.
Prise en charge de la batterie — connecteur JST Li‑Po 3,7 V plus chargeur embarqué et moniteur de batterie.

Brochage¶

Référence des broches¶

22 broches utilisateur sont exposées sur les en‑têtes de bord supérieurs de type Arduino MKR — 15 numériques (D0-D14) plus 7 analogiques (A0-A6). Bien d’autres broches du SoC sont disponibles via les connecteurs haute densité à 80 broches inférieurs pour le travail avec des shields ; voir le PDF de brochage complet d’Arduino pour cette correspondance.

Nom de broche	Référence	Fonction
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 (partagé avec A3 / A5)
D9	3,3 V	SPI2 SCK
D10	3,3 V	SPI2 MISO (partagé avec 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 (analogique uniquement)
A1	3,3 V	ADC12 IN1 (analogique uniquement)
A2	3,3 V	ADC123 IN12 (analogique uniquement ; partagé avec D10)
A3	3,3 V	ADC12 IN13 (analogique uniquement ; partagé avec D8)
A4	3,3 V	ADC123 IN12 (partagé avec D10)
A5	3,3 V	ADC12 IN13 (partagé avec D8)
A6	3,3 V	DAC1 OUT1 / ADC12 IN18
A7	3,3 V	TIM3 CH1 / ADC12 IN3 (non exposé sur les en‑têtes)
D20	3,3 V	alias de `D8` / `A3` / `A5`
D21	3,3 V	alias de `A6` — DAC1 OUT1
RESET	3,3 V	appuyez sur l’interrupteur embarqué ou tirez vers GND pour réinitialiser
LED_RED	3,3 V	canal rouge de la LED RGB (actif à l’état bas)
LED_GREEN	3,3 V	canal vert de la LED RGB (actif à l’état bas)
LED_BLUE	3,3 V	canal bleu de la LED RGB (actif à l’état bas)

Note

Les broches A0-A3 sont des plots analogiques uniquement sur le STM32H747 sans fonction GPIO — traitez‑les uniquement comme des entrées ADC. A2/A4 et A3/A5 partagent leurs broches physiques respectivement avec D10 et D8, vous ne pouvez donc pas piloter de PWM ou de SPI sur celles‑ci tout en les lisant comme entrées analogiques. A7 se trouve sur les connecteurs HD inférieurs.

Broches d’alimentation¶

Broches de l’en‑tête MKR :

VIN — rail d’alimentation système principal vers le PMIC embarqué. Alimenté via une diode depuis le rail +5V, la broche VIN MKR, ou les connecteurs HD inférieurs à 80 broches.
+5V — rail 5 V alimenté depuis l’USB, le connecteur ESLOV, ou la broche +5V MKR elle‑même.
+3V3 — rail 3,3 V principal (sortie du régulateur à découpage du PMIC).
AREF — référence de tension analogique pour les broches ADC. Par défaut 3,3 V ; pilotez‑la en externe pour utiliser une référence différente.
GND — masse commune.

Entrée batterie :

JST Li‑Po à l’avant de la carte accepte une cellule Li‑Po 3,7 V. Le PMIC la charge dès que +5V ou VIN est présent.

Le Portenta H7 peut être alimenté par l’un de ces moyens :

USB‑C — fournit 5 V au PMIC embarqué.
Connecteur ESLOV — jusqu’à 5 V sur VESLOV (voir Connecteur ESLOV).
Broche VIN — pilotez directement une alimentation régulée de 5 V.
Batterie Li‑Po — connectez au JST à l’avant.

Connecteur ESLOV¶

Sur le côté de la carte se trouve un connecteur ESLOV à 5 broches sans soudure :

Broche	Nom	Fonction
1	VESLOV	sortie d’alimentation 5 V (même rail que le `+5V` de l’en‑tête MKR)
2	INT	entrée d’interruption externe sur `D7`
3	SCL_EXT	partagé avec le plot `D12` de l’en‑tête MKR — même bus I²C 3 que l’en‑tête utilisateur
4	SDA_EXT	partagé avec le plot `D11` de l’en‑tête MKR — même bus I²C 3 que l’en‑tête utilisateur
5	GND	masse commune

Les broches SCL_EXT/SDA_EXT de l’ESLOV et les broches D12/D11 de l’en‑tête MKR sont les mêmes — un seul bus I²C 3 exposé sur deux connecteurs.

Astuce

Utilisez l”estimateur d’autonomie de batterie pour modéliser la durée pendant laquelle le Portenta H7 fonctionnera sur batterie pour un cycle de service actif / veille profonde donné.

Broches de récupération et de débogage¶

RESET — à la fois une broche exposée sur l’en‑tête supérieur et un interrupteur momentané sur le côté de la carte, reliés à la ligne NRST du SoC. Tirez vers GND ou appuyez sur le bouton pour réinitialiser.

Le Portenta H7 utilise la réinitialisation par double appui standard d’Arduino pour entrer dans le programme d’amorçage d’Arduino. Appuyez rapidement deux fois sur le bouton de réinitialisation — la carte se ré‑énumère sur USB en tant que périphérique DFU et OpenMV IDE peut flasher une nouvelle image de micrologiciel.

Les signaux SWD du STM32 sont exposés sur le connecteur HD J1 inférieur :

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

Câblez‑les via un Portenta Breakout, l’adaptateur de débogage officiel d’Arduino, ou une carte porteuse personnalisée avec un en‑tête au pas de 1,27 mm. Tous les signaux de débogage sont référencés à 3,3 V.

Note

Lorsque le Portenta Vision Shield est attaché, les mêmes signaux SWD/JTAG sont acheminés vers l”en‑tête de débogage JTAG ARM Cortex à 20 broches standard sur le shield (pas de 1,27 mm / 0,05″).

Périphériques embarqués¶

LED¶

Le Portenta H7 dispose d’une seule LED RGB utilisateur, contrôlable par logiciel via machine.LED

from machine import LED

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

Une LED de charge orange distincte à côté du JST de la batterie s’allume lorsque le chargeur embarqué fournit du courant à une Li‑Po connectée ; elle n’est pas contrôlable par l’utilisateur.

Capteur de caméra (Vision Shield)¶

Avec le Portenta Vision Shield (édition Ethernet ou LoRa) attaché, le capteur Himax est piloté via le module csi — capteurs de caméra

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

Deux révisions du Vision Shield sont prises en charge :

HM01B0 — 320 × 320 monochrome.
HM0360 — 640 × 480 monochrome.

Avertissement

Tant que la caméra du Vision Shield est initialisée, les broches suivantes de l’en‑tête MKR sont réservées par le micrologiciel et ne peuvent pas être utilisées :

Broche MKR	Raison
`D1`	TIM1 CH1 — horloge maître de la caméra
`D6`	TIM1 CH1 (alt) — horloge maître de la caméra
`D11`	I²C 3 SDA — partagé avec la caméra ; le bus est utilisable mais évitez l’adresse I²C du capteur (`0x24`)
`D12`	I²C 3 SCL — partagé avec la caméra ; le bus est utilisable mais évitez l’adresse I²C du capteur (`0x24`)
`A6` / `D21`	DCMI HSYNC — désactive également le DAC
`A7`	DCMI PXCLK

Apprentissage automatique¶

ml — Apprentissage automatique exécute des modèles TFLite quantifiés sur le Cortex‑M7 avec des noyaux CMSIS‑NN — assez rapide pour des détecteurs compacts à quelques trames par seconde. Les modèles sur le système de fichiers en lecture seule /rom se chargent directement depuis la mémoire flash sans copie vers la RAM. Voici un détecteur BlazeFace 128×128 qui superpose le visage détecté et ses six points de repère sur chaque trame de la caméra du Vision Shield

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

Cœur M4¶

Le cœur Cortex‑M4 est exposé via openamp pour la communication inter‑processeurs. Le micrologiciel OpenMV s’exécute uniquement sur le M7 ; le M4 n’a pas son propre environnement d’exécution MicroPython, donc l’utiliser implique de construire une image de micrologiciel C distincte et de la charger depuis le système de fichiers via openamp.RemoteProc. Un micrologiciel d’exemple précompilé qui implémente un point de terminaison UART virtuel est disponible dans le dépôt openamp_vuart — suivez son README pour construire 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)

En pratique, cette prise en charge est plutôt à considérer comme une démonstration de l’interface openamp qu’une plateforme double cœur fonctionnelle — le M4 ne peut pas être réinitialisé indépendamment du M7, donc arrêter le M4 force un redémarrage complet du système.

Microphone (Vision Shield)¶

Le Vision Shield porte deux microphones PDM capturés via audio — Module Audio sur le périphérique SAI4 du STM32. Chaque tampon arrive sous forme de bytearray PCM 16 bits signé, prêt à être fourni à ulab/numpy pour le traitement du signal — par exemple, un simple détecteur de volume sonore

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

Passez channels=2 à audio.init pour recevoir des échantillons entrelacés des deux microphones.

Jauge de batterie¶

La jauge de batterie Maxim MAX17262 ModelGauge m5 suit la tension, le courant, la température et l’état de charge de la batterie Li‑Po. Elle se trouve sur I²C 1 à l’adresse 0x36.

Le MAX17262 dispose d’une mesure de courant interne, le registre de courant se lit donc directement en microampères sans facteur Rsense externe à appliquer. Lire la jauge de batterie est inoffensif — aucun pilote n’est fourni, mais les registres documentés dans la fiche technique du MAX17262 peuvent être lus directement

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 est en complément à deux signé : positif pendant la charge, négatif pendant la décharge. TTE n’a de sens que lorsque le courant est négatif ; TTF uniquement lorsque le courant est positif.

Circuit de gestion de l’alimentation¶

Le PMIC NXP PF1550 gère tous les régulateurs du Portenta H7 — le rail principal +3V3, le rail cœur / E/S +1V8 du SoC, et le chargeur Li‑Po. Il se trouve sur I²C 1 à l’adresse 0x08.

Avertissement

Lire les registres du PMIC est sans risque ; y écrire est dangereux. Une mauvaise configuration d’un régulateur abaisseur ou d’un paramètre du chargeur peut endommager définitivement la carte, la batterie, ou les deux. Traitez le PMIC comme étant en lecture seule à moins de savoir exactement ce que vous faites.

Ce que le PMIC vous indique de plus utile et que la jauge de batterie ne peut pas est la machine à états du chargeur — si la carte fonctionne actuellement sur USB / ESLOV / VIN, à quel stade du cycle de charge la Li‑Po se trouve, et si le chargeur est en défaut thermique ou de chien de garde. Les registres du chargeur se situent à un décalage de 0x80 dans l’espace d’adressage I²C principal du PF1550 (voir §22.2 de la fiche technique du PF1550), par exemple CHG_INT_OK à l’adresse de chargeur 0x04 se lit depuis le registre 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)

D’autres registres en lecture seule à examiner dans la fiche technique (tous au décalage chargeur 0x80) : 0x80 CHG_INT (interruptions de chargeur verrouillées — drapeaux de défaut), 0x86 VBUS_SNS (l’état VBUS multi‑bit incluant OVLO / UVLO / DPM), et 0x88 BATT_SNS (présence de la batterie et état de surintensité).

Wi‑Fi¶

Le Murata 1DX (CYW4343W) embarqué est exposé via network — configuration réseau en tant qu’interface station. Connectez l’antenne fournie au connecteur U.FL embarqué avant d’activer la radio

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¶

Le même Murata 1DX expose également le Bluetooth LE 5.1. Utilisez aioble — BLE asynchrone pour du BLE compatible asyncio — par exemple, faire de la publicité en tant que périphérique et attendre qu’un central se connecte

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

L”édition LoRa du Vision Shield ajoute un module LoRaWAN Murata CMWX1ZZABZ câblé au Portenta H7 via UART. Le module lora encapsule le micrologiciel à commandes AT et prend en charge la jonction OTAA ou ABP, l’uplink et le 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()

Utilisez BAND_US915 / BAND_AS923 / BAND_AU915 etc. pour les régions hors UE, et passez à lora.Lora.join_ABP() si votre serveur réseau utilise l’activation ABP.

Avertissement

Tant que le module LoRa est en cours d’utilisation, le pilote réserve les broches suivantes de l’en‑tête MKR comme lignes de contrôle pour le Murata CMWX1ZZABZ — elles ne peuvent pas être utilisées :

Broche MKR	Raison
`D3`	broche BOOT du module LoRa
`D5`	broche RST du module LoRa

Ethernet (Vision Shield)¶

L”édition Ethernet du Vision Shield ajoute une prise RJ45 avec circuits magnétiques câblée au MAC Ethernet 10/100 du STM32H747 via RMII. Branchez un câble Ethernet et le PHY apparaît comme une interface LAN ; le DHCP s’exécute automatiquement une fois la liaison établie

import network
import time

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

Carte microSD (Vision Shield)¶

Lorsqu’une carte est insérée, elle est montée automatiquement sur /sdcard et est utilisable via le système de fichiers habituel

import os

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

Référence des bus¶

GPIO¶

Utilisez machine.Pin pour lire ou piloter n’importe laquelle des broches sérigraphiées. Les sorties sont en CMOS 3,3 V et peuvent absorber/fournir jusqu’à 20 mA par broche (140 mA au total sur l’ensemble de l’en‑tête).

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

Toute broche d’entrée peut également déclencher une interruption lors des transitions de front

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

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

UART¶

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

Bus	SCL	SDA
I2C3	D12	D11

from machine import I2C

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

Les plots D11/D12 de l’en‑tête MKR et les broches SDA_EXT/SCL_EXT du connecteur ESLOV aboutissent sur le même bus I²C 3 — voir Connecteur ESLOV ci‑dessus pour le brochage ESLOV.

Le même matériel peut également être utilisé en mode cible (esclave) via machine.I2CTarget pour exposer une région mémoire à un autre contrôleur I²C

from machine import I2CTarget

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

SPI¶

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

Le Portenta H7 expose huit canaux ADC 12 bits sur A0–A7. Tous sont référencés à 3,3 V — read_u16 renvoie 0–65535 sur la plage 0–3,3 V à la broche

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¶

Un seul canal DAC 12 bits est exposé sur DAC1 (A6 / D21) via pyb.DAC

from pyb import DAC

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

PWM¶

Broche	Minuteur / canal
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

Pilotez‑en n’importe lequel via machine.PWM

from machine import Pin, PWM

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

Note

Plusieurs broches partagent des canaux de minuteur :

TIM1 CH1 est sur D1 et D6.
TIM1 CH2 est sur D2 et D14.
TIM8 CH3N est sur D0 et D1.

Choisissez un seul consommateur par canal de minuteur.

Avertissement

TIM1 est réservé à l”horloge maître de la caméra lorsque le Vision Shield est initialisé via csi — capteurs de caméra — D1, D2, D6, D13 et D14 ne peuvent pas être pilotés en PWM tant que la caméra est active.

Bus en bit‑banging logiciel¶

machine.SoftI2C et machine.SoftSPI fonctionnent sur n’importe quel GPIO si vous avez besoin d’un bus supplémentaire.

Capteur thermique (externe)¶

Le micrologiciel inclut le pilote fir — pilote de capteur thermique (fir == infrarouge lointain) pour les imageurs thermiques câblés en externe :

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

Câblez le module au bus I²C de la carte et lisez les trames avec 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())

Le pilote fir ne communique avec le capteur que via I²C 3 — câblez le module sur D12 (SCL) et D11 (SDA).

Temporisation¶

time¶

Le module time couvre les délais bloquants, les tics monotones et la mesure du temps écoulé

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)

Minuteurs virtuels¶

machine.Timer planifie des fonctions de rappel périodiques ou à déclenchement unique sans consommer d’emplacement de minuteur matériel. Passez -1 comme identifiant pour utiliser un minuteur virtuel (logiciel)

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

Les valeurs de période sont en millisecondes. Appelez deinit() pour arrêter et libérer l’emplacement.

Horloge temps réel¶

machine.RTC conserve l’heure murale à travers les réinitialisations. Le connecteur HD expose également un plot COINCELL qui peut alimenter la RTC depuis une CR2032 en cas de coupure de courant

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

Chien de garde¶

machine.WDT réinitialise la carte si l’application se bloque. Une fois démarré, il ne peut être ni arrêté ni reconfiguré — alimentez‑le périodiquement dans votre boucle principale

from machine import WDT

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

Informations de démarrage et d’exécution¶

Mise à jour du micrologiciel (DFU)¶

Un script en cours d’exécution peut re‑entrer dans le programme d’amorçage à la demande en appelant machine.bootloader()

import machine

machine.bootloader()

Système de fichiers et ordre de démarrage¶

Le micrologiciel du Portenta H7 monte jusqu’à trois systèmes de fichiers au démarrage :

Mémoire flash interne — toujours montée sur /flash. Contient main.py et README.txt par défaut ; créée au tout premier démarrage.
Carte microSD — si un Vision Shield est attaché et qu’une carte est insérée, elle est montée sur /sdcard.
ROMFS — système de fichiers en lecture seule, mappé en mémoire sur /rom, monté automatiquement par MicroPython au démarrage.

Après le montage, le répertoire de travail est défini sur /sdcard lorsque la carte est présente, sinon /flash. L’interpréteur exécute ensuite les scripts depuis ce répertoire :

boot.py est exécuté à chaque redémarrage logiciel (démarrage à froid, Ctrl‑D depuis le REPL, ou chaque fois que le script en cours d’exécution se termine).
main.py est exécuté uniquement au démarrage à froid, immédiatement après boot.py. Les redémarrages logiciels ultérieurs ré‑exécutent boot.py mais passent directement au REPL — pour ré‑exécuter main.py, vous devez réinitialiser complètement la carte.

Déposer un boot.py ou un main.py sur la carte SD remplace la copie en mémoire flash sans y toucher — les deux fichiers sont recherchés dans le répertoire de démarrage (/sdcard lorsque la carte est montée, sinon /flash).

Le main.py par défaut livré sur une carte fraîchement flashée fait simplement clignoter le canal bleu de la LED RGB utilisateur comme battement de cœur (deux brèves impulsions, court intervalle), pour que vous puissiez savoir que le micrologiciel a démarré proprement sans aucun hôte connecté.

sys.path est étendu pour inclure les trois systèmes de fichiers et leurs sous‑répertoires lib/, de sorte que les modules importables peuvent se trouver dans /flash/lib, /sdcard/lib ou /rom/lib.

Pour forcer le système à ignorer une carte SD insérée (par exemple pour exécuter le main.py de la mémoire flash même avec une carte présente), créez un fichier vide nommé SKIPSD à la racine de /flash.

Lorsqu’il est connecté via USB, le système de fichiers de démarrage (/sdcard si une carte est présente, sinon /flash) s’énumère également comme un lecteur de stockage de masse USB sur l’hôte, vous permettant d’éditer boot.py, main.py et tout autre fichier directement. Éjectez le lecteur avant de réinitialiser la carte afin que l’hôte vide ses écritures en cache.

Note

Comme le système d’exploitation traite le lecteur comme un périphérique de bloc passif, les fichiers créés ou modifiés par le code s’exécutant sur la caméra n’apparaîtront pas tant que l’hôte n’aura pas remonté le lecteur. Si à la fois le système d’exploitation et la caméra écrivent sur le même système de fichiers en même temps, le système d’exploitation l’emportera et écrasera les modifications effectuées par la caméra. Utilisez la carte SD pour toute donnée que le script réécrit, et remontez avant de lire ces fichiers depuis l’hôte.

Note

Le canal rouge de la LED RGB utilisateur peut brièvement s’allumer pendant que l’hôte lit ou écrit sur le lecteur de stockage de masse USB — c’est un indicateur d’activité piloté par le micrologiciel, pas un défaut.

Tailles de stockage¶

Le Portenta H7 est livré avec :

/flash — système de fichiers FAT de 11 Mo, lecture/écriture.
/rom — ROMFS mappée en mémoire en lecture seule de 4 Mo, utilisée pour livrer des scripts et des modèles ML qui bénéficient d’un accès mmap sans copie.
/sdcard — taille complète de toute carte microSD insérée dans un Vision Shield (lorsqu’elle est présente), lecture/écriture.

Indicateur de défaut grave (hard fault)¶

Si la LED RGB utilisateur passe rapidement en revue toutes les couleurs — assez vite pour ressembler à une LED blanche scintillante plutôt qu’à des teintes distinctes — le micrologiciel a rencontré un défaut grave irrécupérable. Reflashez le micrologiciel pour récupérer ; si reflasher n’aide pas, la carte peut être physiquement endommagée.

Bibliothèques logicielles¶

Voir l”index de la bibliothèque pour la liste complète des modules — y compris ceux qui sont propres à la version Portenta H7.