OpenMV Cam M4¶

L’OpenMV Cam M4 est une carte de vision industrielle compacte à base de Cortex‑M4, construite autour du STM32F427 de STMicroelectronics cadencé à 180 MHz, avec 256 Ko de SRAM interne et 1 Mo de mémoire flash interne. Le capteur OV7725 fourni capture des trames de 320×240 en niveaux de gris ou RGB565, et le connecteur utilisateur à 9 broches expose les périphériques UART, I²C, SPI, CAN, ADC/DAC et PWM.

Note

L’OV7725 était le capteur standard des cartes M4 de production. Les toutes premières variantes de la M4 étaient livrées avec l’OmniVision OV2640 à la place — même pipeline d’aperçu QVGA, mais l’OV2640 peut aussi capturer des trames JPEG jusqu’à l’UXGA (1600×1200). Les deux capteurs sont pilotés par la même API csi — capteurs de caméra.

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

Points forts¶

STM32F427 de STMicroelectronics Cortex‑M4 à 180 MHz.
256 Ko de SRAM interne — pas de SDRAM externe.
1 Mo de mémoire flash interne (pas de mémoire flash QSPI externe).
Capteur OV7725 (ou OV2640 sur les toutes premières variantes M4) — 320×240 en niveaux de gris 8 bits ou RGB565 ; l’OV2640 peut en plus capturer jusqu’à l’UXGA (1600×1200) en JPEG.
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.
9 broches d’E/S, tolérantes au 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 au 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 sous faible luminosité.

Note

La M4 n’a 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 via l’USB ou VIN.

Brochage¶

Référence des broches¶

Nom de la broche	Fonction
P0	SPI2 MOSI
P1	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	TIM4 CH1
P8	TIM4 CH2
RESET	tirer vers GND pour réinitialiser la carte
BOOT0	tirer vers 3,3 V à la mise sous tension pour le programme d’amorçage DFU / ROM
SWCLK	horloge ARM SWD (accès débogueur)
SWDIO	données ARM SWD (accès débogueur)
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)

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 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 la M4 en injectant directement 3,3 V sur la broche 3.3V si vous ne voulez pas passer par le régulateur embarqué. Dans ce cas, n’appliquez pas en même temps VIN ou l’alimentation USB — réinjecter dans 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 combien de temps la M4 fonctionnera sur une 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. Le 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é.

SWCLK et SWDIO sont dérivés sous forme de broches de connecteur ordinaires (et non d’un connecteur SWD dédié). Câblez RESET, SWCLK, SWDIO, GND et 3,3 V sur un adaptateur ST‑LINK ou SEGGER J-Link pour déboguer la carte.

Périphériques embarqués¶

LED¶

La M4 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 tandis 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 la logique)
```
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¶

Le capteur fourni (OV7725 sur les cartes standard, OV2640 sur les toutes premières variantes) 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 est soudé à la carte sur la M4 — il n’est pas sur un module interchangeable.

Note

Sur les cartes OV7725, la broche FSIN (synchronisation de trame) du capteur est câblée au MCU mais la prise en charge logicielle n’a pas été ajoutée.

Sur les cartes OV2640, les broches STROBE, FREX (exposition de trame) et EXPST (réinitialisation d’exposition) du capteur sont câblées au MCU mais leur prise en charge logicielle n’a pas été ajoutée.

Connecteurs de servos¶

La face arrière de la carte comporte deux pastilles de soudure pour connecteurs de servos qui dérivent le connecteur de servo standard à 3 broches (signal / VIN / GND) pour P7 et P8. Les broches de signal correspondent directement aux canaux 1 et 2 de TIM4 (les mêmes canaux utilisés par pyb.Servo), et la broche V+ de chaque connecteur est câblée directement à VIN, de sorte que les servos tirent leur courant du rail d’entrée plutôt que du régulateur 3,3 V.

Soudez une paire de connecteurs à 3 broches coudés dans les pastilles et raccordez deux servos de modélisme pour piloter un support pan-and-tilt

from pyb import Servo

pan  = Servo(1)              # P7 — TIM4 CH1
tilt = Servo(2)              # P8 — TIM4 CH2
pan.angle(0)
tilt.angle(0)

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 au 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
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

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¶

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 tolérante au 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 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 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 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).

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

Watchdog¶

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 à 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 cède 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 M4 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 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 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 se termine).
main.py n’est exécuté qu’au démarrage à froid, immédiatement après boot.py. Les réinitialisations logicielles suivantes réexécutent boot.py mais passent directement au REPL — pour réexécuter 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 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 en présence d’une carte), créez un fichier vide nommé SKIPSD à la racine de /flash.

Lorsqu’elle est connectée via l’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, ce qui vous permet 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 ne remonte pas le lecteur. Si le système d’exploitation et l’OpenMV Cam écrivent en même temps dans le même système de fichiers, 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 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’un défaut.

Tailles de stockage¶

La M4 est livrée avec :

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

Indicateur de défaut 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 — le micrologiciel a rencontré un défaut 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 spécifiques à la version M4.