OpenMV Cam RT1062

De OpenMV Cam RT1062 is een energiezuinig machine vision-bord gebouwd rond de NXP i.MX RT1062 (Cortex‑M7 @ 600 MHz). Het bord combineert USB‑C high‑speed netwerken, Wi‑Fi/Bluetooth en 10/100 Ethernet met een OV5640 5MP-sensor op een verwisselbare drager. De camera trekt in diepe slaap slechts ~30 µA uit een LiPo-batterij, waardoor hij uitstekend geschikt is voor projecten op batterijvoeding.

OpenMV Cam RT1062

Voor de volledige datasheet, foto’s en afmetingen, zie de productpagina van de OpenMV Cam RT1062.

Hoogtepunten

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

  • 32 MB extern SDRAM (16‑bit @ 160 MHz, 320 MB/s) plus 1 MB intern SRAM en 16 MB QSPI flashgeheugen (133 MHz 4‑bit SDR, 66 MB/s lezen); 4 KB EEPROM op R6+.

  • OV5640 5MP rolling‑shutter sensor.

  • Ingebouwde IMU (12‑bit 3‑assige versnellingsmeter, ±2/4/8 g).

  • High‑speed USB‑C (480 Mb/s, 1,5 A stroomlimiet), 10/100 Mb/s Ethernet (PoE‑geschikt via shield), Wi‑Fi a/b/g/n + Bluetooth 5.1 (chipantenne of U.FL-optie).

  • microSD-aansluiting — SD tot 2 GB, SDHC tot 32 GB, SDXC tot 2 TB.

  • LiPo-lader (500 mA op R6+, 100 mA op R4/R5), RTC met pads voor back‑upbatterij. Diepe slaap trekt ~30 µA op batterij.

  • 14 I/O-pinnen, allemaal 3,3 V uitgang / 3,3 V tolerant, 4 mA per pin, interrupt‑geschikt.

  • RGB-LED voor gebruiker, SW-knop voor gebruiker, hardware-aan/uitknop (diepe slaap / wake state machine), en een aparte status-LED voor opladen / USB / VIN-voeding.

Waarschuwing

De I/O-pinnen van de RT1062 zijn niet 5 V tolerant. Sluit het apparaat niet rechtstreeks aan op een 5 V-MCU zoals de Arduino Mega. Voed het bord uitsluitend via VIN.

Pinout

OpenMV Cam RT1062 OV5640 Pinout

Pinreferentie

Pinnaam

Functie

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

P11

wakeup (actief laag, verbind met GND om te wekken)

P12

RESET — trek naar GND om het bord te resetten (geen GPIO)

P13

digitale I/O

P14

digitale I/O

ON/OFF

headerpad die de hardware-aan/uitknop nabootst (actief laag)

SW

gebruikersknop (actief laag)

ST

laag op VIN-voeding, hoog op USB-voeding

CHG

actief‑laag; laag terwijl een aangesloten LiPo-batterij oplaadt

PG

actief‑laag; laag wanneer VIN- of USB-voeding aanwezig is

LED_RED

rode kanaal van RGB-LED (actief laag)

LED_GREEN

groene kanaal van RGB-LED (actief laag)

LED_BLUE

blauwe kanaal van RGB-LED (actief laag)

Notitie

De P10 frame‑sync-lijn is een gedeelde bus. Hij is tegelijk verbonden met de MCU, de trigger‑/belichtingspin van de camerasensor en de gebruikersheader. De richting is door de toepassing bepaald — de MCU, de sensor of een extern signaal kan hem aansturen, afhankelijk van hoe de sensor is geconfigureerd. Zorg ervoor dat er steeds maar één driver tegelijk actief is.

Notitie

ON/OFF en P11 zijn gerefereerd aan de altijd‑aan RAW-rail (niet de geschakelde 3,3 V-rail), zodat ze functioneel blijven terwijl de rest van het bord in diepe slaap / energiezuinige modus is. Beide ingangen zijn actief laag.

Deze pinnen lopen via level shifters zodat ze op de RAW-rail kunnen meeliften. Als je echt 3,3 V‑directe GPIO-werking op ON/OFF of P11 nodig hebt (bijvoorbeeld om ze vanaf een 3,3 V-MCU aan te sturen zonder via de shifter te gaan), heeft het bord pull‑up- en 0‑ohm-jumperpads waarmee je de shifter kunt omzeilen. Dit is een geavanceerde hardware-aanpassing — de meeste gebruikers laten dit beter ongemoeid.

Notitie

P13 en P14 zijn standaard gewone GPIO zonder speciale functie. De pads kunnen optioneel naar andere signalen worden omgeleid door de 0‑ohm-weerstandssoldeerbruggen aan de achterkant van het bord opnieuw te solderen:

  • P13 ↔ CHG-status / JTAG TRSTB

  • P14 ↔ ST-status / JTAG TDI

De meeste gebruikers raken deze jumpers niet aan — laat ze op de GPIO-standaard staan, tenzij je specifiek terugmelding van het energiebeheer of JTAG nodig hebt.

Voedingspinnen

  • 3.3V — gereguleerde 3,3 V-rail. Alleen uitgang op de RT1062 — voer geen externe voeding in deze pin. Tot 1 A beschikbaar voor shields.

  • VIN — 5 V-ingang. Voedt het bord en de ingebouwde LiPo-lader.

  • RAW — ingang/uitgang, altijd‑aan (3,6 V – 5 V). Voert de momenteel actieve bron (VIN, USB of aangesloten batterij), en kan ook als ingang worden gebruikt. Je moet RAW via een serie-diode aansturen wanneer je er voeding in voert — anders stroomt er stroom terug in VIN/USB en beschadigt dit de voeding of de ingebouwde bescherming.

  • GND — gemeenschappelijke massa.

Notitie

De ingebouwde energiebeheerchip kiest automatisch welke van USB of VIN de hogere spanning heeft om het bord en de batterijlader te voeden. Als er een LiPo is aangesloten, laadt deze op met de overgebleven marge, en de controller valt terug op de batterij om het bord draaiende te houden als VIN/USB inzakken of worden losgekoppeld.

Notitie

De achterkant van het bord heeft soldeerpads voor een externe 3,3 V RTC-back‑upbatterij. Door een knoopcel op deze pads aan te sluiten blijft de RTC lopen terwijl de rest van het bord geen voeding heeft.

Tip

Gebruik de batterijduur-schatter om te modelleren hoe lang de RT1062 op een batterij zal draaien voor een gegeven actief / diepe-slaap-werkverhouding.

Ethernet-pinnen

De RT1062 stelt de MDI-paren van de 10/100 Mb/s Ethernet-PHY beschikbaar op speciale pads naast de GPIO-header. De MDI-pinnen kunnen niet veilig rechtstreeks op een RJ45 worden aangesloten — Ethernet-magnetics (een isolatietransformator, ingebouwd in een magjack of op het shield) zijn vereist tussen de PHY en de kabel. Het OpenMV PoE-shield bevat ze; als je je eigen aansluiting maakt, gebruik dan een RJ45 met geïntegreerde magnetics of een externe transformator.

  • ETH_LED — link/activiteit-LED. Actief laag wanneer er een link is; knippert bij verkeer.

  • ETH_TXP / ETH_TXN — zendpaar.

  • ETH_RXP / ETH_RXN — ontvangstpaar.

Notitie

De header stelt ook vier pads beschikbaar met de zeefdruk Reserved. Deze zijn footprint‑compatibel met de gigabit Ethernet-paren op de OpenMV N6 (DC P/N en DD P/N), zodat hetzelfde Ethernet- / PoE-shield op beide borden kan worden aangesloten. De PHY van de RT1062 doet alleen 10/100 Mb/s, dus die vier pads hebben geen elektrische verbinding — laat ze onaangesloten.

Herstel- en debug-pinnen

  • RESET — trek naar GND om het bord te resetten. Door hem los te laten kan de MCU normaal opstarten.

  • SBL — trek naar 3,3 V tijdens het voeden van het bord om de ROM-bootloader-modus (Serial Boot Loader) te activeren. OpenMV IDE gebruikt deze modus om de ingebouwde bootloader opnieuw te flashen.

Er is een speciale ARM 10‑pins SWD/JTAG-header gemonteerd, compatibel met ST‑LINK- en SEGGER J‑Link-adapters.

Notitie

De RT1062 stelt via deze connector standaard alleen SWD-debug beschikbaar. Volledige JTAG is niet kant‑en‑klaar beschikbaar.

Ingebouwde randapparaten

LED’s

De RT1062 heeft twee RGB-LED’s:

  • RGB-LED voor gebruiker — softwarematig regelbaar, beschikbaar als LED_RED, LED_GREEN en LED_BLUE

    from machine import LED

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

  • Voedings-LED — rechtstreeks aangestuurd door de ingebouwde energiebeheerhardware, geen softwarematige besturing. Gebruik hem om in één oogopslag te zien wat de voeding doet.

    Tijdens het draaien:

    Kanaal

    Betekenis

    Blauw

    VIN voedt het bord (uit bij USB)

    Groen

    USB- of VIN-voeding aanwezig

    Rood

    een aangesloten LiPo-batterij wordt opgeladen

    In diepe slaap zijn alle kanalen uit behalve Rood, die nog brandt terwijl een LiPo oplaadt.

Knoppen

De RT1062 heeft twee knoppen:

  • SW — algemene gebruikersknop. Vanuit code leesbaar als een normale actief‑lage GPIO-ingang:

    from machine import Pin

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

  • Aan/uitknop — aangestuurd door een speciale energiecontroller-state-machine op het RT1062-bord, volledig in hardware. Hij is niet beschikbaar voor gebruikerscode; de controller bepaalt wat er gebeurt op basis van hoe lang hij wordt ingedrukt:

    • ~5 s ingedrukt houden terwijl het bord draait → de state machine schakelt over naar diepe slaap.

    • ~1 s ingedrukt houden terwijl het bord in diepe slaap is → de state machine schakelt het systeem weer in.

    Het laag trekken van de ON/OFF-headerpad heeft hetzelfde effect als het indrukken van de ingebouwde aan/uitknop — handig om een externe schakelaar aan te sluiten of de lijn vanaf een andere microcontroller aan te sturen.

Voedingsstatuspinnen

Drie actief‑lage statusingangen van de ingebouwde energiebeheerchip:

  • PG — laag wanneer VIN- of USB-voeding aanwezig is. Altijd verbonden.

  • ST — laag wanneer het bord op VIN draait, hoog wanneer het op USB-voeding draait. Standaard niet verbonden.

  • CHG — laag terwijl een aangesloten LiPo-batterij oplaadt. Standaard niet verbonden.

from machine import Pin

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

Camerasensor

De OV5640 wordt aangestuurd via de csi — camerasensoren-module:

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

De OV5640 heeft een ingebouwde JPEG-compressor. Stel csi.CSI.pixformat in op csi.JPEG en de sensor levert gecomprimeerde frames rechtstreeks aan de cam over de camerabus, waardoor opnamen met hoge resolutie praktisch worden: csi.HD (1280×720), csi.FHD (1920×1080) en de volledige 5MP csi.WQXGA2 (2592×1944) streamen allemaal als JPEG. Stel de compressie af met csi.CSI.quality (0-100, hoger = grotere frames, meer detail):

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

De sensor zit op een verwisselbare module — verwissel hem voor een van de andere OpenMV-cameramodules (global shutter, thermisch, hogere resolutie, enz.) zonder de rest van het bord te wijzigen.

Machine learning

ml — Machine Learning draait gekwantiseerde TFLite-modellen op de Cortex‑M7 met CMSIS‑NN-kernels — snel genoeg voor compacte detectors met enkele frames per seconde. Modellen op het alleen‑lezen /rom-bestandssysteem laden rechtstreeks vanuit flashgeheugen zonder naar RAM te kopiëren. Hier is een 128×128 BlazeFace-detector die het gedetecteerde gezicht en zijn zes oriëntatiepunten op elk frame overlayt:

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

De RT1062-firmware koppelt de ingebouwde versnellingsmeter niet aan de imu — imu-sensor-module. Communiceer er in plaats daarvan rechtstreeks mee over de interne I²C-bus — de chip bevindt zich op adres 0x15 en bevat drie signed 12‑bit versnellingskanalen plus een 8‑bit temperatuurbyte, beginnend bij 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-borden en later bevatten een generieke 4 KB I²C-EEPROM op dezelfde interne bus als de versnellingsmeter. (Eerdere revisies hebben er geen — het aanroepen van deze snippets op R4/R5 zal een time‑out geven door een ontbrekende I²C-ack.) Gebruik de standaard machine.I2C readfrom_mem / writeto_mem API met een 16‑bit geheugenadres:

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

Zowel lees- als schrijfacties moeten binnen een pagina van 32 bytes blijven. Splits elke grotere overdracht op in één aanroep per pagina, en voeg de schrijfcyclusvertraging van ~5 ms toe tussen opeenvolgende schrijfacties.

Wi‑Fi

De ingebouwde module uit de CYW43-familie is via network — netwerkconfiguratie beschikbaar als station-interface. Na het verbinden retourneert ipconfig("addr4") het (ip, netmask)-paar:

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

Dezelfde draadloze module stelt ook Bluetooth 5.1 beschikbaar. Gebruik aioble — Async BLE voor asyncio‑vriendelijke BLE — adverteer bijvoorbeeld als randapparaat en wacht tot een central verbinding maakt:

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

Wanneer een RJ45 (met magnetics) op de MDI-pads is aangesloten, verschijnt de 10/100-PHY als een LAN-interface. DHCP draait automatisch zodra de link tot stand komt:

import network, time

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

microSD-kaart

Wanneer een kaart is geplaatst, wordt deze automatisch gemount op /sdcard en is bruikbaar via het normale bestandssysteem:

import os

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

Busreferentie

GPIO

Gebruik machine.Pin om een van de pinnen met zeefdruk uit te lezen of aan te sturen. Uitgangen zijn 3,3 V CMOS en kunnen tot 4 mA per pin sinken/sourcen.

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

Elke ingangspin kan ook een interrupt afvuren bij randovergangen:

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

Dezelfde hardware kan ook in target- (slave-)modus worden gebruikt via machine.I2CTarget om een geheugengebied beschikbaar te stellen aan een andere I²C-controller:

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

Notitie

CAN wordt in firmware v5.0.0 nog niet ondersteund op dit bord.

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

De enige ADC-pin voor de gebruiker is P6, die volledige schaal bereikt bij ~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

FlexPWM-kanaal

P0

PWM2 B3

P2

PWM2 B3

P4

PWM1 X2

P5

PWM1 X3

P7

PWM2 A0

P8

PWM2 B0

P9

PWM1 A3

P10

PWM1 B3

Stuur er een van aan via machine.PWM

from machine import Pin, PWM

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

Softwarematige bit‑banged bussen

machine.SoftI2C en machine.SoftSPI werken op elke GPIO als je een extra bus nodig hebt.

Thermische sensor (extern)

De firmware bevat de fir — thermische sensor-driver (fir == far infrared)-driver voor extern bedrade thermische beeldsensoren:

  • MLX90621 — 16 × 4 IR-array

  • MLX90640 — 32 × 24 IR-array

  • MLX90641 — 16 × 12 IR-array

  • AMG8833 — 8 × 8 IR-array

Sluit de module aan op de I²C-bus van het bord en lees frames met 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())

De fir-driver communiceert alleen via I²C 4 met de sensor — sluit de module aan op P4 (SCL) en P5 (SDA).

Timing

time

De time-module dekt blokkerende vertragingen, monotone ticks en het meten van verstreken tijd:

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)

Virtuele timers

machine.Timer plant periodieke of eenmalige callbacks zonder een hardware-timerslot te gebruiken. Geef -1 op als de id om een virtuele (software-)timer te gebruiken:

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

Periodewaarden zijn in milliseconden. Roep deinit() aan om te stoppen en het slot vrij te geven.

Real‑time klok

machine.RTC houdt de wandklok-tijd bij over resets heen en (met de optionele 3,3 V back‑upbatterij aangesloten op de achterste pads, zie Voedingspinnen) over volledig stroomverlies heen:

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

De RTC blijft ook tijdens diepe slaap lopen, zodat je hem kunt gebruiken als wakeup-bron voor machine.deepsleep().

Watchdog

machine.WDT reset het bord als de toepassing vastloopt. Eenmaal gestart kan hij niet worden gestopt of opnieuw geconfigureerd — voed hem periodiek binnen je hoofdlus:

from machine import WDT

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

Boot- en runtime-informatie

USB-bootloader-venster

Bij elke inschakeling draait de camera een korte bootloader (enkele seconden) waarmee OpenMV IDE de firmware kan updaten zonder dat de gebruiker de DFU-modus hoeft te openen. Nadat het venster verloopt, draagt de bootloader over aan boot.py en vervolgens main.py.

Een draaiend script kan op verzoek opnieuw de bootloader binnengaan door machine.bootloader() aan te roepen:

import machine

machine.bootloader()

Bestandssysteem en bootvolgorde

De RT1062-firmware mount bij het opstarten maximaal drie bestandssystemen:

  • Intern flashgeheugen — altijd gemount op /flash. Bevat standaard main.py en README.txt; aangemaakt bij de allereerste boot.

  • microSD-kaart — als er een kaart is geplaatst, wordt deze gemount op /sdcard.

  • ROMFS — alleen‑lezen, geheugen‑gemapt bestandssysteem op /rom, gebruikt om grote datagegevens te leveren (bijv. AI-modellen) die baat hebben bij zero‑copy-toegang. Wordt bij het opstarten automatisch door MicroPython gemount, vóór er enige gebruikers-Python draait.

Na het mounten wordt de werkmap ingesteld op /sdcard wanneer de kaart aanwezig is, anders /flash. De interpreter draait vervolgens scripts vanuit die map:

  • boot.py wordt uitgevoerd bij elke soft reset (koude boot, Ctrl‑D vanuit de REPL, of telkens wanneer het draaiende script terugkeert).

  • main.py wordt alleen bij een koude boot uitgevoerd, direct na boot.py. Latere soft resets draaien boot.py opnieuw maar vallen rechtstreeks terug op de REPL — om main.py opnieuw te draaien moet je het bord volledig resetten.

Het plaatsen van een boot.py of main.py op de SD-kaart overschrijft de kopie in flashgeheugen zonder deze aan te raken — beide bestanden worden opgezocht in de bootmap (/sdcard wanneer de kaart is gemount, anders /flash).

De standaard main.py die op een vers geflasht bord wordt geleverd, laat alleen het blauwe kanaal van de RGB-LED voor de gebruiker knipperen als een hartslag (twee korte pulsen, korte tussenpauze), zodat je kunt zien dat de firmware netjes is opgestart zonder dat er een host is aangesloten.

sys.path wordt uitgebreid met alle drie de bestandssystemen en hun lib/-submappen, zodat importeerbare modules kunnen staan in /flash/lib, /sdcard/lib of /rom/lib.

Om het systeem te dwingen een geplaatste SD-kaart te negeren (bijvoorbeeld om de flash-main.py te draaien zelfs als er een kaart aanwezig is), maak je een leeg bestand met de naam SKIPSD in de root van /flash.

Wanneer verbonden via USB, wordt het bootbestandssysteem (/sdcard als er een kaart aanwezig is, anders /flash) ook op de host geënumereerd als een USB-massaopslagstation, waarmee je boot.py, main.py en alle andere bestanden rechtstreeks kunt bewerken. Werp het station uit voordat je de camera reset zodat de host zijn gecachete schrijfacties wegschrijft.

Notitie

Omdat het OS het station als een passief blokapparaat behandelt, zullen bestanden die worden aangemaakt of gewijzigd door code die op de OpenMV Cam draait, pas verschijnen wanneer de host het station opnieuw mount. Als zowel het OS als de OpenMV Cam tegelijkertijd naar hetzelfde bestandssysteem schrijven, wint het OS en overschrijft het de wijzigingen van de camera. Gebruik de SD-kaart voor alle gegevens die het script terugschrijft, en mount opnieuw voordat je die bestanden vanaf de host leest.

Notitie

Het rode kanaal van de RGB-LED voor de gebruiker kan kort oplichten terwijl de host van of naar het USB-massaopslagstation leest of schrijft — dit is een firmware‑aangestuurde activiteitsindicator, geen fout.

Opslaggroottes

De RT1062 wordt geleverd met:

  • /flash — 4 MB FAT-bestandssysteem, lezen/schrijven.

  • /rom — 8 MB alleen‑lezen geheugen‑gemapt ROMFS, gebruikt om scripts en ML-modellen te leveren die baat hebben bij zero‑copy mmap-toegang.

  • /sdcard — volledige grootte van de geplaatste microSD-kaart (indien aanwezig), lezen/schrijven.

Hard‑fault-indicator

Als de RGB-LED voor de gebruiker snel door alle kleuren cyclet — snel genoeg dat het meestal lijkt op een fonkelende witte LED in plaats van afzonderlijke tinten — dan heeft de firmware een onherstelbare hard fault opgelopen. Flash de firmware opnieuw om te herstellen; als opnieuw flashen niet helpt, kan het bord fysiek beschadigd zijn.

Softwarebibliotheken

Zie de bibliotheekindex voor de volledige lijst met modules — inclusief welke uniek zijn voor de RT1062-build.