OpenMV Cam RT1062

OpenMV Cam RT1062 är ett strömsnålt maskinseendekort byggt kring NXP i.MX RT1062 (Cortex‑M7 @ 600 MHz). Kortet kombinerar USB‑C‑nätverk med hög hastighet, Wi‑Fi/Bluetooth och 10/100 Ethernet med en OV5640 5MP‑sensor på en löstagbar bärare. Kameran drar bara ~30 µA från ett LiPo‑batteri i djupsömn, vilket gör den väl lämpad för batteridrivna projekt.

OpenMV Cam RT1062

För fullständigt datablad, foton och mått, se produktsidan för OpenMV Cam RT1062.

Höjdpunkter

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

  • 32 MB externt SDRAM (16‑bitars @ 160 MHz, 320 MB/s) plus 1 MB internt SRAM och 16 MB QSPI‑flashminne (133 MHz 4‑bitars SDR, 66 MB/s läsning); 4 KB EEPROM på R6+.

  • OV5640 5MP rolling‑shutter‑sensor.

  • Inbyggd IMU (12‑bitars 3‑axlig accelerometer, ±2/4/8 g).

  • Höghastighets‑USB‑C (480 Mb/s, 1,5 A strömbegränsning), 10/100 Mb/s Ethernet (PoE‑kapabel via sköld), Wi‑Fi a/b/g/n + Bluetooth 5.1 (chipantenn eller U.FL‑alternativ).

  • microSD‑sockel — SD upp till 2 GB, SDHC upp till 32 GB, SDXC upp till 2 TB.

  • LiPo‑laddare (500 mA på R6+, 100 mA på R4/R5), RTC med pads för backupbatteri. Djupsömn drar ~30 µA på batteri.

  • 14 I/O‑stift, alla med 3,3 V utgång / 3,3 V toleranta, 4 mA per stift, avbrottskapabla.

  • Användar‑RGB‑LED, användar‑SW‑knapp, hårdvarustrombrytarknapp (tillståndsmaskin för djupsömn / väckning), och en separat status‑LED för laddning / USB / VIN‑ström.

Varning

RT1062:ans I/O‑stift är inte 5 V‑toleranta. Anslut inte enheten direkt till en 5 V MCU som Arduino Mega. Strömförsörj kortet endast via VIN.

Stiftschema

OpenMV Cam RT1062 OV5640 stiftschema

Stiftreferens

Stiftnamn

Funktion

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 / bildrute‑synk‑I/O

P11

väckning (aktivt låg, anslut till GND för att väcka)

P12

RESET — dra till GND för att återställa kortet (inte en GPIO)

P13

digital I/O

P14

digital I/O

ON/OFF

header‑pad som replikerar hårdvarustrombrytarknappen (aktivt låg)

SW

användarknapp (aktivt låg)

ST

låg vid VIN‑ström, hög vid USB‑ström

CHG

aktivt låg; låg medan ett anslutet LiPo‑batteri laddas

PG

aktivt låg; låg när VIN‑ eller USB‑ström finns

LED_RED

RGB‑LED:ns röda kanal (aktivt låg)

LED_GREEN

RGB‑LED:ns gröna kanal (aktivt låg)

LED_BLUE

RGB‑LED:ns blå kanal (aktivt låg)

Anteckning

P10:s bildrute‑synk‑linje är en delad buss. Den är kopplad till MCU:n, kamerasensorns trigger‑/exponeringsstift och användarheadern på en gång. Riktningen är applikationsdefinierad — MCU:n, sensorn eller en extern signal kan driva den beroende på hur sensorn är konfigurerad. Se till att bara en drivare är aktiv åt gången.

Anteckning

ON/OFF och P11 refererar till den alltid påslagna RAW‑skenan (inte den växlade 3,3 V‑skenan), så de förblir funktionella medan resten av kortet är i djupsömn / lågeffektläge. Båda ingångarna är aktivt låga.

Dessa stift går genom nivåomvandlare så att de kan ligga på RAW‑skenan. Om du absolut behöver 3,3 V‑direkt GPIO‑beteende på ON/OFF eller P11 (till exempel för att driva dem från en 3,3 V MCU utan att gå genom omvandlaren), exponerar kortet pull‑up‑ och 0‑ohms‑bryggpads som låter dig kringgå omvandlaren. Detta är en avancerad hårdvarumodifiering — de flesta användare bör låta det vara.

Anteckning

P13 och P14 är vanlig GPIO som standard utan någon specialfunktion. Padsen kan valfritt dirigeras om till andra signaler genom att löda om 0‑ohms‑motståndsbryggorna på baksidan av kortet:

  • P13 ↔ CHG‑status / JTAG TRSTB

  • P14 ↔ ST‑status / JTAG TDI

De flesta användare rör inte dessa byglar — låt dem vara på GPIO‑standardvärdet om du inte specifikt behöver återläsning av strömhantering eller JTAG.

Strömstift

  • 3.3V — reglerad 3,3 V‑skena. Endast utgång på RT1062 — mata inte extern ström in i detta stift. Upp till 1 A tillgängligt för sköldar.

  • VIN — 5 V‑ingång. Strömförsörjer kortet och den inbyggda LiPo‑laddaren.

  • RAW — in‑/utgång, alltid påslagen (3,6 V – 5 V). För den källa som är aktiv (VIN, USB eller anslutet batteri), och kan också användas som ingång. Du måste driva RAW genom en seriediod när du matar ström in i den — annars kommer ström att flöda tillbaka in i VIN/USB och skada strömförsörjningen eller det inbyggda skyddet.

  • GND — gemensam jord.

Anteckning

Det inbyggda strömhanteringschipet väljer automatiskt vilken av USB eller VIN som har högst spänning för att strömförsörja kortet och batteriladdaren. Om ett LiPo är anslutet laddas det på det överblivna utrymmet, och styrenheten faller tillbaka på batteriet för att hålla kortet igång om VIN/USB sjunker eller kopplas ur.

Anteckning

Kortets baksida har lödpads för ett externt 3,3 V RTC‑backupbatteri. Att koppla en knappcell till dessa pads håller RTC:n igång medan resten av kortet är strömlöst.

Tips

Använd batterilivslängdsuppskattaren för att modellera hur länge RT1062 körs på ett batteri för en given aktiv / djupsömns‑arbetscykel.

Ethernet‑stift

RT1062 exponerar den 10/100 Mb/s Ethernet‑PHY:ns MDI‑par på dedikerade pads bredvid GPIO‑headern. MDI‑stiften är inte säkra att koppla direkt till en RJ45 — Ethernet‑magnetik (en isolationstransformator, antingen inbyggd i ett magjack eller på skölden) är obligatorisk mellan PHY:n och kabeln. OpenMV PoE‑skölden inkluderar den; om du bygger ditt eget jack, använd en RJ45 med integrerad magnetik eller en extern transformator.

  • ETH_LED — länk/aktivitets‑LED. Aktivt låg när en länk är uppe; blinkar vid trafik.

  • ETH_TXP / ETH_TXN — sändningspar.

  • ETH_RXP / ETH_RXN — mottagningspar.

Anteckning

Headern exponerar också fyra pads med silktrycket Reserved. Dessa är fotavtrycks‑kompatibla med gigabit‑Ethernet‑paren på OpenMV N6 (DC P/N och DD P/N) så att samma Ethernet‑/PoE‑sköld kan kopplas in på endera kortet. RT1062:ans PHY klarar bara 10/100 Mb/s, så dessa fyra pads har ingen elektrisk anslutning — lämna dem oanslutna.

Återställnings‑ och felsökningsstift

  • RESET — dra till GND för att återställa kortet. Att släppa den låter MCU:n starta upp normalt.

  • SBL — dra till 3,3 V medan kortet strömförsörjs för att gå in i ROM‑bootloader‑läge (Serial Boot Loader). OpenMV IDE använder detta läge för att flasha om den inbyggda startladdaren.

En dedikerad ARM 10‑stifts SWD/JTAG‑header är monterad, kompatibel med ST‑LINK‑ och SEGGER J‑Link‑adaptrar.

Anteckning

RT1062 exponerar endast SWD‑felsökning genom denna kontakt som standard. Fullständig JTAG är inte tillgänglig direkt.

Inbyggd kringutrustning

LED:ar

RT1062 har två RGB‑LED:ar:

  • Användar‑RGB‑LED — programstyrbar, exponerad som LED_RED, LED_GREEN och LED_BLUE

    from machine import LED

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

  • Ström‑LED — driven direkt av den inbyggda strömhanteringshårdvaran, ingen programstyrning. Använd den för att med en blick avläsa vad strömförsörjningen gör.

    Under körning:

    Kanal

    Betydelse

    Blå

    VIN strömförsörjer kortet (av vid USB)

    Grön

    USB‑ eller VIN‑ström finns

    Röd

    laddar ett anslutet LiPo‑batteri

    I djupsömn är alla kanaler släckta utom Röd, som fortfarande lyser medan ett LiPo laddas.

Knappar

RT1062 har två knappar:

  • SW — allmän användarknapp. Läsbar från kod som en vanlig aktivt‑låg GPIO‑ingång:

    from machine import Pin

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

  • Strömbrytarknapp — driven av en dedikerad tillståndsmaskin för strömstyrning på RT1062‑kortet, helt i hårdvara. Den är inte exponerad för användarkod; styrenheten avgör vad som ska göras baserat på hur länge den hålls intryckt:

    • Håll i ~5 s medan kortet är igång → tillståndsmaskinen övergår till djupsömn.

    • Håll i ~1 s medan kortet är i djupsömn → tillståndsmaskinen sätter på systemet igen.

    Att dra ON/OFF‑header‑paden låg har samma effekt som att trycka på den inbyggda strömbrytarknappen — användbart för att koppla in en extern brytare eller driva linjen från en annan mikrokontroller.

Strömstatusstift

Tre aktivt‑låga statusingångar från det inbyggda strömhanteringschipet:

  • PG — låg när VIN‑ eller USB‑ström finns. Alltid ansluten.

  • ST — låg när kortet körs på VIN, hög när det körs på USB‑ström. Inte ansluten som standard.

  • CHG — låg medan ett anslutet LiPo‑batteri laddas. Inte ansluten som standard.

from machine import Pin

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

Kamerasensor

OV5640 drivs genom modulen csi — kamerasensorer

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

OV5640 har en inbyggd JPEG‑kompressor. Ställ in csi.CSI.pixformat på csi.JPEG så levererar sensorn komprimerade bildrutor direkt till kameran över kamerabussen, vilket gör högupplösta tagningar praktiska: csi.HD (1280×720), csi.FHD (1920×1080) och hela 5MP csi.WQXGA2 (2592×1944) strömmas alla som JPEG. Justera komprimeringen med csi.CSI.quality (0-100, högre = större bildrutor, mer detaljer):

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

Sensorn sitter på en löstagbar modul — byt den mot någon av de andra OpenMV‑kameramodulerna (global shutter, termisk, högre upplösning osv.) utan att ändra resten av kortet.

Maskininlärning

ml — Maskininlärning kör kvantiserade TFLite‑modeller på Cortex‑M7 med CMSIS‑NN‑kärnor — tillräckligt snabbt för kompakta detektorer i några bildrutor per sekund. Modeller på det skrivskyddade /rom‑filsystemet laddas direkt från flashminnet utan att kopieras till RAM. Här är en 128×128 BlazeFace‑detektor som lägger det detekterade ansiktet och dess sex landmärken som överlägg på varje bildruta:

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

RT1062:ans fasta programvara kopplar inte den inbyggda accelerometern till modulen imu — imu-sensor. Prata istället med den direkt över den interna I²C‑bussen — chipet ligger på adress 0x15 och packar tre signerade 12‑bitars accelerationskanaler plus en 8‑bitars temperaturbyte med början på register 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

R6‑kort och senare inkluderar ett generiskt 4 KB I²C‑EEPROM på samma interna buss som accelerometern. (Tidigare revisioner har inget — att anropa dessa kodsnuttar på R4/R5 leder till timeout på ett saknat I²C‑ack.) Använd standard‑machine.I2C‑API:t readfrom_mem / writeto_mem med en 16‑bitars minnesadress:

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

Både läsningar och skrivningar måste hålla sig inom en 32‑byte‑sida. Dela upp varje större överföring i ett anrop per sida, och lägg till ~5 ms skrivcykelfördröjning mellan på varandra följande skrivningar.

Wi‑Fi

Den inbyggda modulen ur CYW43‑familjen exponeras via network — nätverkskonfiguration som ett stationsgränssnitt. Efter anslutning returnerar ipconfig("addr4") paret (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

Samma trådlösa modul exponerar också Bluetooth 5.1. Använd aioble — Asynkron BLE för asyncio‑vänlig BLE — annonsera till exempel som en kringutrustning och vänta på att en central ansluter:

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

När en RJ45 (med magnetik) är ansluten till MDI‑padsen visas 10/100‑PHY:n som ett LAN‑gränssnitt. DHCP körs automatiskt så snart länken kommer upp:

import network, time

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

microSD‑kort

När ett kort sätts i monteras det automatiskt på /sdcard och kan användas genom det vanliga filsystemet:

import os

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

Bussreferens

GPIO

Använd machine.Pin för att läsa eller driva något av de silktryckta stiften. Utgångar är 3,3 V CMOS och kan sjunka/källa upp till 4 mA per stift.

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

Vilket ingångsstift som helst kan också utlösa ett avbrott vid flankövergångar:

def handler(pin):
    print("triggered:", pin)

Pin("P1", Pin.IN, Pin.PULL_UP).irq(
    handler, Pin.IRQ_FALLING | Pin.IRQ_RISING,
)

UART

Buss

TX

RX

UART1

P4

P5

 
from machine import UART

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

I²C

Buss

SCL

SDA

I2C1

P4

P5

 
from machine import I2C

i2c = I2C(1, freq=400_000)
i2c.scan()
i2c.writeto(0x76, b"hi")

Samma hårdvara kan också användas i target‑läge (slav) genom machine.I2CTarget för att exponera en minnesregion för en annan I²C‑styrenhet:

from machine import I2CTarget

buf = bytearray(32)
target = I2CTarget(1, addr=0x42, mem=buf)

SPI

Buss

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

Buss

TX

RX

CAN1

P1

P3

Anteckning

CAN stöds ännu inte på detta kort i fast programvara 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

Det enda ADC‑stiftet för användare är P6, som är fullskaligt vid ~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

Stift

FlexPWM‑kanal

P0

PWM2 B3

P2

PWM2 B3

P4

PWM1 X2

P5

PWM1 X3

P7

PWM2 A0

P8

PWM2 B0

P9

PWM1 A3

P10

PWM1 B3

Driv någon av dem via machine.PWM

from machine import Pin, PWM

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

Mjukvaru‑bit‑bangade bussar

machine.SoftI2C och machine.SoftSPI fungerar på vilken GPIO som helst om du behöver en extra buss.

Termisk sensor (extern)

Den fasta programvaran inkluderar drivrutinen fir — drivrutin för värmesensor (fir == far infrared) för externt kopplade termiska kameror:

  • MLX90621 — 16 × 4 IR‑array

  • MLX90640 — 32 × 24 IR‑array

  • MLX90641 — 16 × 12 IR‑array

  • AMG8833 — 8 × 8 IR‑array

Koppla modulen till kortets I²C‑buss och läs bildrutor med 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())

fir‑drivrutinen pratar bara med sensorn över I²C 4 — koppla modulen till P4 (SCL) och P5 (SDA).

Tidsstyrning

time

Modulen time täcker blockerande fördröjningar, monotona ticks och mätning av förfluten tid:

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)

Virtuella timrar

machine.Timer schemalägger periodiska eller engångs‑återanrop utan att förbruka en hårdvarutimer‑plats. Skicka -1 som id för att använda en virtuell (mjukvaru‑)timer:

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

Periodvärden anges i millisekunder. Anropa deinit() för att stoppa och frigöra platsen.

Realtidsklocka

machine.RTC håller väggklockstid över återställningar och (med det valfria 3,3 V‑backupbatteriet kopplat till padsen på baksidan, se Strömstift) över full strömförlust:

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

RTC:n körs också genom djupsömn, så du kan använda den som väckningskälla för machine.deepsleep().

Vakthund

machine.WDT återställer kortet om applikationen hänger sig. När den väl startats kan den inte stoppas eller konfigureras om — mata den regelbundet inuti din huvudloop:

from machine import WDT

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

Boot‑ och körtidsinformation

USB‑bootloader‑fönster

Vid varje uppstart kör kameran en kort bootloader (några sekunder) som låter OpenMV IDE uppdatera den fasta programvaran utan att användaren behöver gå in i DFU‑läge. När fönstret löper ut lämnar bootloadern över till boot.py och sedan main.py.

Ett körande skript kan gå in i bootloadern igen på begäran genom att anropa machine.bootloader()

import machine

machine.bootloader()

Filsystem och boot‑ordning

RT1062:ans fasta programvara monterar upp till tre filsystem vid uppstart:

  • Internt flashminne — alltid monterat på /flash. Innehåller main.py och README.txt som standard; skapas vid allra första uppstarten.

  • microSD‑kort — om ett kort sätts i monteras det på /sdcard.

  • ROMFS — skrivskyddat, minnesmappat filsystem på /rom som används för att leverera stora datatillgångar (t.ex. AI‑modeller) som drar nytta av zero‑copy‑åtkomst. Monteras automatiskt av MicroPython vid start, innan någon användar‑Python körs.

Efter montering sätts arbetskatalogen till /sdcard när kortet finns, annars /flash. Tolken kör sedan skript från den katalogen:

  • boot.py körs vid varje mjuk återställning (kallstart, Ctrl‑D från REPL:en, eller närhelst det körande skriptet returnerar).

  • main.py körs endast vid kallstart, omedelbart efter boot.py. Efterföljande mjuka återställningar kör boot.py igen men hoppar direkt till REPL:en — för att köra main.py igen måste du återställa kortet helt.

Att lägga en boot.py eller main.py på SD‑kortet åsidosätter kopian i flashminnet utan att röra den — båda filerna slås upp i boot‑katalogen (/sdcard när kortet är monterat, annars /flash).

Den standard‑main.py som levereras på ett nyligen flashat kort blinkar bara användar‑RGB‑LED:ns blå kanal som en hjärtslagsindikator (två korta pulser, kort paus), så att du kan se att den fasta programvaran startade rent utan någon värd ansluten.

sys.path utökas till att inkludera alla tre filsystemen och deras lib/‑underkataloger, så importerbara moduler kan ligga i /flash/lib, /sdcard/lib eller /rom/lib.

För att tvinga systemet att ignorera ett insatt SD‑kort (till exempel för att köra flash‑main.py även med ett kort isatt), skapa en tom fil med namnet SKIPSD i roten av /flash.

När den är ansluten över USB enumereras boot‑filsystemet (/sdcard om ett kort finns, annars /flash) också som en USB‑masslagringsenhet på värden, vilket låter dig redigera boot.py, main.py och alla andra filer direkt. Mata ut enheten innan du återställer kameran så att värden tömmer sina cachade skrivningar.

Anteckning

Eftersom operativsystemet behandlar enheten som en passiv blockenhet kommer filer som skapas eller ändras av kod som körs på OpenMV Cam inte att visas förrän värden monterar om enheten. Om både operativsystemet och OpenMV Cam skriver till samma filsystem samtidigt vinner operativsystemet och skriver över ändringar gjorda av kameran. Använd SD‑kortet för all data som skriptet skriver tillbaka, och montera om innan du läser dessa filer från värden.

Anteckning

Användar‑RGB‑LED:ns röda kanal kan kort lysa upp medan värden läser från eller skriver till USB‑masslagringsenheten — detta är en firmware‑driven aktivitetsindikator, inte ett fel.

Lagringsstorlekar

RT1062 levereras med:

  • /flash — 4 MB FAT‑filsystem, läs/skriv.

  • /rom — 8 MB skrivskyddat minnesmappat ROMFS, används för att leverera skript och ML‑modeller som drar nytta av zero‑copy‑mmap‑åtkomst.

  • /sdcard — full storlek på vilket microSD‑kort som än sätts i (när det finns), läs/skriv.

Hård‑felindikator

Om användar‑RGB‑LED:n snabbt cyklar genom alla färger — tillräckligt snabbt för att det tenderar att se ut som en glittrande vit LED snarare än distinkta nyanser — har den fasta programvaran träffat ett oåterhämtningsbart hårt fel. Flasha om den fasta programvaran för att återhämta; om omflashning inte hjälper kan kortet vara fysiskt skadat.

Programvarubibliotek

Se biblioteksindexet för den fullständiga listan över moduler — inklusive vilka som är unika för RT1062‑bygget.