OpenMV N6

Az OpenMV N6 a STMicroelectronics STM32N657 (Cortex‑M55 @ 800 MHz) köré épül, amelyhez egy 1 GHz‑es, 600 GOPS INT8 teljesítményű, chipre integrált NPU tartozik. A kártya az NPU‑t egy PAG7936 1 MP‑es, globális zárral rendelkező érzékelővel párosítja, amely cserélhető hordozón helyezkedik el, továbbá gigabites Ethernettel, USB‑C nagy sebességű csatlakozóval, Wi‑Fi‑vel és Bluetooth 5.1‑gyel rendelkezik, valamint élő videostreamelés mellett 30 FPS sebességgel futtat YOLOv8/YOLOv11 következtetést.

A teljes adatlapért, fényképekért és méretekért lásd az OpenMV N6 termékoldalt.

Kiemelt jellemzők

• STM32N657 Cortex‑M55 800 MHz‑en (1280 DMIPS) ARM Helium 128 bites SIMD‑del — 6,4 gigaops vektoros átviteli teljesítmény.

• 1 GHz‑es NPU, 600 GOPS INT8 — 30 FPS sebességgel futtat YOLOv8/YOLOv11 észlelést.

• ISP akár 5MP RAW Bayer‑hez, 2D GPU méretezéshez és 3D forgatáshoz, H.264 kódolás 1080p‑ig, valamint hardveres JPEG kodek.

• 64 MB külső SDRAM (16 bites @ 200 MHz DDR, 800 MB/s), továbbá 4,2 MB belső SRAM és 32 MB octal flash (200 MHz DDR, 400 MB/s).

• PAG7936 1 MP‑es színes, globális zárral rendelkező érzékelő.

• Beépített IMU (gyorsulásmérő + giroszkóp) és mikrofon a hang és mozgás összevonásához.

• Nagy sebességű USB‑C (480 Mb/s, 1,5 A áramkorlát), gigabites Ethernet (PoE‑képes shield segítségével), Wi‑Fi a/b/g/n + Bluetooth 5.1 (chip antenna vagy U.FL opció).

• microSD foglalat — SD akár 2 GB, SDHC akár 32 GB, SDXC akár 2 TB.

• LiPo töltő (500 mA gyorstöltés), akkufeszültség‑ADC, RTC 8 KB tartalék RAM‑mal és külön tartalék‑akkumulátor lábbal.

• 18 I/O láb, mind 3,3 V kimenet / 3,3 V toleráns, 20 mA lábanként, megszakítás‑képes.

• Felhasználói RGB LED, felhasználói gomb és külön állapot LED a töltéshez / USB‑hez / VIN tápellátáshoz.

Figyelem

Az N6 I/O lábai nem 5 V toleránsak. Ne csatlakoztasd az eszközt közvetlenül egy 5 V‑os MCU‑hoz, például az Arduino Mega‑hoz. Az N6‑ot kizárólag a VIN‑en keresztül tápláld.

Lábkiosztás

Lábkiosztási referencia

Láb neve	Funkció
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 (ezen a lábon nincs ADC — lásd P6_ADC)
P6_ADC	dedikált 12 bites ADC bemenet (belsőleg a P6‑hoz kötve)
P7	TIM4 CH1
P8	TIM4 CH2
P9	TIM17 CH1
P10	TIM15 CH2 / képkocka‑szinkron I/O
P11	ébresztés (aktív alacsony, WKUP3)
P12	RESET — GND‑re húzva alaphelyzetbe állítja a kártyát (nem GPIO)
P13	UART7 RX
P14	UART7 TX
P15	SPI4 CS
P16	SPI4 SCK
P17	SPI4 MISO
P18	SPI4 MOSI
SW	felhasználói gomb (aktív alacsony)
ONOFF (SW2)	mélyalvásból ébresztő gomb (aktív alacsony, WKUP2)
ST	alacsony VIN tápellátásnál, magas USB tápellátásnál
CHG	aktív alacsony; alacsony, amíg egy csatlakoztatott LiPo akkumulátor töltődik
PG	aktív alacsony; alacsony, amikor VIN vagy USB tápellátás van jelen
BAT_ADC	belső ADC csatorna, amely a csatlakoztatott LiPo akkumulátor feszültségét méri
LED_RED	RGB LED vörös csatorna (aktív alacsony)
LED_GREEN	RGB LED zöld csatorna (aktív alacsony)
LED_BLUE	RGB LED kék csatorna (aktív alacsony)

Megjegyzés

A P10 képkocka‑szinkron vonal egy megosztott busz. Egyszerre van bekötve az MCU‑hoz, a kamera érzékelőjének trigger / expozíció lábához és a felhasználói tűsorhoz. Az irány alkalmazásfüggő — az MCU, az érzékelő vagy egy külső jel is meghajthatja attól függően, hogyan van konfigurálva az érzékelő (egyes érzékelők ugyanazt a lábat használhatják trigger bemenetként vagy expozíciós kimenetként). Ügyelj arra, hogy egyszerre csak egy meghajtó legyen aktív.

Megjegyzés

Az ONOFF és a P11 az állandóan bekapcsolt RAW sínre van hivatkozva (nem a kapcsolt 3,3 V‑os sínre), így működőképesek maradnak, miközben a kártya többi része mélyalvásban / alacsony fogyasztású módban van. Mindkét bemenet aktív alacsony.

Ezek a lábak szintillesztőkön keresztül vannak vezetve, hogy a RAW sínen működhessenek. Ha mindenképpen 3,3 V‑os közvetlen GPIO viselkedésre van szükséged az ONOFF vagy a P11 lábon (például hogy egy 3,3 V‑os MCU‑ról hajtsd meg őket a szintillesztő megkerülésével), a kártya felhúzó és 0 ohmos áthidaló pontokat tartalmaz, amelyekkel megkerülhető a szintillesztő. Ez fejlett hardveres átalakítás — a legtöbb felhasználónak érdemes érintetlenül hagynia.

Megjegyzés

A P15–P18 a gigabites Ethernet PHY‑vel van megosztva, amely alapból be van kötve és aktív. Ahhoz, hogy ezeket a lábakat felhasználói I/O‑ként használd, át kell forrasztanod a kártya hátoldalán lévő 0 ohmos ellenállást a GPIO pozícióba. Ez csak a gigabites Ethernetet tiltja le — a 10/100 Mb/s‑es Ethernet továbbra is működik a saját dedikált lábain.

Tápellátási lábak

• 3.3V — szabályozott 3,3 V‑os sín. Az N6‑on csak kimenet — ne táplálj külső feszültséget erre a lábra. Akár 1 A áll rendelkezésre a shieldek számára.

• VIN — 5 V‑os bemenet. A kártyát és a beépített LiPo töltőt táplálja.

• RAW — bemenet/kimenet, állandóan bekapcsolt (3,6 V – 5 V). Azt a forrást vezeti, amelyik éppen aktív (VIN, USB vagy csatlakoztatott akkumulátor), és bemenetként is használható. A RAW‑ot soros diódán keresztül kell meghajtanod, amikor tápellátást táplálsz bele — különben az áram visszafolyik a VIN/USB‑be és károsítja a tápellátást vagy a beépített védelmet.

• GND — közös föld.

Megjegyzés

A beépített tápkezelő chip automatikusan azt választja, amelyik az USB vagy a VIN közül a magasabb feszültségű, hogy táplálja a kártyát és az akkumulátortöltőt. Ha egy LiPo van csatlakoztatva, az a maradék kapacitáson töltődik, és a vezérlő visszavált az akkumulátorra, hogy a kártyát működésben tartsa, ha a VIN/USB feszültsége leesik vagy kihúzzák.

Megjegyzés

A kártya hátoldalán forrasztási pontok találhatók egy külső 3,3 V‑os RTC tartalék akkumulátor számára. Egy gombelem bekötése ezekre a pontokra működésben tartja az RTC‑t és 8 KB tartalék RAM‑ot, miközben a kártya többi része tápellátás nélkül van.

Javaslat

Használd az akkumulátor‑élettartam becslőt annak modellezéséhez, hogy az N6 egy adott aktív / mélyalvás kitöltési tényező mellett mennyi ideig fog működni akkumulátorról.

Ethernet lábak

Az N6 az Ethernet PHY MDI párjait dedikált pontokon vezeti ki a GPIO tűsor mellett. Az MDI lábakat nem biztonságos közvetlenül egy RJ45‑höz kötni — az Ethernet mágneses elemei (egy leválasztó transzformátor, amely vagy a magjack‑be van beépítve, vagy a shielden van) kötelezőek a PHY és a kábel között. Az OpenMV PoE shield tartalmazza ezeket; ha saját csatlakozót készítesz, használj mágneses elemekkel integrált RJ45‑öt vagy külső transzformátort.

• ETH_LED — kapcsolat/aktivitás LED. Aktív alacsony, ha a kapcsolat él; villog forgalom esetén.

• DA P / DA N — A pár (TX 10/100‑nál, minden sebességnél használt).

• DB P / DB N — B pár (RX 10/100‑nál, minden sebességnél használt).

• DC P / DC N — C pár, csak gigabitnél használt.

• DD P / DD N — D pár, csak gigabitnél használt.

A 10/100 Mb/s‑hez csak az A és B pár szükséges. A gigabithez mind a négy A–D pár szükséges.

Helyreállítási és hibakeresési lábak

• RESET — GND‑re húzva alaphelyzetbe állítja a kártyát. Elengedve az MCU normálisan elindul.

• BOOT0 — 3,3 V‑ra húzva a kártya bekapcsolásakor a ROM rendszerbetöltő módba lép. Az OpenMV IDE ezt a módot használja a beépített rendszerbetöltő újraírásához.

• BOOT1 — kapcsoló, amely a kártyát fejlesztői módba helyezi az ST eszközeivel való használathoz (egy ST‑LINK csatlakoztatva az ARM 10 tűs SWD/JTAG tűsorhoz). Hagyd ezt letiltva az OpenMV firmware‑rel és eszközökkel való normál működéshez.

Egy dedikált ARM 10 tűs SWD/JTAG tűsor van felszerelve, amely kompatibilis az ST‑LINK és a SEGGER J‑Link adapterekkel.

Beépített perifériák

LED‑ek

Az N6 két RGB LED‑del rendelkezik:

• Felhasználói RGB LED — szoftveresen vezérelhető, LED_RED, LED_GREEN és LED_BLUE néven elérhető:

  from machine import LED
  
  LED("LED_RED").on()
  LED("LED_GREEN").on()
  LED("LED_BLUE").on()
  

• Tápellátás LED — közvetlenül a beépített tápkezelő hardver hajtja meg, nincs szoftveres vezérlés. Használd arra, hogy egy pillantással leolvasd, mit csinál a tápellátás.

  Futás közben:

  Csatorna	Jelentés
  Kék	A VIN táplálja a kártyát (kikapcsolva USB‑n)
  Zöld	USB vagy VIN tápellátás van jelen
  Vörös	egy csatlakoztatott LiPo akkumulátor töltése

  Mélyalvásban minden csatorna ki van kapcsolva a vörös kivételével, amely továbbra is világít, amíg egy LiPo töltődik.

Felhasználói gombok

Az N6 két gombbal rendelkezik:

• SW — általános célú felhasználói gomb. Akkor aktív, ha alacsonyra van húzva.

• ONOFF (SW2) — ébresztő gomb. Az egyetlen gomb, amely képes mélyalvásból kihozni a kártyát.

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

Ahhoz, hogy a kártyát mélyalvásba helyezd, és az ONOFF (SW2) gombbal ébreszd fel, csak hívd meg a machine.deepsleep() függvényt — nincs szükség ébresztési konfigurációra, a gomb közvetlenül a WKUP2 bemenethez van kötve:

import machine

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

Az ONOFF‑ot szoftveres tápkapcsolóként is bekötheted. A felfutó élre triggerelj — a vonal magasra áll be, miután a felhasználó elengedi a gombot, így a következő gombnyomás egyértelműen egy ébresztési esemény:

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.

Tápellátás állapotjelző lábak

Három aktív alacsony állapot bemenet lehetővé teszi, hogy a firmware lássa, mit csinál a beépített tápkezelő chip:

• ST — alacsony, amikor a kártya VIN‑ről működik, magas, amikor USB tápellátásról.

• CHG — alacsony, amíg egy csatlakoztatott LiPo akkumulátor töltődik.

• PG — alacsony, amikor VIN vagy USB tápellátás van jelen.

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

Kamera érzékelő

A PAG7936‑ot a csi — kameraérzékelők modulon keresztül hajtja meg:

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

Az érzékelő egy cserélhető modulon helyezkedik el — cseréld ki bármely másik OpenMV kameramodulra (globális zár, hőkamera, nagyobb felbontás stb.) anélkül, hogy a kártya többi részét meg kellene változtatnod.

A PAG7936 támogatja a triggerelt módot — a képpontok integrálása pontosan minden egyes csi.CSI.snapshot híváshoz igazodik, nem pedig a szabadon futó képkocka‑órajelhez, ami hasznos a felvétel egy külső eseményhez vagy egy másik érzékelőhöz való szinkronizálásához. Engedélyezd a csi.CSI.ioctl segítségével a csi.IOCTL_SET_TRIGGERED_MODE paraméterrel. A képkockasebesség körülbelül a szabadon futó mód felére esik, mivel a kiolvasás már nem fut párhuzamosan a következő képkocka integrálásával:

cam.ioctl(csi.IOCTL_SET_TRIGGERED_MODE, True)

NPU

Az N6 1 GHz‑es Neural‑ART NPU‑ja (600 GOPS INT8) a ml — Gépi tanulás modulon keresztül érhető el. A csak olvasható /rom fájlrendszeren tárolt modellek közvetlenül a flash memóriából töltődnek be RAM‑ba másolás nélkül, így még a nagy detektorok is kényelmesen elférnek az élő képkocka‑puffer mellett. Futtass egy YOLOv8 detektort minden képkockán, és rajzold rá a predikciókat az élő képre:

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

Mikrofon

A beépített mikrofont a audio — Audio modul rögzíti. Minden puffer egy előjeles 16 bites PCM bytearray‑ként érkezik, ami triviálissá teszi a ulab/numpy felé történő továbbítást gyors DSP‑hez. Egy egyszerű hangerő‑detektor — kiír valahányszor az RMS hangerő átlép egy küszöbértéket:

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

A kameramodul alatt lévő beépített gyorsulásmérő + giroszkóp a imu — imu érzékelő modulon keresztül érhető el:

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

A beépített CYW43439 a network — hálózati konfiguráció modulon keresztül érhető el állomás (station) interfészként. A csatlakozás után az ipconfig("addr4") visszaadja az (ip, netmask) párt:

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

Ugyanaz a CYW43439 Bluetooth 5.1‑et is biztosít. Használd az aioble — Aszinkron BLE modult az asyncio‑barát BLE‑hez — például hirdesd magad perifériaként, és várd, hogy egy központi eszköz csatlakozzon:

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

Amikor egy RJ45 (mágneses elemekkel) csatlakozik az MDI pontokhoz, a gigabites PHY LAN interfészként jelenik meg. A DHCP automatikusan elindul, amint a kapcsolat létrejön:

import network, time

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

microSD kártya

Amikor egy kártyát behelyeznek, az automatikusan a /sdcard ponton csatolódik, és a szokásos fájlrendszeren keresztül használható:

import os

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

Busz referencia

GPIO

Használd a machine.Pin modult bármelyik szitanyomatos láb olvasásához vagy meghajtásához. A kimenetek 3,3 V CMOS‑ok, és lábanként akár 20 mA‑t nyelhetnek el/szolgáltathatnak.

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

Bármely bemeneti láb megszakítást is kiválthat él‑átmenetekkor:

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

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

UART

Busz	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

Busz	SCL	SDA
I2C2	P4	P5

from machine import I2C

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

Ugyanaz a hardver cél (slave) módban is használható a machine.I2CTarget segítségével, hogy egy memóriaterületet tegyen elérhetővé egy másik I²C vezérlő számára:

from machine import I2CTarget

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

SPI

Busz	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

Busz	TX	RX
CAN1	P2	P3

Megjegyzés

A CAN még nem támogatott ezen a kártyán az v5.0.0 firmware‑ben.

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

Mindkét ADC csatorna egy műveleti erősítővel pufferelt feszültségosztón megy keresztül, mielőtt elérné az MCU‑t, így a read_u16() mindkét lábon eltérő teljes skálájú bemeneti feszültséghez van rendelve.

Láb	Teljes skála	Megjegyzések
P6_ADC	~3,3 V	általános célú pont, belsőleg a P6‑hoz kötve
BAT_ADC	~5,0 V	belső csatorna a LiPo akkumulátorhoz

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

Láb	Időzítő / csatorna
P4	TIM2 CH3
P5	TIM2 CH4
P6	TIM12 CH1
P7	TIM4 CH1
P8	TIM4 CH2
P9	TIM17 CH1
P10	TIM15 CH2

Hajtsd meg bármelyiket a machine.PWM segítségével:

from machine import Pin, PWM

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

Szoftveresen bit‑bangelt buszok

A machine.SoftI2C és a machine.SoftSPI bármely GPIO‑n működik, ha egy további buszra van szükséged.

Hőkamera érzékelő (külső)

A firmware tartalmazza a fir — hőérzékelő-meghajtó (fir == far infrared, távoli infravörös) illesztőprogramot a külsőleg bekötött hőkamerákhoz:

• MLX90621 — 16 × 4 IR tömb

• MLX90640 — 32 × 24 IR tömb

• MLX90641 — 16 × 12 IR tömb

• AMG8833 — 8 × 8 IR tömb

Kösd a modult a kártya I²C buszára, és olvass be képkockákat a fir.init() + fir.snapshot() segítségével:

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

A fir illesztőprogram csak az I²C 2‑n keresztül kommunikál az érzékelővel — kösd a modult a P4 (SCL) és P5 (SDA) lábakra.

Időzítés

time

A time modul lefedi a blokkoló késleltetéseket, a monoton tick‑eket és az eltelt idő mérését:

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)

Virtuális időzítők

A machine.Timer periodikus vagy egyszeri visszahívásokat ütemez anélkül, hogy egy hardveres időzítő helyét felhasználná. Add át a -1‑et id‑ként egy virtuális (szoftveres) időzítő használatához:

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

A periódusértékek ezredmásodpercben vannak megadva. Hívd meg a deinit() metódust a leállításhoz és a hely felszabadításához.

Valós idejű óra

A machine.RTC megőrzi a fali órát az újraindításokon át, és (a hátoldali pontokra bekötött opcionális 3,3 V‑os tartalék akkumulátorral, lásd Tápellátási lábak) a teljes áramkimaradáson át is:

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

Az RTC mélyalvás közben is fut, így ébresztési forrásként használhatod a machine.deepsleep() számára.

Watchdog

A machine.WDT alaphelyzetbe állítja a kártyát, ha az alkalmazás lefagy. Elindítása után nem lehet leállítani vagy újrakonfigurálni — etesd rendszeresen a fő ciklusodon belül:

from machine import WDT

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

Indítási és futásidejű információk

USB rendszerbetöltő ablak

Minden bekapcsoláskor a kamera egy rövid rendszerbetöltőt futtat (néhány másodperc), amely lehetővé teszi az OpenMV IDE számára a firmware frissítését anélkül, hogy a felhasználónak DFU módba kellene lépnie. Az ablak lejárta után a rendszerbetöltő átadja a vezérlést a boot.py‑nak, majd a main.py‑nak.

Egy futó szkript igény szerint újra beléphet a rendszerbetöltőbe a machine.bootloader() meghívásával:

import machine

machine.bootloader()

Fájlrendszer és indítási sorrend

Az N6 firmware indításkor akár három fájlrendszert is csatol:

• Belső flash — mindig a /flash ponton csatolva. Alapból a main.py‑t és a README.txt‑et tartalmazza; a legelső indításkor jön létre.

• microSD kártya — ha egy kártya van behelyezve, az a /sdcard ponton csatolódik.

• ROMFS — csak olvasható, memóriába leképezett fájlrendszer a /rom ponton, amelyet nagy adatállományok (pl. AI modellek) szállítására használnak, amelyek profitálnak a nulla másolásos hozzáférésből. A MicroPython automatikusan csatolja indításkor, mielőtt bármilyen felhasználói Python lefutna.

A csatolás után a munkakönyvtár a /sdcard‑ra állítódik, ha a kártya jelen van, egyébként a /flash‑re. Az értelmező ezután ebből a könyvtárból futtatja a szkripteket:

• A boot.py minden szoftveres újraindításkor lefut (hidegindítás, Ctrl‑D a REPL‑ből, vagy valahányszor a futó szkript visszatér).

• A main.py csak hidegindításkor fut le, közvetlenül a boot.py után. A későbbi szoftveres újraindítások újra lefuttatják a boot.py‑t, de egyből a REPL‑re lépnek — a main.py újrafuttatásához teljesen alaphelyzetbe kell állítanod a kártyát.

Egy boot.py vagy main.py SD kártyára helyezése felülírja a flashben lévő példányt annak megérintése nélkül — mindkét fájlt az indítási könyvtárban keresi a rendszer (/sdcard, ha a kártya csatolva van, egyébként /flash).

A frissen flashelt kártyán szállított alapértelmezett main.py csak villogtatja a felhasználói RGB LED kék csatornáját szívverésként (két rövid villanás, rövid szünet), így anélkül is megállapíthatod, hogy a firmware tisztán elindult, hogy bármilyen gazdagép csatlakozna.

A sys.path kibővül mind a három fájlrendszerrel és azok lib/ alkönyvtáraival, így az importálható modulok elhelyezkedhetnek a /flash/lib, /sdcard/lib vagy /rom/lib mappákban.

Ahhoz, hogy a rendszert egy behelyezett SD kártya figyelmen kívül hagyására kényszerítsd (például hogy a flash main.py‑ját futtasd akkor is, ha kártya van jelen), hozz létre egy üres, SKIPSD nevű fájlt a /flash gyökerében.

USB‑n keresztül csatlakoztatva az indítási fájlrendszer (/sdcard, ha kártya van jelen, egyébként /flash) USB tömegtároló meghajtóként is megjelenik a gazdagépen, ami lehetővé teszi a boot.py, main.py és bármely más fájl közvetlen szerkesztését. Vesd ki a meghajtót, mielőtt alaphelyzetbe állítanád a kamerát, hogy a gazdagép kiürítse a gyorsítótárazott írásokat.

Megjegyzés

Mivel az operációs rendszer a meghajtót passzív blokkeszközként kezeli, az OpenMV Cam‑en futó kód által létrehozott vagy módosított fájlok nem jelennek meg, amíg a gazdagép újra nem csatolja a meghajtót. Ha az operációs rendszer és az OpenMV Cam egyszerre írja ugyanazt a fájlrendszert, az operációs rendszer győz, és felülírja a kamera által végzett módosításokat. Használd az SD kártyát minden olyan adathoz, amelyet a szkript visszaír, és csatold újra, mielőtt ezeket a fájlokat a gazdagépről olvasnád.

Megjegyzés

A felhasználói RGB LED vörös csatornája rövid időre felvillanhat, miközben a gazdagép az USB tömegtároló meghajtóról olvas vagy arra ír — ez egy firmware által vezérelt aktivitásjelző, nem hiba.

Tárolóméretek

Az N6 a következőkkel kerül szállításra:

• /flash — 4 MB FAT fájlrendszer, írható/olvasható.

• /rom — 24 MB csak olvasható, memóriába leképezett ROMFS, amelyet szkriptek és ML modellek szállítására használnak, amelyek profitálnak a nulla másolásos mmap hozzáférésből.

• /sdcard — a behelyezett microSD kártya teljes mérete (ha jelen van), írható/olvasható.

Hard‑fault jelző

Ha a felhasználói RGB LED gyorsan végigfut az összes színen — elég gyorsan ahhoz, hogy inkább csillogó fehér LED‑nek tűnjön, mint különálló árnyalatoknak —, akkor a firmware helyrehozhatatlan hard fault‑ba ütközött. A helyreállításhoz flasheld újra a firmware‑t; ha az újraflashelés nem segít, a kártya fizikailag sérült lehet.

Szoftverkönyvtárak

A modulok teljes listájáért lásd a könyvtár indexet — beleértve azt is, hogy melyek egyediek az N6 buildhez.