OpenMV Cam RT1062

OpenMV Cam RT1062 è una scheda per visione artificiale a basso consumo costruita attorno all’NXP i.MX RT1062 (Cortex‑M7 @ 600 MHz). La scheda combina rete USB‑C high‑speed, Wi‑Fi/Bluetooth e Ethernet 10/100 con un sensore OV5640 da 5MP su un carrier rimovibile. In deep sleep la camera assorbe solo ~30 µA da una batteria LiPo, il che la rende particolarmente adatta a progetti alimentati a batteria.

OpenMV Cam RT1062

Per il datasheet completo, le foto e le dimensioni consulta la pagina prodotto di OpenMV Cam RT1062.

Caratteristiche principali

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

  • 32 MB di SDRAM esterna (16‑bit @ 160 MHz, 320 MB/s) più 1 MB di SRAM interna e 16 MB di flash QSPI (133 MHz 4‑bit SDR, 66 MB/s in lettura); 4 KB di EEPROM su R6+.

  • Sensore rolling‑shutter OV5640 da 5MP.

  • IMU integrata (accelerometro a 3 assi a 12‑bit, ±2/4/8 g).

  • USB‑C high‑speed (480 Mb/s, limite di corrente 1,5 A), Ethernet 10/100 Mb/s (compatibile PoE tramite shield), Wi‑Fi a/b/g/n + Bluetooth 5.1 (antenna su chip o opzione U.FL).

  • Socket microSD — SD fino a 2 GB, SDHC fino a 32 GB, SDXC fino a 2 TB.

  • Caricabatterie LiPo (500 mA su R6+, 100 mA su R4/R5), RTC con pad per batteria di backup. In deep sleep assorbe ~30 µA a batteria.

  • 14 pin di I/O, tutti con uscita 3,3 V / tolleranti 3,3 V, 4 mA per pin, con capacità di interrupt.

  • LED RGB utente, pulsante SW utente, pulsante di accensione hardware (macchina a stati deep‑sleep / wake) e un LED di stato separato per ricarica / USB / alimentazione VIN.

Avvertimento

I pin di I/O dell’RT1062 non sono tolleranti 5 V. Non collegare il dispositivo direttamente a un MCU a 5 V come l’Arduino Mega. Alimenta la scheda solo tramite VIN.

Pinout

Pinout OpenMV Cam RT1062 OV5640

Riferimento dei pin

Nome del pin

Funzione

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 / I/O frame sync

P11

wakeup (attivo basso, collegare a GND per risvegliare)

P12

RESET — collegare a GND per resettare la scheda (non è un GPIO)

P13

I/O digitale

P14

I/O digitale

ON/OFF

pad sull’header che replica il pulsante di accensione hardware (attivo basso)

SW

pulsante utente (attivo basso)

ST

basso con alimentazione VIN, alto con alimentazione USB

CHG

attivo basso; basso mentre una batteria LiPo collegata è in carica

PG

attivo basso; basso quando è presente alimentazione VIN o USB

LED_RED

canale rosso del LED RGB (attivo basso)

LED_GREEN

canale verde del LED RGB (attivo basso)

LED_BLUE

canale blu del LED RGB (attivo basso)

Nota

La linea di frame‑sync P10 è un bus condiviso. È cablata contemporaneamente all’MCU, al pin di trigger / esposizione del sensore della camera e all’header utente. La direzione è definita dall’applicazione — l’MCU, il sensore o un segnale esterno possono pilotarla a seconda di come è configurato il sensore. Assicurati che sia attivo un solo driver alla volta.

Nota

ON/OFF e P11 sono riferiti al rail RAW sempre attivo (non al rail 3,3 V commutato), quindi restano funzionanti mentre il resto della scheda è in modalità deep sleep / basso consumo. Entrambi gli ingressi sono attivi bassi.

Questi pin passano attraverso dei level shifter così da poter operare sul rail RAW. Se hai assolutamente bisogno di un comportamento GPIO diretto a 3,3 V su ON/OFF o P11 (ad esempio per pilotarli da un MCU a 3,3 V senza passare per lo shifter), la scheda espone pad jumper di pull‑up e da 0 ohm che permettono di bypassare lo shifter. Si tratta di una modifica hardware avanzata — la maggior parte degli utenti dovrebbe lasciarla così com’è.

Nota

P13 e P14 sono GPIO normali per impostazione predefinita, senza funzione speciale. I pad possono opzionalmente essere ri‑instradati ad altri segnali rifondendo i ponticelli di resistenze da 0 ohm sul retro della scheda:

  • P13 ↔ stato CHG / JTAG TRSTB

  • P14 ↔ stato ST / JTAG TDI

La maggior parte degli utenti non toccherà questi jumper — lasciali sul valore predefinito GPIO a meno che tu non abbia specificamente bisogno della lettura della gestione dell’alimentazione o di JTAG.

Pin di alimentazione

  • 3.3V — rail regolato a 3,3 V. Solo uscita sull’RT1062 — non immettere alimentazione esterna in questo pin. Fino a 1 A disponibile per gli shield.

  • VIN — ingresso 5 V. Alimenta la scheda e il caricabatterie LiPo integrato.

  • RAW — ingresso/uscita, sempre attivo (3,6 V – 5 V). Trasporta qualunque sorgente sia attiva (VIN, USB o batteria collegata) e può anche essere usato come ingresso. Devi pilotare RAW attraverso un diodo in serie quando vi immetti alimentazione — altrimenti la corrente rifluirà verso VIN/USB danneggiando l’alimentatore o la protezione integrata.

  • GND — massa comune.

Nota

Il chip di gestione dell’alimentazione integrato seleziona automaticamente quale tra USB o VIN abbia la tensione più alta per alimentare la scheda e il caricabatterie. Se è collegata una LiPo, questa viene caricata sul margine residuo, e il controller passa alla batteria per mantenere la scheda in funzione se VIN/USB calano o vengono scollegati.

Nota

Il retro della scheda ha pad di saldatura per una batteria di backup RTC esterna a 3,3 V. Collegando una batteria a bottone a questi pad si mantiene l’RTC in funzione mentre il resto della scheda è privo di alimentazione.

Suggerimento

Usa lo stimatore di durata della batteria per modellare quanto a lungo l’RT1062 funzionerà a batteria per un dato duty cycle attivo / deep‑sleep.

Pin Ethernet

L’RT1062 espone le coppie MDI del PHY Ethernet 10/100 Mb/s su pad dedicati accanto all’header GPIO. I pin MDI non possono essere cablati direttamente a un RJ45 — tra il PHY e il cavo è richiesta la magnetica Ethernet (un trasformatore di isolamento, integrato in un magjack o presente sullo shield). Lo shield PoE di OpenMV la include; se realizzi un tuo connettore, usa un RJ45 con magnetica integrata o un trasformatore esterno.

  • ETH_LED — LED di link/attività. Attivo basso quando il link è attivo; lampeggia in presenza di traffico.

  • ETH_TXP / ETH_TXN — coppia di trasmissione.

  • ETH_RXP / ETH_RXN — coppia di ricezione.

Nota

L’header espone anche quattro pad serigrafati Reserved. Questi sono compatibili come footprint con le coppie Ethernet gigabit dell”OpenMV N6 (DC P/N e DD P/N), così lo stesso shield Ethernet / PoE può essere collegato a entrambe le schede. Il PHY dell’RT1062 supporta solo 10/100 Mb/s, quindi quei quattro pad non hanno alcuna connessione elettrica — lasciali scollegati.

Pin di recovery e debug

  • RESET — collegare a GND per resettare la scheda. Rilasciandolo l’MCU si avvia normalmente.

  • SBL — collegare a 3,3 V durante l’alimentazione della scheda per entrare in modalità ROM bootloader (Serial Boot Loader). OpenMV IDE usa questa modalità per riprogrammare il bootloader integrato.

È presente un header dedicato ARM 10‑pin SWD/JTAG, compatibile con gli adattatori ST‑LINK e SEGGER J‑Link.

Nota

L’RT1062 espone per impostazione predefinita solo il debug SWD attraverso questo connettore. JTAG completo non è disponibile out of the box.

Periferiche integrate

LED

L’RT1062 ha due LED RGB:

  • LED RGB utente — controllabile via software, esposto come LED_RED, LED_GREEN e LED_BLUE

    from machine import LED

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

  • LED di alimentazione — pilotato direttamente dall’hardware di gestione dell’alimentazione integrato, senza controllo software. Usalo per capire a colpo d’occhio cosa sta facendo l’alimentazione.

    Durante il funzionamento:

    Canale

    Significato

    Blu

    VIN sta alimentando la scheda (spento con USB)

    Verde

    alimentazione USB o VIN presente

    Rosso

    ricarica di una batteria LiPo collegata

    In deep sleep tutti i canali sono spenti tranne il Rosso, che resta acceso mentre una LiPo è in carica.

Pulsanti

L’RT1062 ha due pulsanti:

  • SW — pulsante utente generico. Leggibile da codice come un normale ingresso GPIO attivo basso:

    from machine import Pin

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

  • Pulsante di accensione — pilotato da una macchina a stati dedicata del controller di alimentazione sulla scheda RT1062, interamente in hardware. Non è esposto al codice utente; il controller decide cosa fare in base a quanto a lungo viene tenuto premuto:

    • Tieni premuto per ~5 s mentre la scheda è in funzione → la macchina a stati passa al deep sleep.

    • Tieni premuto per ~1 s mentre la scheda è in deep sleep → la macchina a stati riaccende il sistema.

    Portare basso il pad dell’header ON/OFF ha lo stesso effetto di premere il pulsante di accensione integrato — utile per cablare un interruttore esterno o pilotare la linea da un altro microcontrollore.

Pin di stato dell’alimentazione

Tre ingressi di stato attivi bassi provenienti dal chip di gestione dell’alimentazione integrato:

  • PG — basso quando è presente alimentazione VIN o USB. Sempre collegato.

  • ST — basso quando la scheda funziona a VIN, alto quando funziona ad alimentazione USB. Non collegato per impostazione predefinita.

  • CHG — basso mentre una batteria LiPo collegata è in carica. Non collegato per impostazione predefinita.

from machine import Pin

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

Sensore della camera

L’OV5640 è pilotato tramite il modulo csi — sensori camera

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 ha un compressore JPEG integrato. Imposta csi.CSI.pixformat su csi.JPEG e il sensore consegna frame compressi direttamente alla cam sul bus della camera, il che rende pratiche le acquisizioni ad alta risoluzione: csi.HD (1280×720), csi.FHD (1920×1080) e i 5MP completi csi.WQXGA2 (2592×1944) vengono trasmessi tutti in JPEG. Regola la compressione con csi.CSI.quality (0‑100, più alto = frame più grandi, più dettaglio):

cam.pixformat(csi.JPEG)
cam.framesize(csi.WQXGA2)
cam.quality(90)

Il sensore si trova su un modulo rimovibile — sostituiscilo con uno qualsiasi degli altri moduli camera di OpenMV (global shutter, termico, risoluzione maggiore, ecc.) senza cambiare il resto della scheda.

Machine learning

ml — Machine Learning esegue modelli TFLite quantizzati sul Cortex‑M7 con kernel CMSIS‑NN — abbastanza veloce per detector compatti a pochi frame al secondo. I modelli sul filesystem di sola lettura /rom vengono caricati direttamente dalla flash senza copiarli in RAM. Ecco un detector BlazeFace 128×128 che sovrappone il volto rilevato e i suoi sei landmark su ogni frame:

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

Il firmware dell’RT1062 non collega l’accelerometro integrato al modulo imu — sensore imu. Comunica con esso direttamente sul bus I²C interno — il chip risiede all’indirizzo 0x15 e contiene tre canali di accelerazione con segno a 12‑bit più un byte di temperatura a 8‑bit a partire dal registro 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

Le schede R6 e successive includono una EEPROM I²C generica da 4 KB sullo stesso bus interno dell’accelerometro. (Le revisioni precedenti non ne hanno una — eseguire questi snippet su R4/R5 andrà in timeout per un ack I²C mancante.) Usa la classica API machine.I2C readfrom_mem / writeto_mem con un indirizzo di memoria a 16‑bit:

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

Sia le letture che le scritture devono restare all’interno di una pagina da 32 byte. Suddividi qualsiasi trasferimento più grande in una chiamata per pagina e aggiungi il ritardo del ciclo di scrittura di ~5 ms tra scritture consecutive.

Wi‑Fi

Il modulo della famiglia CYW43 integrato è esposto tramite network — configurazione di rete come interfaccia station. Dopo la connessione, ipconfig("addr4") restituisce la coppia (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

Lo stesso modulo wireless espone anche Bluetooth 5.1. Usa aioble — BLE asincrono per BLE compatibile con asyncio — ad esempio, fai advertising come periferica e attendi che un central si connetta:

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

Quando un RJ45 (con magnetica) è collegato ai pad MDI, il PHY 10/100 appare come interfaccia LAN. Il DHCP viene eseguito automaticamente non appena il link è attivo:

import network, time

lan = network.LAN()
lan.active(True)
while not lan.isconnected():
    time.sleep(1)
print("Ethernet IP:", lan.ipconfig("addr4")[0])

Scheda microSD

Quando una scheda è inserita viene montata automaticamente su /sdcard ed è utilizzabile attraverso il normale file system:

import os

for entry in os.listdir("/sdcard"):
    print(entry)

Riferimento dei bus

GPIO

Usa machine.Pin per leggere o pilotare uno qualsiasi dei pin serigrafati. Le uscite sono CMOS a 3,3 V e possono assorbire/erogare fino a 4 mA per pin.

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

Qualsiasi pin di ingresso può anche generare un interrupt sulle transizioni di fronte:

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

Lo stesso hardware può essere usato anche in modalità target (slave) tramite machine.I2CTarget per esporre una regione di memoria a un altro controller 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

Nota

CAN non è ancora supportato su questa scheda nel firmware 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

L’unico pin ADC utente è P6, che è a fondo scala a ~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

Pin

Canale 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

Pilotane uno qualsiasi tramite machine.PWM

from machine import Pin, PWM

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

Bus bit‑banged software

machine.SoftI2C e machine.SoftSPI funzionano su qualsiasi GPIO se ti serve un bus aggiuntivo.

Sensore termico (esterno)

Il firmware include il driver fir — driver del sensore termico (fir == far infrared) per imager termici cablati esternamente:

  • MLX90621 — array IR 16 × 4

  • MLX90640 — array IR 32 × 24

  • MLX90641 — array IR 16 × 12

  • AMG8833 — array IR 8 × 8

Cabla il modulo al bus I²C della scheda e leggi i frame con 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())

Il driver fir comunica con il sensore solo sull”I²C 4 — cabla il modulo a P4 (SCL) e P5 (SDA).

Temporizzazione

time

Il modulo time copre i ritardi bloccanti, i tick monotoni e la misurazione del tempo trascorso:

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)

Timer virtuali

machine.Timer pianifica callback periodici o one‑shot senza consumare uno slot di timer hardware. Passa -1 come id per usare un timer virtuale (software):

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

I valori di periodo sono in millisecondi. Chiama deinit() per fermare e rilasciare lo slot.

Real‑time clock

machine.RTC mantiene l’ora di sistema attraverso i reset e (con la batteria di backup opzionale a 3,3 V cablata ai pad posteriori, vedi Pin di alimentazione) attraverso la perdita totale di alimentazione:

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

L’RTC funziona anche durante il deep sleep, quindi puoi usarlo come sorgente di wakeup per machine.deepsleep().

Watchdog

machine.WDT resetta la scheda se l’applicazione si blocca. Una volta avviato non può essere fermato né riconfigurato — alimentalo periodicamente all’interno del tuo loop principale:

from machine import WDT

wdt = WDT(timeout=5_000)   # 5 second window
while True:
    # ...do work...
    wdt.feed()

Informazioni di boot e runtime

Finestra del bootloader USB

A ogni accensione la camera esegue un breve bootloader (pochi secondi) che permette a OpenMV IDE di aggiornare il firmware senza che l’utente debba entrare in modalità DFU. Allo scadere della finestra il bootloader passa il controllo a boot.py e poi a main.py.

Uno script in esecuzione può rientrare nel bootloader su richiesta chiamando machine.bootloader()

import machine

machine.bootloader()

Filesystem e ordine di boot

Il firmware dell’RT1062 monta fino a tre filesystem all’avvio:

  • Flash interna — sempre montata su /flash. Contiene main.py e README.txt per impostazione predefinita; creata al primissimo boot.

  • Scheda microSD — se una scheda è inserita viene montata su /sdcard.

  • ROMFS — filesystem di sola lettura, mappato in memoria, su /rom usato per distribuire grandi asset di dati (ad es. modelli AI) che beneficiano dell’accesso zero‑copy. Montato automaticamente da MicroPython all’avvio, prima che venga eseguito qualsiasi Python utente.

Dopo il montaggio, la directory di lavoro è impostata su /sdcard quando la scheda è presente, altrimenti su /flash. L’interprete esegue quindi gli script da quella directory:

  • boot.py viene eseguito a ogni soft reset (cold boot, Ctrl‑D dal REPL, o ogni volta che lo script in esecuzione termina).

  • main.py viene eseguito solo al cold boot, immediatamente dopo boot.py. I soft reset successivi rieseguono boot.py ma passano direttamente al REPL — per rieseguire main.py devi resettare completamente la scheda.

Mettere un boot.py o main.py sulla scheda SD sovrascrive la copia in flash senza toccarla — entrambi i file vengono cercati nella directory di boot (/sdcard quando la scheda è montata, altrimenti /flash).

Il main.py predefinito fornito su una scheda appena flashata si limita a far lampeggiare il canale blu del LED RGB utente come heartbeat (due brevi impulsi, breve pausa), così puoi capire che il firmware si è avviato correttamente senza alcun host collegato.

sys.path viene esteso per includere tutti e tre i filesystem e le loro sottodirectory lib/, così i moduli importabili possono risiedere in /flash/lib, /sdcard/lib o /rom/lib.

Per forzare il sistema a ignorare una scheda SD inserita (ad esempio per eseguire il main.py in flash anche con una scheda presente), crea un file vuoto chiamato SKIPSD nella radice di /flash.

Quando è collegata via USB, il filesystem di boot (/sdcard se è presente una scheda, altrimenti /flash) viene anche enumerato come unità di archiviazione di massa USB sull’host, permettendoti di modificare boot.py, main.py e qualsiasi altro file direttamente. Espelli l’unità prima di resettare la camera così che l’host svuoti le sue scritture in cache.

Nota

Poiché il sistema operativo tratta l’unità come un dispositivo a blocchi passivo, i file creati o modificati dal codice in esecuzione sulla OpenMV Cam non compariranno finché l’host non rimonta l’unità. Se sia il sistema operativo sia la OpenMV Cam scrivono sullo stesso filesystem nello stesso momento, il sistema operativo prevarrà e sovrascriverà le modifiche fatte dalla camera. Usa la scheda SD per qualsiasi dato che lo script riscrive, e rimonta prima di leggere quei file dall’host.

Nota

Il canale rosso del LED RGB utente potrebbe accendersi brevemente mentre l’host legge da o scrive sull’unità di archiviazione di massa USB — è un indicatore di attività gestito dal firmware, non un guasto.

Dimensioni di archiviazione

L’RT1062 viene fornito con:

  • /flash — filesystem FAT da 4 MB, lettura/scrittura.

  • /rom — ROMFS di sola lettura mappata in memoria da 8 MB, usata per distribuire script e modelli ML che beneficiano dell’accesso mmap zero‑copy.

  • /sdcard — dimensione completa di qualsiasi scheda microSD inserita (quando presente), lettura/scrittura.

Indicatore di hard‑fault

Se il LED RGB utente sta ciclando rapidamente attraverso tutti i colori — abbastanza velocemente da sembrare un LED bianco scintillante anziché tinte distinte — il firmware ha incontrato un hard fault irrecuperabile. Riprogramma il firmware per ripristinare; se la riprogrammazione non aiuta, la scheda potrebbe essere fisicamente danneggiata.

Librerie software

Consulta l”indice della libreria per l’elenco completo dei moduli — inclusi quelli esclusivi della build RT1062.