OpenMV N6¶

L’OpenMV N6 est construit autour du STMicroelectronics STM32N657 (Cortex‑M55 @ 800 MHz) doté d’un NPU intégré à 1 GHz évalué à 600 GOPS INT8. La carte associe le NPU au capteur global‑shutter PAG7936 1 MP monté sur un support amovible, à de l’Ethernet gigabit, à de l’USB‑C haute vitesse, au Wi‑Fi et au Bluetooth 5.1, et exécute l’inférence YOLOv8/YOLOv11 à 30 FPS tout en diffusant la vidéo en direct.

Pour la fiche technique complète, les photos et les dimensions, consultez la page produit OpenMV N6.

Points forts¶

STM32N657 Cortex‑M55 à 800 MHz (1280 DMIPS) avec ARM Helium SIMD 128 bits — 6,4 gigaops de débit vectoriel.
NPU à 1 GHz, 600 GOPS INT8 — exécute la détection YOLOv8/YOLOv11 à 30 FPS.
ISP pour du RAW Bayer jusqu’à 5MP, GPU 2D pour la mise à l’échelle et la rotation 3D, encodage H.264 jusqu’au 1080p, et codec JPEG matériel.
64 Mo de SDRAM externe (16 bits @ 200 MHz DDR, 800 Mo/s) plus 4,2 Mo de SRAM interne et 32 Mo de mémoire flash octale (200 MHz DDR, 400 Mo/s).
Capteur PAG7936 couleur global‑shutter 1 MP.
IMU embarquée (accéléromètre + gyroscope) et microphone pour la fusion audio + mouvement.
USB‑C haute vitesse (480 Mb/s, limite de courant à 1,5 A), Ethernet gigabit (compatible PoE via un shield), Wi‑Fi a/b/g/n + Bluetooth 5.1 (antenne sur puce ou option U.FL).
Connecteur microSD — SD jusqu’à 2 Go, SDHC jusqu’à 32 Go, SDXC jusqu’à 2 To.
Chargeur LiPo (charge rapide 500 mA), ADC de tension de batterie, RTC avec 8 Ko de RAM de sauvegarde et une broche dédiée pour la batterie de sauvegarde.
18 broches d’E/S, toutes en sortie 3,3 V / tolérantes 3,3 V, 20 mA par broche, compatibles interruptions.
LED RGB utilisateur, bouton utilisateur, et une LED d’état distincte pour la charge / l’USB / l’alimentation VIN.

Avertissement

Les broches d’E/S du N6 ne sont pas tolérantes au 5 V. Ne connectez pas l’appareil directement à un microcontrôleur 5 V comme l’Arduino Mega. Alimentez le N6 uniquement par VIN.

Brochage¶

Référence des broches¶

Nom de broche	Fonction
P0	SPI2 MOSI / I2S2 SDO
P1	SPI2 MISO / I2S2 SDI
P2	SPI2 SCLK / UART4 TX / CAN1 TX / I2S2 CK
P3	SPI2 SS / UART4 RX / CAN1 RX / I2S2 WS
P4	I2C2 SCL / UART3 TX / TIM2 CH3 / I3C2 SCL
P5	I2C2 SDA / UART3 RX / TIM2 CH4 / I3C2 SDA
P6	TIM12 CH1 (pas d’ADC sur cette broche — voir `P6_ADC`)
P6_ADC	entrée ADC 12 bits dédiée (reliée en interne à P6)
P7	TIM4 CH1
P8	TIM4 CH2
P9	TIM17 CH1
P10	TIM15 CH2 / E/S de synchronisation de trame
P11	réveil (actif bas, WKUP3)
P12	RESET — relier à GND pour réinitialiser la carte (pas une GPIO)
P13	UART7 RX
P14	UART7 TX
P15	SPI4 CS
P16	SPI4 SCK
P17	SPI4 MISO
P18	SPI4 MOSI
SW	bouton utilisateur (actif bas)
ONOFF (SW2)	bouton de réveil après sommeil profond (actif bas, WKUP2)
ST	bas sous alimentation VIN, haut sous alimentation USB
CHG	actif bas ; bas pendant qu’une batterie LiPo connectée se charge
PG	actif bas ; bas lorsque l’alimentation VIN ou USB est présente
BAT_ADC	canal ADC interne mesurant la tension de la batterie LiPo connectée
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)

Note

La ligne de synchronisation de trame P10 est un bus partagé. Elle est câblée à la fois au microcontrôleur, à la broche de déclenchement / d’exposition du capteur de la caméra et au connecteur utilisateur. Le sens est défini par l’application — le microcontrôleur, le capteur ou un signal externe peut la piloter selon la configuration du capteur (certains capteurs peuvent utiliser la même broche comme entrée de déclenchement ou comme sortie d’exposition). Assurez-vous qu’un seul pilote est actif à la fois.

Note

ONOFF et P11 sont référencés au rail RAW toujours alimenté (et non au rail 3,3 V commuté), de sorte qu’ils restent fonctionnels pendant que le reste de la carte est en sommeil profond / mode basse consommation. Les deux entrées sont actives bas.

Ces broches passent par des adaptateurs de niveau pour pouvoir fonctionner sur le rail RAW. Si vous avez absolument besoin d’un comportement GPIO 3,3 V direct sur ONOFF ou P11 (par exemple pour les piloter depuis un microcontrôleur 3,3 V sans passer par l’adaptateur), la carte expose des pastilles de cavalier de tirage et de 0 ohm qui permettent de contourner l’adaptateur. Il s’agit d’une modification matérielle avancée — la plupart des utilisateurs devraient s’en abstenir.

Note

P15–P18 sont partagées avec le PHY Ethernet Gigabit, qui est câblé et actif par défaut. Pour utiliser ces broches comme E/S utilisateur, vous devez ressouder la résistance 0 ohm située à l’arrière de la carte sur la position GPIO. Cela désactive uniquement l’Ethernet gigabit — l’Ethernet 10/100 Mb/s continue de fonctionner sur ses broches dédiées.

Broches d’alimentation¶

3.3V — rail régulé 3,3 V. Sortie uniquement sur le N6 — n’injectez pas d’alimentation externe dans cette broche. Jusqu’à 1 A disponible pour les shields.
VIN — entrée 5 V. Alimente la carte et le chargeur LiPo embarqué.
RAW — entrée/sortie, toujours alimenté (3,6 V – 5 V). Transporte la source active du moment (VIN, USB ou batterie connectée), et peut aussi être utilisé comme entrée. Vous devez piloter RAW à travers une diode en série lorsque vous y injectez de l’alimentation — sinon le courant reflue vers VIN/USB et endommage l’alimentation ou la protection embarquée.
GND — masse commune.

Note

La puce de gestion de l’alimentation embarquée choisit automatiquement laquelle de l”USB ou de VIN présente la tension la plus élevée pour alimenter la carte et le chargeur de batterie. Si une LiPo est connectée, elle se charge sur la marge restante, et le contrôleur bascule sur la batterie pour maintenir la carte en marche si VIN/USB faiblissent ou sont débranchés.

Note

L’arrière de la carte comporte des pastilles à souder pour une batterie de sauvegarde RTC 3,3 V externe. Le câblage d’une pile bouton sur ces pastilles maintient le RTC et les 8 Ko de RAM de sauvegarde en fonctionnement pendant que le reste de la carte n’est pas alimenté.

Astuce

Utilisez l”estimateur d’autonomie de batterie pour modéliser combien de temps le N6 fonctionnera sur une batterie pour un cycle de service actif / sommeil profond donné.

Broches Ethernet¶

Le N6 expose les paires MDI du PHY Ethernet sur des pastilles dédiées à côté du connecteur GPIO. Les broches MDI ne peuvent pas être câblées directement à un RJ45 — des composants magnétiques Ethernet (un transformateur d’isolation, intégré à un magjack ou présent sur le shield) sont obligatoires entre le PHY et le câble. Le shield PoE OpenMV les inclut ; si vous concevez votre propre connecteur, utilisez un RJ45 à magnétiques intégrés ou un transformateur externe.

ETH_LED — LED de lien/activité. Active bas lorsqu’un lien est établi ; clignote en présence de trafic.
DA P / DA N — paire A (TX en 10/100, utilisée à toutes les vitesses).
DB P / DB N — paire B (RX en 10/100, utilisée à toutes les vitesses).
DC P / DC N — paire C, utilisée uniquement en gigabit.
DD P / DD N — paire D, utilisée uniquement en gigabit.

Le 10/100 Mb/s ne nécessite que les paires A et B. Le gigabit nécessite les quatre paires A–D.

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

RESET — relier à GND pour réinitialiser la carte. Le relâcher laisse le microcontrôleur démarrer normalement.
BOOT0 — relier au 3,3 V lors de la mise sous tension de la carte pour entrer en mode bootloader ROM. OpenMV IDE utilise ce mode pour reflasher le programme d’amorçage embarqué.
BOOT1 — interrupteur qui place la carte en mode développeur pour une utilisation avec les outils ST (un ST‑LINK connecté au connecteur SWD/JTAG ARM 10 broches). Laissez-le désactivé pour un fonctionnement normal avec le micrologiciel et les outils OpenMV.

Un connecteur SWD/JTAG ARM 10 broches dédié est installé, compatible avec les adaptateurs ST‑LINK et SEGGER J‑Link.

Périphériques embarqués¶

LED¶

Le N6 possède deux LED RGB :

LED RGB utilisateur — contrôlable par logiciel, exposée sous LED_RED, LED_GREEN et LED_BLUE

from machine import LED

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

LED d’alimentation — pilotée directement par le matériel de gestion de l’alimentation embarqué, sans contrôle logiciel. Utilisez-la pour voir d’un coup d’œil ce que fait l’alimentation.

En fonctionnement :

Canal

Signification

Bleu

VIN alimente la carte (éteint sous USB)

Vert

alimentation USB ou VIN présente

Rouge

charge d’une batterie LiPo connectée

En sommeil profond, tous les canaux sont éteints sauf le rouge, qui reste allumé tant qu’une LiPo se charge.

Canal	Signification
Bleu	VIN alimente la carte (éteint sous USB)
Vert	alimentation USB ou VIN présente
Rouge	charge d’une batterie LiPo connectée

Boutons utilisateur¶

Le N6 possède deux boutons :

SW — bouton utilisateur à usage général. Actif lorsqu’il est tiré au niveau bas.
ONOFF (SW2) — bouton de réveil. Le seul bouton capable de sortir la carte du sommeil profond.

from machine import Pin

sw    = Pin("SW",    Pin.IN)   # user button
onoff = Pin("ONOFF", Pin.IN)   # SW2 — wakes from deep sleep
print(sw.value(), onoff.value())

Pour mettre la carte en sommeil profond et la faire réveiller par ONOFF (SW2), appelez simplement machine.deepsleep() — aucune configuration de réveil n’est requise, le bouton est câblé directement à l’entrée WKUP2

import machine

machine.deepsleep()   # press ONOFF (SW2) to wake the board

Vous pouvez aussi câbler ONOFF comme interrupteur d’alimentation logiciel. Déclenchez sur le front montant — la ligne se stabilise au niveau haut une fois que l’utilisateur relâche le bouton, de sorte que l’appui suivant est sans ambiguïté un événement de réveil

import machine
from machine import Pin

def power_off(_):
    machine.deepsleep()

Pin("ONOFF", Pin.IN).irq(power_off, Pin.IRQ_RISING)

# ...rest of the application runs here. Press ONOFF once to sleep,
# press it again to wake.

Broches d’état de l’alimentation¶

Trois entrées d’état actives bas permettent au micrologiciel de voir ce que fait la puce de gestion de l’alimentation embarquée :

ST — bas lorsque la carte fonctionne sur VIN, haut lorsqu’elle fonctionne sur alimentation USB.
CHG — bas pendant qu’une batterie LiPo connectée se charge.
PG — bas lorsque l’alimentation VIN ou USB est présente.

from machine import Pin

on_vin    = not Pin("ST",  Pin.IN).value()
charging  = not Pin("CHG", Pin.IN).value()
power_ok  = not Pin("PG",  Pin.IN).value()

Capteur de la caméra¶

Le PAG7936 est piloté via le module csi — capteurs de caméra

import csi

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

while True:
    img = cam.snapshot()

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

Le PAG7936 prend en charge le mode déclenché — l’intégration des pixels s’aligne exactement sur chaque appel csi.CSI.snapshot plutôt que sur l’horloge de trame en flux libre, ce qui est utile pour synchroniser la capture sur un événement externe ou un autre capteur. Activez-le via csi.CSI.ioctl avec csi.IOCTL_SET_TRIGGERED_MODE. La cadence d’images chute à environ la moitié de celle du mode en flux libre car la lecture ne se chevauche plus avec l’intégration de la trame suivante

cam.ioctl(csi.IOCTL_SET_TRIGGERED_MODE, True)

NPU¶

Le NPU Neural‑ART à 1 GHz du N6 (600 GOPS INT8) est exposé via le module ml — Apprentissage automatique. Les modèles stockés sur le système de fichiers en lecture seule /rom se chargent directement depuis la mémoire flash sans copie en RAM, de sorte que même de gros détecteurs tiennent confortablement aux côtés du tampon d’image en direct. Exécutez un détecteur YOLOv8 sur chaque trame et dessinez les prédictions par-dessus l’image en direct

import csi
import time
import ml
from ml.postprocessing.ultralytics import YoloV8

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

# Load YOLO V8 model from ROM FS.
model = ml.Model("/rom/yolov8n_192.tflite", postprocess=YoloV8(threshold=0.4))
print(model)

# Visualization parameters.
n = len(model.labels)
model_class_colors = [
    (int(255 * i // n), int(255 * (n - i - 1) // n), 255)
    for i in range(n)
]

clock = time.clock()
while True:
    clock.tick()
    img = csi0.snapshot()

    # boxes is a list of list per class of ((x, y, w, h), score) tuples
    boxes = model.predict([img])

    # Draw bounding boxes around the detected objects
    for i, class_detections in enumerate(boxes):
        rects = [r for r, score in class_detections]
        labels = [model.labels[i] for j in range(len(rects))]
        colors = [model_class_colors[i] for j in range(len(rects))]
        ml.utils.draw_predictions(img, rects, labels, colors, format=None)

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

Microphone¶

Le micro embarqué est capturé via audio — Module Audio. Chaque tampon arrive sous forme de bytearray PCM 16 bits signé, ce qui facilite son envoi vers ulab/numpy pour un traitement DSP rapide. Un détecteur de volume sonore simple — affiche un message chaque fois que le volume RMS franchit un seuil

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

IMU¶

L’accéléromètre + gyroscope embarqué sous le module de la caméra est exposé via imu — capteur imu

import imu
import time

while True:
    print(imu.acceleration_mg())   # (x, y, z) in milli‑g
    print(imu.angular_rate_mdps()) # (x, y, z) in milli‑deg/s
    time.sleep_ms(100)

Wi‑Fi¶

Le CYW43439 embarqué est exposé via network — configuration réseau comme interface station. Après la connexion, ipconfig("addr4") renvoie le couple (ip, netmask)

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 CYW43439 expose également le Bluetooth 5.1. Utilisez aioble — BLE asynchrone pour du BLE compatible asyncio — par exemple, s’annoncer comme 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="OpenMV-N6")
        print("Connected:", conn.device)
        await conn.disconnected()

asyncio.run(run())

Ethernet¶

Lorsqu’un RJ45 (avec composants magnétiques) est connecté aux pastilles MDI, le PHY gigabit apparaît comme une interface LAN. Le DHCP s’exécute automatiquement dès que le lien est établi

import network, time

lan = network.LAN()
lan.active(True)
while not lan.isconnected():
    time.sleep(1)
print("Ethernet IP:", lan.ipconfig("addr4")[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 et peuvent absorber/fournir jusqu’à 20 mA par broche.

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
UART3	P4	P5
UART4	P2	P3
UART7	P14	P13

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
SPI4	P18	P17	P16	P15

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
CAN1	P2	P3

Note

Le CAN n’est pas encore pris en charge sur cette carte dans le micrologiciel v5.0.0.

from machine import CAN

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

ADC¶

Les deux canaux ADC passent par un diviseur de tension tamponné par un amplificateur opérationnel avant d’atteindre le microcontrôleur, de sorte que read_u16() est mappé sur une tension d’entrée pleine échelle différente sur chaque broche.

Broche	Pleine échelle	Remarques
P6_ADC	~3,3 V	pastille à usage général, reliée en interne à P6
BAT_ADC	~5,0 V	canal interne pour la batterie LiPo

from machine import ADC
import time

adc = ADC("P6_ADC")
bat = ADC("BAT_ADC")

while True:
    print("P6:", adc.read_u16() * 3.3 / 65535, "V")
    print("BAT:", bat.read_u16() * 5.0 / 65535, "V")
    time.sleep_ms(100)

PWM¶

Broche	Minuteur / canal
P4	TIM2 CH3
P5	TIM2 CH4
P6	TIM12 CH1
P7	TIM4 CH1
P8	TIM4 CH2
P9	TIM17 CH1
P10	TIM15 CH2

Pilotez l’un d’eux via machine.PWM

from machine import Pin, PWM

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

Bus logiciels en bit-banging¶

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

Temporisation¶

time¶

Le module time couvre les délais bloquants, les ticks 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 ponctuelles 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 murale à travers les réinitialisations et (avec la batterie de sauvegarde 3,3 V optionnelle câblée sur les pastilles arrière, voir Broches d’alimentation) à travers une coupure totale d’alimentation

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

Le RTC fonctionne également pendant le sommeil profond, vous pouvez donc l’utiliser comme source de réveil pour machine.deepsleep().

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¶

Fenêtre du bootloader USB¶

À chaque mise sous tension, la caméra exécute un court bootloader (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 bootloader passe la main à boot.py puis à main.py.

Un script en cours d’exécution peut ré-entrer dans le bootloader à la demande en appelant machine.bootloader()

import machine

machine.bootloader()

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

Le micrologiciel du N6 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 gros volumes 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 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 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 fourni 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 impulsions brèves, courte pause), de sorte que vous pouvez constater 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 également comme un lecteur de stockage de masse USB sur l’hôte, ce qui vous permet 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 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’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 toute donnée que le script réécrit, et remontez-la 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’une panne.

Tailles de stockage¶

Le N6 est livré avec :

/flash — système de fichiers FAT de 4 Mo, en lecture/écriture.
/rom — ROMFS de 24 Mo en lecture seule mappé en mémoire, utilisé pour embarquer 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 panne grave¶

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 ne résout rien, la carte est peut-être endommagée physiquement.

Bibliothèques logicielles¶

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