OpenMV Cam RT1062

L’OpenMV Cam RT1062 est une carte de vision industrielle à faible consommation construite autour du NXP i.MX RT1062 (Cortex‑M7 @ 600 MHz). La carte associe un réseau USB‑C haut débit, le Wi‑Fi/Bluetooth et l’Ethernet 10/100 à un capteur OV5640 de 5 Mpx monté sur un support amovible. La caméra ne consomme qu’environ 30 µA depuis une batterie LiPo en sommeil profond, ce qui la rend bien adaptée aux projets alimentés par batterie.

OpenMV Cam RT1062

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

Points forts

  • NXP i.MX RT1062 Cortex‑M7 à 600 MHz.

  • 32 Mo de SDRAM externe (16 bits @ 160 MHz, 320 Mo/s) ainsi que 1 Mo de SRAM interne et 16 Mo de mémoire flash QSPI (133 MHz 4 bits SDR, lecture à 66 Mo/s) ; 4 Ko d’EEPROM sur R6+.

  • Capteur OV5640 de 5 Mpx à obturateur déroulant.

  • IMU embarquée (accéléromètre 3 axes 12 bits, ±2/4/8 g).

  • USB‑C haut débit (480 Mb/s, limite de courant 1,5 A), Ethernet 10/100 Mb/s (compatible PoE via shield), Wi‑Fi a/b/g/n + Bluetooth 5.1 (antenne sur puce ou option U.FL).

  • Logement microSD — SD jusqu’à 2 Go, SDHC jusqu’à 32 Go, SDXC jusqu’à 2 To.

  • Chargeur LiPo (500 mA sur R6+, 100 mA sur R4/R5), RTC avec plages de soudure pour batterie de secours. Le sommeil profond consomme ~30 µA sur batterie.

  • 14 broches d’E/S, toutes en sortie 3,3 V / tolérantes 3,3 V, 4 mA par broche, compatibles interruption.

  • LED RGB utilisateur, bouton SW utilisateur, bouton d’alimentation matériel (machine à états sommeil profond / réveil) et une LED d’état distincte pour la charge / l’USB / l’alimentation VIN.

Avertissement

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

Brochage

Brochage de l'OpenMV Cam RT1062 OV5640

Référence des broches

Nom de la broche

Fonction

P0

SPI1 MOSI / PWM2 B3

P1

SPI1 MISO / CAN0 TX

P2

SPI1 SCLK / PWM2 B3

P3

SPI1 SS / CAN0 RX

P4

I2C1 SCL / UART1 TX / PWM1 X2

P5

I2C1 SDA / UART1 RX / PWM1 X3

P6

ADC

P7

PWM2 A0

P8

PWM2 B0

P9

PWM1 A3

P10

PWM1 B3 / E/S de synchronisation de trame

P11

réveil (actif à l’état bas, relier à GND pour réveiller)

P12

RESET — relier à GND pour réinitialiser la carte (pas une GPIO)

P13

E/S numérique

P14

E/S numérique

ON/OFF

plage de connecteur reproduisant le bouton d’alimentation matériel (actif à l’état bas)

SW

bouton utilisateur (actif à l’état bas)

ST

bas sur alimentation VIN, haut sur alimentation USB

CHG

actif à l’état bas ; bas pendant qu’une batterie LiPo connectée se charge

PG

actif à l’état bas ; bas lorsque l’alimentation VIN ou USB est présente

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)

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. Assurez-vous qu’un seul pilote est actif à la fois.

Note

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

Ces broches passent par des adaptateurs de niveau afin de pouvoir fonctionner sur le rail RAW. Si vous avez absolument besoin d’un comportement GPIO en 3,3 V direct sur ON/OFF ou P11 (par exemple pour les piloter depuis un microcontrôleur 3,3 V sans passer par l’adaptateur), la carte expose des plages de soudure de pull‑up et de cavalier 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

P13 et P14 sont de simples GPIO par défaut, sans fonction spéciale. Les plages peuvent éventuellement être réacheminées vers d’autres signaux en refondant les ponts de soudure des résistances 0 ohm à l’arrière de la carte :

  • P13 ↔ état CHG / JTAG TRSTB

  • P14 ↔ état ST / JTAG TDI

La plupart des utilisateurs ne toucheront pas à ces cavaliers — laissez-les sur la valeur GPIO par défaut, sauf si vous avez spécifiquement besoin d’une relecture de la gestion d’alimentation ou du JTAG.

Broches d’alimentation

  • 3.3V — rail 3,3 V régulé. Sortie uniquement sur le RT1062 — 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 active (3,6 V – 5 V). Transporte la source active du moment (VIN, USB ou batterie connectée) et peut aussi être utilisée comme entrée. Vous devez piloter RAW à travers une diode en série lorsque vous y injectez de l’alimentation — sinon le courant remontera vers VIN/USB et endommagera l’alimentation ou la protection embarquée.

  • GND — masse commune.

Note

La puce de gestion d’alimentation embarquée sélectionne automatiquement celle de l’USB ou de la VIN ayant 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 disponible, et le contrôleur bascule sur la batterie pour maintenir la carte en fonctionnement si la VIN/l’USB faiblissent ou sont débranchés.

Note

L’arrière de la carte comporte des plages de soudure pour une batterie de secours RTC 3,3 V externe. Le câblage d’une pile bouton sur ces plages maintient la RTC en fonctionnement pendant que le reste de la carte n’est pas alimenté.

Astuce

Utilisez l”estimateur d’autonomie de batterie pour modéliser la durée pendant laquelle le RT1062 fonctionnera sur batterie pour un cycle de service actif / sommeil profond donné.

Broches Ethernet

Le RT1062 expose les paires MDI du PHY Ethernet 10/100 Mb/s sur des plages 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, soit intégré à un magjack, soit sur le shield) sont obligatoires entre le PHY et le câble. Le shield PoE OpenMV les inclut ; si vous concevez votre propre prise, utilisez un RJ45 à magnétiques intégrés ou un transformateur externe.

  • ETH_LED — LED de liaison/activité. Active à l’état bas quand une liaison est établie ; clignote sur le trafic.

  • ETH_TXP / ETH_TXN — paire de transmission.

  • ETH_RXP / ETH_RXN — paire de réception.

Note

Le connecteur expose également quatre plages sérigraphiées Reserved. Elles sont compatibles en empreinte avec les paires Ethernet gigabit de l”OpenMV N6 (DC P/N et DD P/N), de sorte que le même shield Ethernet / PoE peut être branché sur l’une ou l’autre carte. Le PHY du RT1062 ne gère que le 10/100 Mb/s, donc ces quatre plages n’ont aucune connectivité électrique — laissez-les non connectées.

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

  • RESET — relier à GND pour réinitialiser la carte. Sa libération permet au microcontrôleur de démarrer normalement.

  • SBL — relier à 3,3 V au moment d’alimenter la carte pour entrer en mode programme d’amorçage ROM (Serial Boot Loader). OpenMV IDE utilise ce mode pour reprogrammer le programme d’amorçage embarqué.

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

Note

Le RT1062 n’expose par défaut que le débogage SWD via ce connecteur. Le JTAG complet n’est pas disponible d’origine.

Périphériques embarqués

LED

Le RT1062 possède deux LED RGB :

  • LED RGB utilisateur — contrôlable 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 d’alimentation — pilotée directement par le matériel de gestion d’alimentation embarqué, sans contrôle logiciel. Utilisez-la pour voir en un coup d’œil l’état de l’alimentation.

    Pendant le fonctionnement :

    Canal

    Signification

    Bleu

    la VIN alimente la carte (éteinte sur 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.

Boutons

Le RT1062 possède deux boutons :

  • SW — bouton utilisateur à usage général. Lisible depuis le code comme une entrée GPIO normale active à l’état bas

    from machine import Pin

sw = Pin("SW", Pin.IN)
print(sw.value())

  • Bouton d’alimentation — piloté par une machine à états de contrôleur d’alimentation dédiée sur la carte RT1062, entièrement matérielle. Il n’est pas exposé au code utilisateur ; le contrôleur décide quoi faire en fonction de la durée d’appui :

    • Maintien pendant ~5 s pendant que la carte fonctionne → la machine à états passe en sommeil profond.

    • Maintien pendant ~1 s pendant que la carte est en sommeil profond → la machine à états rallume le système.

    Mettre la plage de connecteur ON/OFF à l’état bas a le même effet qu’appuyer sur le bouton d’alimentation embarqué — utile pour câbler un interrupteur externe ou piloter la ligne depuis un autre microcontrôleur.

Broches d’état d’alimentation

Trois entrées d’état actives à l’état bas provenant de la puce de gestion d’alimentation embarquée :

  • PG — bas lorsque l’alimentation VIN ou USB est présente. Toujours connectée.

  • ST — bas lorsque la carte fonctionne sur VIN, haut lorsqu’elle fonctionne sur alimentation USB. Non connectée par défaut.

  • CHG — bas pendant qu’une batterie LiPo connectée se charge. Non connectée par défaut.

from machine import Pin

power_ok = not Pin("PG", Pin.IN).value()

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 fournit des trames compressées directement à la caméra via le bus de la caméra, ce qui rend les captures haute résolution pratiques : csi.HD (1280×720), csi.FHD (1920×1080) et le plein 5 Mpx 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 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 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 rapide 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 copie 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")

IMU

Le micrologiciel du RT1062 ne relie pas l’accéléromètre embarqué au module imu — capteur imu. Communiquez plutôt directement avec lui via le bus I²C interne — la puce se trouve à l’adresse 0x15 et regroupe trois canaux d’accélération signés sur 12 bits ainsi qu’un octet de température 8 bits à partir du registre 0x03

import machine
import time

ADDR     = 0x15
DATA_REG = 0x03
LSB_PER_G = 1024.0    # ±2 g range

def s12(hi, lo):
    v = ((hi << 8) | lo) >> 4
    return v - 0x1000 if v & 0x800 else v

bus = machine.I2C(2)
print("Devices on I²C2:", bus.scan())

while True:
    d = bus.readfrom_mem(ADDR, DATA_REG, 7)
    x = s12(d[0], d[1]) / LSB_PER_G
    y = s12(d[2], d[3]) / LSB_PER_G
    z = s12(d[4], d[5]) / LSB_PER_G
    temp_c = d[6] * 0.586 + 25.0
    print("x=%+.2fg  y=%+.2fg  z=%+.2fg  T=%.1f°C" % (x, y, z, temp_c))
    time.sleep_ms(100)

EEPROM

Les cartes R6 et ultérieures incluent une EEPROM I²C générique de 4 Ko sur le même bus interne que l’accéléromètre. (Les révisions antérieures n’en ont pas — appeler ces extraits sur R4/R5 expirera sur un acquittement I²C manquant.) Utilisez l’API standard machine.I2C readfrom_mem / writeto_mem avec une adresse mémoire 16 bits

import machine
import time

EEPROM_ADDR = 0x50            # default address
PAGE_SIZE   = 32              # bytes per page (both read and write)
EEPROM_SIZE = 4096

bus = machine.I2C(2)

# Dump the entire 4 KB one page at a time
data = bytearray()
for offset in range(0, EEPROM_SIZE, PAGE_SIZE):
    data += bus.readfrom_mem(EEPROM_ADDR, offset, PAGE_SIZE, addrsize=16)
print(len(data), "bytes")

# Write a small payload back at offset 0 (fits in one page)
bus.writeto_mem(EEPROM_ADDR, 0, b"hello, world", addrsize=16)
time.sleep_ms(10)             # ~5 ms write cycle after each page

# Read it back
print(bus.readfrom_mem(EEPROM_ADDR, 0, 12, addrsize=16))

Les lectures et les écritures doivent toutes deux rester dans une page de 32 octets. Découpez tout transfert plus grand en un appel par page, et ajoutez le délai de cycle d’écriture d’environ 5 ms entre des écritures consécutives.

Wi‑Fi

Le module embarqué de la famille CYW43 est exposé via network — configuration réseau en tant qu’interface station. Après connexion, ipconfig("addr4") renvoie la paire (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 module sans fil 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-RT1062")
        print("Connected:", conn.device)
        await conn.disconnected()

asyncio.run(run())

Ethernet

Lorsqu’un RJ45 (avec composants magnétiques) est connecté aux plages MDI, le PHY 10/100 apparaît comme une interface LAN. Le DHCP s’exécute automatiquement dès que la liaison est établie

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 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’à 4 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

UART1

P4

P5

 
from machine import UART

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

I²C

Bus

SCL

SDA

I2C1

P4

P5

 
from machine import I2C

i2c = I2C(1, 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(1, addr=0x42, mem=buf)

SPI

Bus

MOSI

MISO

SCK

CS

SPI1

P0

P1

P2

P3

 
from machine import SPI
from machine import Pin

spi = SPI(1, 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

P1

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

La seule broche ADC utilisateur est P6, qui est à pleine échelle à ~3,3 V

from machine import ADC
import time

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

PWM

Broche

Canal FlexPWM

P0

PWM2 B3

P2

PWM2 B3

P4

PWM1 X2

P5

PWM1 X3

P7

PWM2 A0

P8

PWM2 B0

P9

PWM1 A3

P10

PWM1 B3

Pilotez l’une d’elles via machine.PWM

from machine import Pin, PWM

pwm = PWM(Pin("P9"), 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 I²C 4 — câblez le module à P4 (SCL) et P5 (SDA).

Chronométrage

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 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 temps réel

machine.RTC conserve l’heure murale à travers les réinitialisations et (avec la batterie de secours 3,3 V optionnelle câblée aux plages arrière, voir Broches d’alimentation) à travers une perte 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())

La 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 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 RT1062 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 volumes 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 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 en guise de battement de cœur (deux brèves impulsions, 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 des 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 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, 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 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 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 défaillance.

Tailles de stockage

Le RT1062 est livré avec :

  • /flash — système de fichiers FAT de 4 Mo, lecture/écriture.

  • /rom — ROMFS mappé en mémoire en lecture seule de 8 Mo, utilisé pour livrer des scripts et des modèles ML 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), lecture/écriture.

Indicateur de faute grave (hard fault)

Si la LED RGB utilisateur passe rapidement en boucle par toutes les couleurs — assez vite pour ressembler à une LED blanche scintillante plutôt qu’à des teintes distinctes — le micrologiciel a rencontré une faute 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 des bibliothèques pour la liste complète des modules — y compris ceux qui sont propres à la version RT1062.