OpenMV Cam H7¶

L’OpenMV Cam H7 est une carte de vision industrielle Cortex‑M7 construite autour du STMicroelectronics STM32H743 cadencé à 480 MHz, avec 1 Mo de SRAM interne, 2 Mo de mémoire flash interne et un codec JPEG matériel. La carte est livrée en deux révisions de capteur — la H7 avec l”OV7725 et la H7 R2 avec le ON Semi MT9M114 — mais le micrologiciel, le brochage et l’API Python sont identiques.

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

Points forts¶

STMicroelectronics STM32H743 Cortex‑M7 à 480 MHz (1027 DMIPS).
Encodeur/décodeur JPEG matériel.
1 Mo de SRAM interne — pas de SDRAM externe.
2 Mo de mémoire flash interne (pas de mémoire flash QSPI externe).
Capteur OV7725 (ou MT9M114 sur la H7 R2).
USB pleine vitesse (12 Mb/s) — apparaît comme VCP + stockage de masse USB pour l’hôte.
Connecteur microSD — SD jusqu’à 2 Go, SDHC jusqu’à 32 Go, SDXC jusqu’à 2 To.
Connecteur de batterie LiPo (pas de chargeur intégré — 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 d’interruption. 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 en faible luminosité.

Note

La H7 ne possède aucune puce de gestion d’alimentation intégrée : il n’y a pas de chargeur de batterie, pas d’ADC de tension de batterie, pas de LED de charge / d’état d’alimentation, et pas de bouton d’alimentation matériel. Connectez une batterie 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	TIM4 CH3
RESET	reliez à GND pour réinitialiser la carte
SYN	pastille de synchronisation de trame — câblée uniquement au capteur de la caméra
BOOT0	reliez à 3,3 V à la mise sous tension pour le programme d’amorçage DFU / ROM
LED_RED	canal rouge de la LED RGB (actif à l’état bas)
LED_GREEN	canal vert de la LED RGB (actif à l’état bas)
LED_BLUE	canal bleu de la LED RGB (actif à l’état bas)
LED_IR	LED IR haute puissance (les deux canaux pilotés ensemble)

Note

La pastille SYN du connecteur est reliée directement à la ligne de déclenchement / d’exposition du capteur de la caméra — elle n’est pas routée vers le MCU sur la H7. Pilotez-la ou lisez-la de manière externe ; vous ne pouvez pas la 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 à travers le régulateur intégré.
GND — masse commune.

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

Note

Lorsque l’USB et le VIN/LiPo sont présents en même temps, l’entrée VIN/LiPo l’emporte — le commutateur d’alimentation intégré la privilégie par rapport à l’USB pour alimenter la carte.

Avertissement

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

Avertissement

Vous pouvez alimenter la H7 en fournissant 3,3 V directement sur la broche 3.3V si vous ne voulez pas passer par le régulateur intégré. Dans ce cas, n’appliquez pas non plus le VIN ou l’alimentation USB en même temps — alimenter le régulateur à contre-courant pendant 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 combien de temps la H7 fonctionnera sur batterie pour un cycle de service actif / veille profonde donné.

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

RESET — reliez à GND pour réinitialiser la carte. La relâcher laisse le MCU démarrer normalement.
BOOT0 — reliez à 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 reflasher le programme d’amorçage intégré.

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

Périphériques intégrés¶

LED¶

La H7 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 à l’état haut au niveau matériel, alors que le micrologiciel traite toutes les autres LED intégrées comme actives à l’état bas, utilisez donc 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’OV7725 (ou le MT9M114 sur la H7 R2) 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()

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

Carte microSD¶

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 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 également 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 sur 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
P9	TIM4 CH3

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 physiquement présents 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 l’ensemble du minuteur pour un fonctionnement à 50 Hz, ne mélangez donc pas machine.PWM sur P7/P8/P9 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 en 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 sur le 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 2 — câblez le module sur P4 (SCL) et P5 (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 en temps réel¶

machine.RTC conserve l’heure de l’horloge murale d’une réinitialisation à l’autre

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 plus être 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 sur le démarrage et l’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é-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 de la 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 lors du tout premier démarrage.
Carte microSD — si 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, utilisé pour embarquer de grands actifs de données (par exemple 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 positionné 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 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 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 se contente de faire clignoter le canal bleu de la LED RGB utilisateur comme battement de cœur (deux brèves impulsions, courte pause), ce qui vous permet de savoir que le micrologiciel a démarré correctement 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 en USB, le système de fichiers de démarrage (/sdcard si une carte est présente, sinon /flash) s’énumère aussi 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 exécuté sur l’OpenMV Cam n’apparaîtront pas tant que l’hôte n’a pas remonté le lecteur. Si le système d’exploitation et l’OpenMV Cam écrivent dans le même système de fichiers en même temps, le système d’exploitation l’emporte et écrase 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 — il s’agit d’un indicateur d’activité piloté par le micrologiciel, pas d’un défaut.

Tailles de stockage¶

La H7 est livrée avec :

/flash — système de fichiers FAT de 128 Ko, en lecture/écriture.
/rom — ROMFS de 128 Ko en lecture seule mappé en mémoire.
/sdcard — taille complète de la carte microSD insérée (lorsqu’elle est présente), en lecture/écriture.

Indicateur de panne grave (hard fault)¶

Si la LED RGB utilisateur défile rapidement à travers toutes les couleurs — assez vite pour qu’elle ait tendance à ressembler à une LED blanche scintillante plutôt qu’à des teintes distinctes — le micrologiciel a rencontré une panne 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¶

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