OpenMV N6¶

De OpenMV N6 is gebouwd rond de STMicroelectronics STM32N657 (Cortex‑M55 @ 800 MHz) met een 1 GHz on‑chip NPU van 600 GOPS INT8. Het board combineert de NPU met de PAG7936 1 MP global‑shutter sensor op een verwisselbare carrier, gigabit Ethernet, USB‑C high‑speed, Wi‑Fi en Bluetooth 5.1, en draait YOLOv8/YOLOv11‑inferentie op 30 FPS naast live videostreaming.

Voor de volledige datasheet, foto’s en afmetingen zie de OpenMV N6 productpagina.

Hoogtepunten¶

STM32N657 Cortex‑M55 op 800 MHz (1280 DMIPS) met ARM Helium 128‑bit SIMD — 6,4 gigaops vectordoorvoer.
1 GHz NPU, 600 GOPS INT8 — draait YOLOv8/YOLOv11‑detectie op 30 FPS.
ISP voor maximaal 5MP RAW Bayer, 2D GPU voor schalen en 3D‑rotatie, H.264‑encodering tot 1080p en hardware JPEG‑codec.
64 MB extern SDRAM (16‑bit @ 200 MHz DDR, 800 MB/s) plus 4,2 MB intern SRAM en 32 MB octal flashgeheugen (200 MHz DDR, 400 MB/s).
PAG7936 1 MP kleuren global‑shutter sensor.
Onboard IMU (accelerometer + gyroscoop) en microfoon voor audio‑ + bewegingsfusie.
High‑speed USB‑C (480 Mb/s, 1,5 A stroomlimiet), gigabit Ethernet (PoE‑geschikt via shield), Wi‑Fi a/b/g/n + Bluetooth 5.1 (chipantenne of U.FL‑optie).
microSD‑slot — SD tot 2 GB, SDHC tot 32 GB, SDXC tot 2 TB.
LiPo‑lader (500 mA snelladen), accuspannings‑ADC, RTC met 8 KB backup‑RAM en een aparte backup‑accupin.
18 I/O‑pinnen, allemaal 3,3 V uitvoer / 3,3 V tolerant, 20 mA per pin, geschikt voor interrupts.
Gebruikers‑RGB‑LED, gebruikersknop en een aparte status‑LED voor laden / USB / VIN‑voeding.

Waarschuwing

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

Pinout¶

Pinreferentie¶

Pinnaam	Functie
P0	SPI2 MOSI / I2S2 SDO
P1	SPI2 MISO / I2S2 SDI
P2	SPI2 SCLK / UART4 TX / CAN1 TX / I2S2 CK
P3	SPI2 SS / UART4 RX / CAN1 RX / I2S2 WS
P4	I2C2 SCL / UART3 TX / TIM2 CH3 / I3C2 SCL
P5	I2C2 SDA / UART3 RX / TIM2 CH4 / I3C2 SDA
P6	TIM12 CH1 (geen ADC op deze pin — zie `P6_ADC`)
P6_ADC	speciale 12‑bit ADC‑ingang (intern verbonden met P6)
P7	TIM4 CH1
P8	TIM4 CH2
P9	TIM17 CH1
P10	TIM15 CH2 / frame‑sync I/O
P11	wakeup (actief laag, WKUP3)
P12	RESET — trek naar GND om het board te resetten (geen GPIO)
P13	UART7 RX
P14	UART7 TX
P15	SPI4 CS
P16	SPI4 SCK
P17	SPI4 MISO
P18	SPI4 MOSI
SW	gebruikersknop (actief laag)
ONOFF (SW2)	deep‑sleep wakeup‑knop (actief laag, WKUP2)
ST	laag bij VIN‑voeding, hoog bij USB‑voeding
CHG	actief‑laag; laag terwijl een aangesloten LiPo‑accu wordt geladen
PG	actief‑laag; laag wanneer VIN‑ of USB‑voeding aanwezig is
BAT_ADC	intern ADC‑kanaal dat de spanning van de aangesloten LiPo‑accu meet
LED_RED	RGB‑LED rode kanaal (actief laag)
LED_GREEN	RGB‑LED groene kanaal (actief laag)
LED_BLUE	RGB‑LED blauwe kanaal (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 wordt bepaald door de applicatie — de MCU, de sensor of een extern signaal kan hem aansturen, afhankelijk van hoe de sensor is geconfigureerd (sommige sensoren kunnen dezelfde pin gebruiken als trigger‑ingang of als belichtingsuitvoer). Zorg ervoor dat er telkens maar één driver actief is.

Notitie

ONOFF 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 board in deep sleep / energiezuinige modus staat. Beide ingangen zijn actief laag.

Deze pinnen lopen via levelshifters zodat ze op de RAW‑rail kunnen werken. Als u echt direct 3,3 V GPIO‑gedrag op ONOFF of P11 nodig heeft (bijvoorbeeld om ze aan te sturen vanaf een 3,3 V MCU zonder via de shifter te gaan), heeft het board pull‑up‑ en 0‑ohm jumperpads die u in staat stellen de shifter te omzeilen. Dit is een geavanceerde hardwareaanpassing — de meeste gebruikers laten dit beter ongemoeid.

Notitie

P15–P18 worden gedeeld met de Gigabit Ethernet PHY, die standaard bedraad en actief is. Om deze pinnen als gebruikers‑I/O te gebruiken, moet u de 0‑ohm weerstand aan de achterkant van het board naar de GPIO‑positie verplaatsen. Dit schakelt alleen gigabit Ethernet uit — 10/100 Mb/s Ethernet blijft werken op zijn eigen pinnen.

Voedingspinnen¶

3.3V — gereguleerde 3,3 V‑rail. Alleen uitvoer op de N6 — voer geen externe voeding in deze pin. Tot 1 A beschikbaar voor shields.
VIN — 5 V ingang. Voedt het board en de on‑board LiPo‑lader.
RAW — ingang/uitvoer, altijd‑aan (3,6 V – 5 V). Voert de actieve bron (VIN, USB of aangesloten accu) en kan ook als ingang worden gebruikt. U moet RAW via een seriële diode aansturen wanneer u er voeding in steekt — anders vloeit er stroom terug naar VIN/USB en beschadigt u de voeding of de on‑board bescherming.
GND — gemeenschappelijke aarde.

Notitie

De on‑board voedingsmanagementchip kiest automatisch welke van USB of VIN de hoogste spanning heeft om het board en de acculader te voeden. Als er een LiPo is aangesloten, wordt deze geladen met de resterende speling, en de controller valt terug op de accu om het board draaiend te houden als VIN/USB inzakt of wordt losgekoppeld.

Notitie

De achterkant van het board heeft soldeerpads voor een externe 3,3 V RTC‑backup‑accu. Door een knoopcel op deze pads aan te sluiten, blijven de RTC en 8 KB backup‑RAM draaien terwijl de rest van het board geen voeding heeft.

Tip

Gebruik de accuduurschatter om te modelleren hoe lang de N6 op een accu draait bij een bepaalde actieve‑ / deep‑sleep‑inschakelduur.

Ethernet‑pinnen¶

De N6 stelt de MDI‑paren van de 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 scheidingstransformator, ingebouwd in een magjack of op het shield) zijn vereist tussen de PHY en de kabel. Het OpenMV PoE‑shield bevat ze; als u uw eigen jack maakt, gebruik dan een RJ45 met geïntegreerde magnetics of een externe transformator.

ETH_LED — link‑/activiteits‑LED. Actief laag wanneer er een link actief is; knippert bij verkeer.
DA P / DA N — paar A (TX bij 10/100, gebruikt bij alle snelheden).
DB P / DB N — paar B (RX bij 10/100, gebruikt bij alle snelheden).
DC P / DC N — paar C, alleen gebruikt bij gigabit.
DD P / DD N — paar D, alleen gebruikt bij gigabit.

10/100 Mb/s heeft alleen de paren A en B nodig. Gigabit heeft alle vier de paren A–D nodig.

Recovery‑ en debug‑pinnen¶

RESET — trek naar GND om het board te resetten. Door hem los te laten start de MCU normaal op.
BOOT0 — trek naar 3,3 V tijdens het inschakelen van het board om de ROM‑bootloader‑modus te activeren. OpenMV IDE gebruikt deze modus om de on‑board bootloader opnieuw te flashen.
BOOT1 — schakelaar die het board in developer‑modus zet voor gebruik met ST’s tooling (een ST‑LINK aangesloten op de ARM 10‑pins SWD/JTAG‑header). Laat dit uitgeschakeld voor normaal gebruik met OpenMV firmware en tools.

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

Onboard randapparaten¶

LED’s¶

De N6 heeft twee RGB‑LED’s:

Gebruikers‑RGB‑LED — softwarematig bestuurbaar, 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 on‑board voedingsmanagementhardware, geen softwarebesturing. Gebruik hem om in één oogopslag af te lezen wat de voeding doet.

Tijdens het draaien:

Kanaal

Betekenis

Blauw

VIN voedt het board (uit bij USB)

Groen

USB‑ of VIN‑voeding aanwezig

Rood

een aangesloten LiPo‑accu wordt geladen

In deep sleep zijn alle kanalen uit behalve Rood, dat nog steeds brandt terwijl een LiPo wordt geladen.

Kanaal	Betekenis
Blauw	VIN voedt het board (uit bij USB)
Groen	USB‑ of VIN‑voeding aanwezig
Rood	een aangesloten LiPo‑accu wordt geladen

Gebruikersknoppen¶

De N6 heeft twee knoppen:

SW — gebruikersknop voor algemeen gebruik. Actief wanneer naar laag getrokken.
ONOFF (SW2) — wakeup‑knop. De enige knop die het board uit deep sleep kan halen.

from machine import Pin

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

Om het board in deep sleep te zetten en het door ONOFF (SW2) weer te laten wekken, roept u gewoon machine.deepsleep() aan — er is geen wakeup‑configuratie nodig, de knop is rechtstreeks bedraad naar de WKUP2‑ingang:

import machine

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

U kunt ONOFF ook bedraden als een soft‑aan‑uitschakelaar. Trigger op de opgaande flank — de lijn gaat hoog nadat de gebruiker de knop loslaat, zodat de volgende druk ondubbelzinnig een wake‑gebeurtenis is:

import machine
from machine import Pin

def power_off(_):
    machine.deepsleep()

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

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

Voedingsstatuspinnen¶

Drie actief‑lage statusingangen laten firmware zien wat de on‑board voedingsmanagementchip doet:

ST — laag wanneer het board op VIN draait, hoog wanneer het op USB‑voeding draait.
CHG — laag terwijl een aangesloten LiPo‑accu wordt geladen.
PG — laag wanneer VIN‑ of USB‑voeding aanwezig is.

from machine import Pin

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

Camerasensor¶

De PAG7936 wordt aangestuurd via de csi — camerasensoren module:

import csi

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

while True:
    img = cam.snapshot()

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

De PAG7936 ondersteunt getriggerde modus — pixelintegratie lijnt precies uit met elke csi.CSI.snapshot aanroep in plaats van de vrijlopende frameklok, handig om opname te synchroniseren met een externe gebeurtenis of een andere sensor. Schakel het in via csi.CSI.ioctl met csi.IOCTL_SET_TRIGGERED_MODE. De framesnelheid daalt tot ongeveer de helft van de vrijlopende modus omdat de uitlezing niet langer pipelinet met de integratie van het volgende frame:

cam.ioctl(csi.IOCTL_SET_TRIGGERED_MODE, True)

NPU¶

De 1 GHz Neural‑ART NPU van de N6 (600 GOPS INT8) wordt beschikbaar gesteld via de ml — Machine Learning module. Modellen die op het alleen‑lezen /rom bestandssysteem zijn opgeslagen, laden rechtstreeks vanuit flashgeheugen zonder naar RAM te kopiëren, zodat zelfs grote detectoren comfortabel naast de live framebuffer passen. Draai een YOLOv8‑detector op elk frame en teken de voorspellingen bovenop de live afbeelding:

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

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

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

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

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

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

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

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

Microfoon¶

De on‑board microfoon wordt opgenomen via audio — Audio Module. Elke buffer arriveert als een signed‑16‑bit PCM bytearray, wat het triviaal maakt om deze in ulab/numpy te voeren voor snelle DSP. Een eenvoudige luidheidsdetector — print telkens wanneer het RMS‑volume een drempelwaarde overschrijdt:

import audio
from ulab import numpy as np

def loudness(pcmbuf):
    samples = np.array(np.frombuffer(pcmbuf, dtype=np.int16), dtype=np.float)
    rms = np.sqrt(np.mean(samples ** 2))
    if rms > 10000:
        print("Loud!", int(rms))

audio.init(channels=1, frequency=16000, gain_db=24)
audio.start_streaming(loudness)

while True:
    pass

IMU¶

De on‑board accelerometer + gyroscoop onder de cameramodule wordt beschikbaar gesteld via imu — imu-sensor

import imu
import time

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

Wi‑Fi¶

De on‑board CYW43439 wordt beschikbaar gesteld via network — netwerkconfiguratie als een station‑interface. Na het verbinden geeft ipconfig("addr4") het (ip, netmask) paar terug:

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 CYW43439 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-N6")
        print("Connected:", conn.device)
        await conn.disconnected()

asyncio.run(run())

Ethernet¶

Wanneer een RJ45 (met magnetics) op de MDI‑pads wordt aangesloten, verschijnt de gigabit PHY als een LAN interface. DHCP draait automatisch zodra de link actief wordt:

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 wordt geplaatst, wordt deze automatisch aangekoppeld op /sdcard en is bruikbaar via het reguliere bestandssysteem:

import os

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

Busreferentie¶

GPIO¶

Gebruik machine.Pin om een van de op de zeefdruk aangegeven pinnen te lezen of aan te sturen. Uitgangen zijn 3,3 V CMOS en kunnen tot 20 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 activeren bij flanktransities:

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

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

UART¶

Bus	TX	RX
UART3	P4	P5
UART4	P2	P3
UART7	P14	P13

from machine import UART

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

I²C¶

Bus	SCL	SDA
I2C2	P4	P5

from machine import I2C

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

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

SPI¶

Bus	MOSI	MISO	SCK	CS
SPI2	P0	P1	P2	P3
SPI4	P18	P17	P16	P15

from machine import SPI
from machine import Pin

spi = SPI(2, baudrate=10_000_000)
cs = Pin("P3", Pin.OUT, value=1)   # CS is not driven by the SPI peripheral

cs.value(0)
spi.write(b"hello")
cs.value(1)

CAN¶

Bus	TX	RX
CAN1	P2	P3

Notitie

CAN wordt nog niet ondersteund op dit board in 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¶

Beide ADC‑kanalen lopen via een op‑amp gebufferde spanningsdeler voordat ze de MCU bereiken, zodat read_u16() op elke pin aan een andere full‑scale ingangsspanning is gekoppeld.

Pin	Full‑scale	Opmerkingen
P6_ADC	~3,3 V	pad voor algemeen gebruik, intern verbonden met P6
BAT_ADC	~5,0 V	intern kanaal voor de LiPo‑accu

from machine import ADC
import time

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

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

PWM¶

Pin	Timer / kanaal
P4	TIM2 CH3
P5	TIM2 CH4
P6	TIM12 CH1
P7	TIM4 CH1
P8	TIM4 CH2
P9	TIM17 CH1
P10	TIM15 CH2

Stuur er een van aan via machine.PWM

from machine import Pin, PWM

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

Software bit‑banged bussen¶

machine.SoftI2C en machine.SoftSPI werken op elke GPIO als u een extra bus nodig heeft.

Thermische sensor (off‑board)¶

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

MLX90621 — 16 × 4 IR‑array
MLX90640 — 32 × 24 IR‑array
MLX90641 — 16 × 12 IR‑array
AMG8833 — 8 × 8 IR‑array

Bedraad de module naar de I²C‑bus van het board 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 met de sensor via I²C 2 — bedraad de module naar P4 (SCL) en P5 (SDA).

Timing¶

time¶

De time module dekt blokkerende vertragingen, monotone ticks en metingen 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 verbruiken. Geef -1 op als 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 kloktijd bij over resets heen en (met de optionele 3,3 V backup‑accu bedraad naar 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 draait ook tijdens deep sleep, zodat u hem kunt gebruiken als wakeup‑bron voor machine.deepsleep().

Watchdog¶

machine.WDT reset het board als de applicatie vastloopt. Eenmaal gestart kan hij niet meer worden gestopt of opnieuw geconfigureerd — voed hem periodiek binnen uw hoofdlus:

from machine import WDT

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

Boot‑ en runtime‑informatie¶

USB‑bootloadervenster¶

Bij elke inschakeling draait de camera een korte bootloader (een paar seconden) waarmee OpenMV IDE de firmware kan bijwerken zonder dat de gebruiker DFU‑modus hoeft te activeren. Na afloop van het venster draagt de bootloader over aan boot.py en daarna 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 N6‑firmware koppelt bij het opstarten maximaal drie bestandssystemen aan:

Intern flashgeheugen — altijd aangekoppeld op /flash. Bevat standaard main.py en README.txt; aangemaakt bij de allereerste boot.
microSD‑kaart — als er een kaart is geplaatst, wordt deze aangekoppeld op /sdcard.
ROMFS — alleen‑lezen, in het geheugen gemapt bestandssysteem op /rom, gebruikt om grote data‑assets (bijv. AI‑modellen) te leveren die baat hebben bij zero‑copy toegang. Wordt automatisch door MicroPython aangekoppeld bij het opstarten, voordat enige gebruikers‑Python draait.

Na het aankoppelen wordt de werkdirectory ingesteld op /sdcard wanneer de kaart aanwezig is, anders /flash. De interpreter draait dan scripts vanuit die directory:

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 koude boot uitgevoerd, direct na boot.py. Volgende soft resets draaien boot.py opnieuw maar vallen direct terug naar de REPL — om main.py opnieuw te draaien moet u het board volledig resetten.

Een boot.py of main.py op de SD‑kaart zetten overschrijft de kopie in flashgeheugen zonder deze aan te raken — beide bestanden worden opgezocht in de bootdirectory (/sdcard wanneer de kaart is aangekoppeld, anders /flash).

De standaard main.py die op een vers geflasht board wordt geleverd, knippert simpelweg het blauwe kanaal van de gebruikers‑RGB‑LED als een hartslag (twee korte pulsen, korte pauze), zodat u kunt zien dat de firmware schoon 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 in /flash/lib, /sdcard/lib of /rom/lib kunnen staan.

Om het systeem te dwingen een geplaatste SD‑kaart te negeren (bijvoorbeeld om de flash‑main.py te draaien zelfs met een kaart aanwezig), maakt u een leeg bestand met de naam SKIPSD aan in de root van /flash.

Wanneer verbonden via USB, wordt het boot‑bestandssysteem (/sdcard als er een kaart aanwezig is, anders /flash) ook als een USB‑massaopslagstation op de host opgesomd, waarmee u boot.py, main.py en alle andere bestanden rechtstreeks kunt bewerken. Werp het station uit voordat u de camera reset zodat de host zijn gecachte writes wegschrijft.

Notitie

Omdat het OS het station behandelt als een passief blokapparaat, verschijnen bestanden die zijn aangemaakt of gewijzigd door code die op de OpenMV Cam draait pas wanneer de host het station opnieuw aankoppelt. 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 data die het script terugschrijft, en koppel opnieuw aan voordat u die bestanden vanaf de host leest.

Notitie

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

Opslaggroottes¶

De N6 wordt geleverd met:

/flash — 4 MB FAT‑bestandssysteem, lezen/schrijven.
/rom — 24 MB alleen‑lezen in het 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 gebruikers‑RGB‑LED snel door alle kleuren cyclet — snel genoeg dat het er meestal uitziet als een twinkelende witte LED in plaats van afzonderlijke kleurtinten — heeft de firmware een onherstelbare hard fault opgelopen. Flash de firmware opnieuw om te herstellen; als opnieuw flashen niet helpt, kan het board fysiek beschadigd zijn.

Softwarebibliotheken¶

Zie de bibliotheekindex voor de volledige lijst met modules — inclusief welke uniek zijn voor de N6‑build.