OpenMV Cam M7¶

L’OpenMV Cam M7 est une carte de vision industrielle Cortex‑M7 construite autour du STMicroelectronics STM32F765 cadencé à 216 MHz, avec 512 Ko de SRAM interne et 2 Mo de mémoire flash interne. Le capteur OV7725 fourni capture des trames en niveaux de gris 640×480 ou RGB565 320×240 jusqu’à 150 FPS, et le connecteur utilisateur à 10 broches expose les périphériques UART, I²C, SPI, CAN, ADC/DAC et PWM.

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

Points forts¶

STMicroelectronics STM32F765 Cortex‑M7 à 216 MHz.
512 Ko de SRAM interne — pas de SDRAM externe.
2 Mo de mémoire flash interne (pas de mémoire flash QSPI externe).
Capteur OV7725 — niveaux de gris 640×480 ou RGB565 320×240 jusqu’à 150 FPS.
USB pleine vitesse (12 Mb/s) — apparaît comme VCP + stockage de masse USB pour l’hôte.
Logement microSD — SD jusqu’à 2 Go, SDHC jusqu’à 32 Go, SDXC jusqu’à 2 To.
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érer les 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 de forte puissance pour un éclairage actif en vision en faible luminosité.

Note

Le M7 ne dispose d”aucune puce de gestion de l’alimentation embarquée : pas de connecteur de batterie, pas de chargeur de batterie, pas d’ADC de tension de batterie, pas de LED de charge / d’état de l’alimentation, et pas de bouton d’alimentation matériel. Alimentez la carte par USB ou VIN.

Brochage¶

Référence des broches¶

Nom de broche	Fonction
P0	UART1 RX / SPI2 MOSI
P1	UART1 TX / SPI2 MISO
P2	SPI2 SCK / CAN2 TX
P3	SPI2 NSS (CS) / CAN2 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	tirer vers GND pour réinitialiser la carte
SYN	pad de synchronisation de trame — câblé uniquement au capteur de la caméra
BOOT0	tirer vers 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 de forte puissance (les deux canaux pilotés ensemble)

Note

Le pad SYN du connecteur est relié directement à la ligne de déclenchement / d’exposition du capteur de la caméra — il n’est pas routé vers le MCU sur le M7. Pilotez-le ou lisez-le en externe ; vous ne pouvez pas le commuter depuis MicroPython.

Broches d’alimentation¶

3.3V — rail 3,3 V régulé. 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.

Note

Lorsque l’USB et le VIN sont tous deux présents, c’est celui qui a la tension la plus élevée qui alimente la carte — les diodes embarquées sélectionnent simplement le rail le plus fort.

Avertissement

Vous pouvez alimenter le M7 en injectant directement 3,3 V sur la broche 3.3V si vous ne souhaitez pas passer par le régulateur embarqué. Dans ce cas, n’appliquez pas en même temps VIN ou l’alimentation USB — refouler le courant vers le régulateur 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 la durée de fonctionnement du M7 sur batterie pour un cycle de service actif / veille profonde donné.

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

RESET — tirer vers GND pour réinitialiser la carte. La relâcher permet au MCU de démarrer normalement.
BOOT0 — tirer vers 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 embarqué.

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 embarqués¶

LED¶

Le M7 dispose d’une seule LED RGB utilisateur ainsi que d’une paire de LED IR 850 nm de forte 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 dans le matériel alors que le micrologiciel traite toutes les autres LED embarquées comme actives à l’état bas, 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 caméra¶

L’OV7725 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()

Sur le M7, le capteur est soudé à la carte — il n’est pas monté sur un module interchangeable.

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 laquelle des broches sérigraphiées. 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 é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(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¶

Bus	TX	RX
CAN2	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 uniquement tolérante 3,3 V — 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, donc ne mélangez pas machine.PWM sur P7/P8/P9 avec pyb.Servo dans le même script.

Pilotez l’un d’eux via machine.PWM:

from machine import Pin, PWM

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

Bus logiciels à commutation par bits (bit‑banged)¶

machine.SoftI2C et machine.SoftSPI fonctionnent sur n’importe quelle 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 l”I²C 2 — câblez le module sur P4 (SCL) et P5 (SDA).

Synchronisation¶

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 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 en millisecondes. Appelez deinit() pour arrêter et libérer l’emplacement.

Horloge temps réel¶

machine.RTC conserve l’heure de l’horloge 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é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 M7 monte jusqu’à trois systèmes de fichiers au démarrage :

Mémoire flash interne — toujours montée sur /flash. Contient par défaut main.py et README.txt ; créée tout au 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 livrer de gros 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 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 relancent boot.py mais passent directement au REPL — pour relancer main.py, vous devez réinitialiser entièrement 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 courtes impulsions, court intervalle), de sorte que vous pouvez 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 directement boot.py, main.py et tout autre fichier. É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 bloc 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’aura 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 toute donnée 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, et non d’une panne.

Tailles de stockage¶

Le M7 est livré avec :

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

Indicateur de panne grave (hard‑fault)¶

Si la LED RGB utilisateur défile rapidement à travers toutes les couleurs — assez vite pour ressembler à une LED blanche scintillante plutôt qu’à des teintes distinctes — c’est que le micrologiciel a rencontré une panne grave irrécupérable. Reflashez le micrologiciel pour récupérer ; si le reflashage n’aide pas, la carte est peut-être physiquement endommagée.

Bibliothèques logicielles¶

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