OpenMV Cam H7 Plus¶

L’OpenMV Cam H7 Plus associe le STMicroelectronics STM32H743 (Cortex-M7 @ 480 MHz) à 32 Mo de SDRAM externe, 32 Mo de mémoire flash QSPI, un codec JPEG matériel et le module caméra OV5640 de 5 MP sur un support amovible. La mémoire supplémentaire est bien adaptée à la capture haute résolution et aux grands tampons d’image.

Pour la fiche technique complète, les photos et les dimensions, consultez la page produit de l’OpenMV Cam H7 Plus.

Points forts¶

STMicroelectronics STM32H743 Cortex-M7 à 480 MHz (1027 DMIPS).
Encodeur/décodeur JPEG matériel.
32 Mo de SDRAM externe (32 bits @ 100 MHz, 400 Mo/s) plus 1 Mo de SRAM interne.
2 Mo de mémoire flash interne + 32 Mo de mémoire flash QSPI externe (lecture ~100 Mo/s).
Capteur à obturateur déroulant OV5640 de 5 MP.
USB pleine vitesse (12 Mb/s) — apparaît comme VCP + stockage de masse USB sur l’hôte.
Connecteur microSD — SD jusqu’à 2 Go, SDHC jusqu’à 32 Go, SDXC jusqu’à 2 To.
Connecteur de batterie LiPo (pas de chargeur embarqué — fournissez une cellule chargée ou alimentez via VIN/USB).
10 broches d’E/S, tolérantes 5 V avec sortie 3,3 V, 25 mA par broche (120 mA au total sur le connecteur), capables de générer des interruptions. P6 n’est pas tolérante 5 V lorsqu’elle est utilisée en mode ADC ou DAC.
LED RGB utilisateur et deux LED IR 850 nm haute puissance pour un éclairage actif en vision à faible luminosité.

Note

La H7 Plus n’a aucune puce de gestion d’alimentation embarquée : il n’y a pas de chargeur de batterie, pas d’ADC de tension de batterie, pas de LED d’état de charge/alimentation et pas de bouton d’alimentation matériel. Connectez une cellule LiPo préchargée au connecteur JST de batterie ou alimentez la carte via USB / VIN.

Brochage¶

Référence des broches¶

Nom de la broche	Fonction
P0	UART1 RX / SPI2 MOSI
P1	UART1 TX / SPI2 MISO
P2	SPI2 SCK / FDCAN2 TX
P3	SPI2 NSS (CS) / FDCAN2 RX
P4	I2C2 SCL / UART3 TX / TIM2 CH3
P5	I2C2 SDA / UART3 RX / TIM2 CH4
P6	ADC / DAC / TIM2 CH1
P7	I2C4 SCL / TIM4 CH1
P8	I2C4 SDA / TIM4 CH2
P9	E/S numérique
RESET	tirer à GND pour réinitialiser la carte
SYN	pad de synchronisation de trame — câblé uniquement au capteur de la caméra
BOOT0	tirer à 3,3 V à la mise sous tension pour le programme d’amorçage DFU / ROM
LED_RED	canal rouge de la LED RGB (actif bas)
LED_GREEN	canal vert de la LED RGB (actif bas)
LED_BLUE	canal bleu de la LED RGB (actif bas)
LED_IR	LED IR haute puissance (les deux canaux pilotés ensemble)

Note

Le pad SYN du connecteur est relié directement à la ligne de déclenchement / exposition du capteur de la caméra — il ne se raccorde pas au MCU sur la H7 Plus. Pilotez-le ou lisez-le en externe ; vous ne pouvez pas le basculer depuis MicroPython.

Broches d’alimentation¶

3.3V — rail régulé 3,3 V. Jusqu’à 250 mA disponibles pour les shields (moins si la carte microSD est utilisée). Contrairement aux caméras plus récentes, cette broche est bidirectionnelle — voir l’avertissement ci-dessous.
VIN — entrée 3,6 – 5 V. Alimente la carte via le régulateur embarqué.
GND — masse commune.

Un connecteur LiPo 3,7 V est également présent, mais la H7 Plus ne dispose pas de chargeur de batterie — connectez une cellule préchargée, ou alimentez plutôt via VIN / USB.

Note

Lorsque l’USB et VIN/LiPo sont tous deux présents, l’entrée VIN/LiPo l’emporte — le commutateur d’alimentation embarqué la privilégie par rapport à l’USB pour alimenter la carte.

Avertissement

Le connecteur de batterie et VIN sont reliés ensemble sur la H7 Plus. Ne branchez pas une LiPo et n’appliquez pas VIN en même temps — les deux alimentations se contrarieront et peuvent endommager la batterie, la carte, ou les deux.

Avertissement

Vous pouvez alimenter la H7 Plus en injectant directement 3,3 V dans la broche 3.3V si vous ne souhaitez pas passer par le régulateur embarqué. Dans ce cas, n’appliquez pas non plus VIN ou l’alimentation USB en même temps — rétro-alimenter le régulateur alors qu’une autre source est active peut endommager et détruire définitivement la caméra.

Astuce

Utilisez l”estimateur d’autonomie de batterie pour modéliser la durée de fonctionnement de la H7 Plus sur batterie pour un cycle de service actif / veille profonde donné.

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

RESET — tirer à GND pour réinitialiser la carte. La relâcher laisse le MCU démarrer normalement.
BOOT0 — tirer à 3,3 V pendant la mise sous tension de la carte pour entrer dans le programme d’amorçage ROM du STM32 (mode DFU). OpenMV IDE utilise ce mode pour reprogrammer le programme d’amorçage embarqué.

La carte expose un connecteur de débogage SWD (RST / SWCLK / SWDIO / SWO) à côté du connecteur GPIO, compatible avec les adaptateurs ST-LINK et SEGGER J-Link.

Note

La broche de trace SWO est partagée avec la ligne d’horloge SPI du connecteur de la caméra. SWO ne peut pas être utilisée en même temps qu’un module caméra qui communique avec le MCU via SPI — par exemple le module adaptateur FLIR® Lepton® — choisissez l’un ou l’autre.

Périphériques embarqués¶

LED¶

La H7 Plus possède une seule LED RGB utilisateur ainsi qu’une paire de LED IR 850 nm haute puissance :

LED RGB utilisateur — pilotable par logiciel, exposée sous les noms LED_RED, LED_GREEN et LED_BLUE

from machine import LED

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

LED IR — les deux LED sont pilotées ensemble via la broche LED_IR. LED_IR est câblée active haute dans le matériel alors que le micrologiciel traite toutes les autres LED embarquées comme actives basses, donc utilisez low() / high() plutôt que on() / off() (qui inverseraient le sens)
```
from machine import LED

ir = LED("LED_IR")
ir.low()    # turn IR illumination ON
ir.high()   # turn IR illumination OFF
```

Capteur de la caméra¶

L’OV5640 est piloté via le module csi — capteurs de caméra

import csi

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

while True:
    img = cam.snapshot()

L’OV5640 dispose d’un compresseur JPEG embarqué. Réglez csi.CSI.pixformat sur csi.JPEG et le capteur délivre des trames compressées directement à la caméra via le bus caméra, ce qui rend les captures haute résolution praticables : csi.HD (1280×720), csi.FHD (1920×1080) et le 5 MP complet csi.WQXGA2 (2592×1944) sont tous diffusés en JPEG. Ajustez la compression avec csi.CSI.quality (0-100, plus élevé = trames plus grandes, plus de détails)

cam.pixformat(csi.JPEG)
cam.framesize(csi.WQXGA2)
cam.quality(90)

Le capteur est monté sur un module amovible — remplacez-le par n’importe quel autre module caméra OpenMV (obturateur global, thermique, résolution supérieure, etc.) sans changer le reste de la carte.

Apprentissage automatique¶

ml — Apprentissage automatique exécute des modèles TFLite quantifiés sur le Cortex-M7 avec les noyaux CMSIS-NN — assez rapides pour des détecteurs compacts à quelques trames par seconde. Les modèles présents sur le système de fichiers en lecture seule /rom se chargent directement depuis la mémoire flash sans être copiés en RAM. Voici un détecteur BlazeFace 128×128 superposant le visage détecté et ses six points de repère sur chaque trame

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

# Initialize the sensor.
csi0 = csi.CSI()
csi0.reset()
csi0.pixformat(csi.RGB565)
csi0.framesize(csi.VGA)
csi0.window((400, 400))

# 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)
        # 0 - right eye (x, y)
        # 1 - left eye (x, y)
        # 2 - nose (x, y)
        # 3 - mouth (x, y)
        # 4 - right ear (x, y)
        # 5 - left ear (x, y)
        ml.utils.draw_keypoints(img, keypoints, color=(255, 0, 0))

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

Carte microSD¶

Lorsqu’une carte est insérée, elle est montée automatiquement sous /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 quelle broche sérigraphiée. Les sorties sont en CMOS 3,3 V, tolérantes 5 V côté entrée, et peuvent absorber/fournir jusqu’à 25 mA par broche (120 mA au total sur l’ensemble du connecteur).

from machine import Pin

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

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

Toute broche d’entrée peut aussi déclencher une interruption sur les transitions de front

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

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

UART¶

Bus	TX	RX
UART1	P1	P0
UART3	P4	P5

from machine import UART

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

I²C¶

Bus	SCL	SDA
I2C2	P4	P5
I2C4	P7	P8

from machine import I2C

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

Le même matériel peut aussi ê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(2, addr=0x42, mem=buf)

SPI¶

Bus	MOSI	MISO	SCK	CS
SPI2	P0	P1	P2	P3

from machine import SPI
from machine import Pin

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

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

CAN (FDCAN)¶

Bus	TX	RX
FDCAN2	P2	P3

from machine import CAN

can = CAN(2, 500_000)
can.set_filters(None)
can.send(0x123, b"\xDE\xAD\xBE\xEF")
print(can.recv())

ADC et DAC¶

P6 est la seule broche analogique utilisateur. Elle peut être utilisée soit comme entrée ADC 12 bits, soit comme sortie DAC.

ADC — pleine échelle à 3,3 V sur la broche

from machine import ADC
import time

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

DAC — via pyb.DAC. La valeur 8 bits couvre 0–3,3 V

from pyb import DAC

dac = DAC("P6")
voltage = 1.65
dac.write(int(voltage / 3.3 * 255))

En mode ADC ou DAC, P6 est tolérante 3,3 V uniquement — ne lui appliquez pas 5 V.

PWM¶

Broche	Minuteur / canal
P4	TIM2 CH3
P5	TIM2 CH4
P6	TIM2 CH1
P7	TIM4 CH1
P8	TIM4 CH2

Note

TIM1 est réservé par le micrologiciel pour générer l’horloge pixel du capteur de la caméra, de sorte que les canaux TIM1 qui sont physiquement sur P0/P1/P2 ne peuvent pas être utilisés pour du PWM utilisateur sans casser la caméra.

TIM4 est partagé avec pyb.Servo — instancier un servo reconfigure le minuteur entier pour un fonctionnement à 50 Hz, donc ne mélangez pas machine.PWM sur P7/P8 avec pyb.Servo dans le même script.

Pilotez n’importe lequel d’entre eux via machine.PWM

from machine import Pin, PWM

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

Bus logiciels à bit-banging¶

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 communique avec le capteur uniquement via I²C 2 — câblez le module à P4 (SCL) et P5 (SDA).

Synchronisation temporelle¶

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 un emplacement de minuteur matériel. Passez -1 comme id 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 exprimées 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

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 à l’intérieur de 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¶

Fenêtre du programme d’amorçage USB¶

À chaque mise sous tension, la caméra exécute un court programme d’amorçage (quelques secondes) qui permet à OpenMV IDE de mettre à jour le micrologiciel sans que l’utilisateur ait à entrer en mode DFU. Une fois la fenêtre expirée, le programme d’amorçage passe la main à boot.py puis à main.py.

Un script en cours d’exécution peut réintégrer 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 de la H7 Plus monte jusqu’à trois systèmes de fichiers au démarrage :

Mémoire flash interne — toujours montée sous /flash. Contient main.py et README.txt par défaut ; créés lors du tout premier démarrage.
Carte microSD — si une carte est insérée, elle est montée sous /sdcard.
ROMFS — système de fichiers en lecture seule, mappé en mémoire, sous /rom, utilisé pour livrer de grands actifs de données (par ex. des modèles d’IA) qui bénéficient d’un accès sans copie. Monté automatiquement par MicroPython au démarrage, avant l’exécution de tout code Python utilisateur.

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

boot.py est exécuté à chaque réinitialisation logicielle (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 réinitialisations logicielles ultérieures réexécutent boot.py mais basculent directement vers le 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 présente 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 programmée se contente de faire clignoter le canal bleu de la LED RGB utilisateur comme un battement de cœur (deux impulsions courtes, court intervalle), afin que vous puissiez constater 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 résider 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 en présence d’une carte), créez un fichier vide nommé SKIPSD à la racine de /flash.

Lorsqu’elle est connectée 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 caméra 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 blocs passif, les fichiers créés ou modifiés par le code s’exécutant sur l’OpenMV Cam n’apparaîtront pas tant que l’hôte n’a pas remonté le lecteur. Si à la fois le système d’exploitation et l’OpenMV Cam écrivent sur le même système de fichiers en même temps, le système d’exploitation l’emportera et écrasera les modifications faites par la caméra. Utilisez la carte SD pour toutes les données que le script réécrit, et remontez le lecteur avant de lire ces fichiers depuis l’hôte.

Note

Le canal rouge de la LED RGB utilisateur peut s’allumer brièvement 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¶

La H7 Plus est livrée avec :

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

Indicateur de défaillance matérielle (hard fault)¶

Si la LED RGB utilisateur cycle rapidement à travers toutes les couleurs — assez vite pour ressembler à une LED blanche scintillante plutôt qu’à des teintes distinctes — le micrologiciel a rencontré une défaillance matérielle irrécupérable (hard fault). Reprogrammez le micrologiciel pour récupérer ; si la reprogrammation n’aide pas, la carte est peut-être physiquement endommagée.

Bibliothèques logicielles¶

Consultez l”index des bibliothèques pour la liste complète des modules — y compris ceux qui sont propres à la version H7 Plus.