OpenMV N6

OpenMV N6 este construit în jurul cipului STMicroelectronics STM32N657 (Cortex‑M55 @ 800 MHz) cu un NPU integrat de 1 GHz evaluat la 600 GOPS INT8. Placa combină NPU‑ul cu senzorul cu obturator global PAG7936 de 1 MP montat pe un suport detașabil, Ethernet gigabit, USB‑C de mare viteză, Wi‑Fi și Bluetooth 5.1, și rulează inferența YOLOv8/YOLOv11 la 30 FPS în paralel cu transmiterea video în timp real.

OpenMV N6

Pentru fișa tehnică completă, fotografii și dimensiuni, consultați pagina de produs OpenMV N6.

Aspecte importante

  • STM32N657 Cortex‑M55 la 800 MHz (1280 DMIPS) cu ARM Helium SIMD pe 128 de biți — debit vectorial de 6,4 gigaops.

  • NPU de 1 GHz, 600 GOPS INT8 — rulează detectarea YOLOv8/YOLOv11 la 30 FPS.

  • ISP pentru RAW Bayer de până la 5MP, GPU 2D pentru scalare și rotație 3D, codare H.264 la 1080p și codec JPEG hardware.

  • 64 MB de SDRAM extern (16 biți @ 200 MHz DDR, 800 MB/s) plus 4,2 MB de SRAM intern și 32 MB de memorie flash octală (200 MHz DDR, 400 MB/s).

  • Senzor color cu obturator global PAG7936 de 1 MP.

  • IMU integrat (accelerometru + giroscop) și microfon pentru fuziunea audio + mișcare.

  • USB‑C de mare viteză (480 Mb/s, limită de curent de 1,5 A), Ethernet gigabit (compatibil PoE prin shield), Wi‑Fi a/b/g/n + Bluetooth 5.1 (antenă pe cip sau opțiune U.FL).

  • Soclu microSD — SD până la 2 GB, SDHC până la 32 GB, SDXC până la 2 TB.

  • Încărcător LiPo (încărcare rapidă 500 mA), ADC pentru tensiunea bateriei, RTC cu 8 KB de RAM de rezervă și un pin dedicat pentru bateria de rezervă.

  • 18 pini de I/O, toți cu ieșire 3,3 V / toleranți la 3,3 V, 20 mA per pin, capabili de întrerupere.

  • LED RGB de utilizator, buton de utilizator și un LED de stare separat pentru încărcare / USB / alimentare VIN.

Atenționare

Pinii de I/O ai N6 nu sunt toleranți la 5 V. Nu conectați dispozitivul direct la un MCU de 5 V precum Arduino Mega. Alimentați N6 doar prin VIN.

Dispunerea pinilor

Dispunerea pinilor OpenMV N6 PAG7936

Referință pini

Nume pin

Funcție

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 (fără ADC pe acest pin — vezi P6_ADC)

P6_ADC

intrare ADC dedicată pe 12 biți (legată intern la P6)

P7

TIM4 CH1

P8

TIM4 CH2

P9

TIM17 CH1

P10

TIM15 CH2 / I/O de sincronizare cadre

P11

wakeup (activ pe nivel jos, WKUP3)

P12

RESET — trageți la GND pentru a reseta placa (nu este un GPIO)

P13

UART7 RX

P14

UART7 TX

P15

SPI4 CS

P16

SPI4 SCK

P17

SPI4 MISO

P18

SPI4 MOSI

SW

buton de utilizator (activ pe nivel jos)

ONOFF (SW2)

buton de trezire din somn profund (activ pe nivel jos, WKUP2)

ST

jos la alimentare VIN, sus la alimentare USB

CHG

activ pe nivel jos; jos în timp ce o baterie LiPo atașată se încarcă

PG

activ pe nivel jos; jos când este prezentă alimentarea VIN sau USB

BAT_ADC

canal ADC intern care măsoară tensiunea bateriei LiPo atașate

LED_RED

canalul roșu al LED‑ului RGB (activ pe nivel jos)

LED_GREEN

canalul verde al LED‑ului RGB (activ pe nivel jos)

LED_BLUE

canalul albastru al LED‑ului RGB (activ pe nivel jos)

Notă

Linia de sincronizare a cadrelor P10 este o magistrală partajată. Este conectată simultan la MCU, la pinul de declanșare / expunere al senzorului camerei și la conectorul de utilizator. Direcția este definită de aplicație — MCU‑ul, senzorul sau un semnal extern îl pot conduce, în funcție de modul în care este configurat senzorul (unii senzori pot folosi același pin ca intrare de declanșare sau ca ieșire de expunere). Asigurați‑vă că un singur driver este activ la un moment dat.

Notă

ONOFF și P11 sunt raportate la magistrala RAW mereu activă (nu la magistrala comutată de 3,3 V), așa că rămân funcționale în timp ce restul plăcii se află în somn profund / mod de consum redus. Ambele intrări sunt active pe nivel jos.

Acești pini trec prin convertoare de nivel pentru a putea funcționa pe magistrala RAW. Dacă aveți absolută nevoie de comportament GPIO direct la 3,3 V pe ONOFF sau P11 (de exemplu pentru a‑i conduce de la un MCU de 3,3 V fără a trece prin convertor), placa expune pad‑uri cu pull‑up și jumper de 0 ohmi care vă permit să ocoliți convertorul. Aceasta este o modificare hardware avansată — majoritatea utilizatorilor ar trebui să nu o atingă.

Notă

P15–P18 sunt partajați cu PHY‑ul Ethernet Gigabit, care este conectat și activ în mod implicit. Pentru a folosi acești pini ca I/O de utilizator trebuie să resudați rezistorul de 0 ohmi de pe spatele plăcii în poziția GPIO. Acest lucru dezactivează doar Ethernet gigabit — Ethernet 10/100 Mb/s continuă să funcționeze pe pinii săi dedicați.

Pini de alimentare

  • 3.3V — magistrală reglată de 3,3 V. Doar ieșire pe N6 — nu alimentați acest pin cu energie externă. Până la 1 A disponibil pentru shield‑uri.

  • VIN — intrare de 5 V. Alimentează placa și încărcătorul LiPo de la bord.

  • RAW — intrare/ieșire, mereu activă (3,6 V – 5 V). Transportă oricare sursă este activă (VIN, USB sau bateria atașată) și poate fi folosită și ca intrare. Trebuie să alimentați RAW printr‑o diodă în serie când injectați energie în el — altfel curentul va curge înapoi în VIN/USB și va deteriora sursa de alimentare sau protecția de la bord.

  • GND — masă comună.

Notă

Cipul de gestionare a alimentării de la bord alege automat care dintre USB sau VIN are tensiunea mai mare pentru a alimenta placa și încărcătorul de baterie. Dacă este atașată o baterie LiPo, aceasta se încarcă din rezerva disponibilă, iar controlerul revine la baterie pentru a menține placa în funcțiune dacă VIN/USB scad sau sunt deconectate.

Notă

Spatele plăcii are pad‑uri de lipit pentru o baterie externă de rezervă RTC de 3,3 V. Conectarea unei baterii tip pastilă la aceste pad‑uri menține RTC‑ul și cei 8 KB de RAM de rezervă în funcțiune în timp ce restul plăcii este nealimentat.

Sfat

Folosiți estimatorul duratei de viață a bateriei pentru a modela cât timp va funcționa N6 cu o baterie pentru un anumit ciclu de funcționare activă / somn profund.

Pini Ethernet

N6 expune perechile MDI ale PHY‑ului Ethernet pe pad‑uri dedicate de lângă conectorul GPIO. Pinii MDI nu pot fi conectați în siguranță direct la un RJ45 — magneticele Ethernet (un transformator de izolare, fie încorporat într‑un magjack, fie pe shield) sunt necesare între PHY și cablu. Shield‑ul PoE OpenMV le include; dacă vă construiți propriul mufa, folosiți un RJ45 cu magnetice integrate sau un transformator extern.

  • ETH_LED — LED de legătură/activitate. Activ pe nivel jos când legătura este stabilită; clipește la trafic.

  • DA P / DA N — perechea A (TX la 10/100, folosită la toate vitezele).

  • DB P / DB N — perechea B (RX la 10/100, folosită la toate vitezele).

  • DC P / DC N — perechea C, folosită doar la gigabit.

  • DD P / DD N — perechea D, folosită doar la gigabit.

10/100 Mb/s necesită doar perechile A și B. Gigabit necesită toate cele patru perechi A–D.

Pini de recuperare și depanare

  • RESET — trageți la GND pentru a reseta placa. Eliberarea lui permite MCU‑ului să pornească normal.

  • BOOT0 — trageți la 3,3 V în timp ce alimentați placa pentru a intra în modul bootloader ROM. OpenMV IDE folosește acest mod pentru a reprograma bootloader‑ul de la bord.

  • BOOT1 — comutator care pune placa în mod de dezvoltator pentru utilizarea cu instrumentele ST (un ST‑LINK atașat la conectorul ARM cu 10 pini SWD/JTAG). Lăsați‑l dezactivat pentru funcționarea normală cu firmware‑ul și instrumentele OpenMV.

Este montat un conector dedicat ARM cu 10 pini SWD/JTAG, compatibil cu adaptoarele ST‑LINK și SEGGER J‑Link.

Periferice de la bord

LED‑uri

N6 are două LED‑uri RGB:

  • LED RGB de utilizator — controlabil prin software, expus ca LED_RED, LED_GREEN și LED_BLUE

    from machine import LED

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

  • LED de alimentare — condus direct de hardware‑ul de gestionare a alimentării de la bord, fără control software. Folosiți‑l pentru a vedea dintr‑o privire ce face sursa de alimentare.

    În timpul funcționării:

    Canal

    Semnificație

    Albastru

    VIN alimentează placa (stins la USB)

    Verde

    alimentare USB sau VIN prezentă

    Roșu

    se încarcă o baterie LiPo atașată

    În somn profund toate canalele sunt stinse cu excepția celui roșu, care încă luminează în timp ce o baterie LiPo se încarcă.

Butoane de utilizator

N6 are două butoane:

  • SW — buton de utilizator de uz general. Activ când este tras la nivel jos.

  • ONOFF (SW2) — buton de trezire. Singurul buton care poate scoate placa din somnul profund.

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

Pentru a pune placa în somn profund și a o trezi din nou cu ONOFF (SW2), apelați doar machine.deepsleep() — nu este necesară nicio configurare de trezire, butonul este conectat direct la intrarea WKUP2:

import machine

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

Puteți de asemenea să conectați ONOFF ca un comutator de alimentare soft. Declanșați pe frontul crescător — linia se stabilizează la nivel sus după ce utilizatorul eliberează butonul, așa că următoarea apăsare este în mod neechivoc un eveniment de trezire:

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.

Pini de stare a alimentării

Trei intrări de stare active pe nivel jos permit firmware‑ului să vadă ce face cipul de gestionare a alimentării de la bord:

  • ST — jos când placa funcționează pe VIN, sus când funcționează pe alimentare USB.

  • CHG — jos în timp ce o baterie LiPo atașată se încarcă.

  • PG — jos când este prezentă alimentarea VIN sau USB.

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

Senzorul camerei

PAG7936 este controlat prin modulul csi — senzori de cameră

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

Senzorul se află pe un modul detașabil — înlocuiți‑l cu oricare dintre celelalte module de cameră OpenMV (obturator global, termic, rezoluție mai mare etc.) fără a schimba restul plăcii.

PAG7936 acceptă modul declanșat — integrarea pixelilor se aliniază exact cu fiecare apel csi.CSI.snapshot în loc de ceasul de cadre cu rulare liberă, util pentru sincronizarea capturii cu un eveniment extern sau cu un alt senzor. Activați‑l prin csi.CSI.ioctl cu csi.IOCTL_SET_TRIGGERED_MODE. Rata de cadre scade la aproximativ jumătate față de modul cu rulare liberă deoarece citirea nu mai este suprapusă cu integrarea cadrului următor:

cam.ioctl(csi.IOCTL_SET_TRIGGERED_MODE, True)

NPU

NPU‑ul Neural‑ART de 1 GHz al N6 (600 GOPS INT8) este expus prin modulul ml — Învățare automată. Modelele stocate în sistemul de fișiere doar‑citire /rom se încarcă direct din memoria flash fără a fi copiate în RAM, așa că până și detectoarele mari încap confortabil alături de tamponul de cadre (frame buffer) în timp real. Rulați un detector YOLOv8 pe fiecare cadru și desenați predicțiile peste imaginea în timp real:

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

Microfon

Microfonul de la bord este captat prin audio — Modulul Audio. Fiecare tampon (buffer) sosește ca un bytearray PCM pe 16 biți cu semn, ceea ce face foarte simplă transmiterea sa către ulab/numpy pentru DSP rapid. Un detector simplu de intensitate sonoră — afișează ori de câte ori volumul RMS depășește un prag:

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

Accelerometrul + giroscopul de la bord, situat sub modulul camerei, este expus prin imu — senzor imu

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

Cipul CYW43439 de la bord este expus prin network — configurarea rețelei ca interfață de stație. După conectare, ipconfig("addr4") returnează perechea (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

Același CYW43439 expune de asemenea Bluetooth 5.1. Folosiți aioble — BLE asincron pentru BLE compatibil cu asyncio — de exemplu, anunțați‑vă ca periferic și așteptați ca un dispozitiv central să se conecteze:

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

Când un RJ45 (cu magnetice) este conectat la pad‑urile MDI, PHY‑ul gigabit apare ca interfață LAN. DHCP rulează automat odată ce legătura este stabilită:

import network, time

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

Card microSD

Când un card este introdus, este montat automat la /sdcard și poate fi utilizat prin sistemul de fișiere obișnuit:

import os

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

Referință magistrale

GPIO

Folosiți machine.Pin pentru a citi sau conduce oricare dintre pinii serigrafiați. Ieșirile sunt CMOS de 3,3 V și pot absorbi/furniza până la 20 mA per pin.

from machine import Pin

out = Pin("P0", Pin.OUT)
out.on()
out.off()
out.value(1)

inp = Pin("P1", Pin.IN, Pin.PULL_UP)
print(inp.value())

Orice pin de intrare poate de asemenea declanșa o întrerupere la tranzițiile de front:

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

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

UART

Magistrală

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

Magistrală

SCL

SDA

I2C2

P4

P5

 
from machine import I2C

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

Același hardware poate fi folosit și în mod țintă (slave) prin machine.I2CTarget pentru a expune o regiune de memorie unui alt controler I²C:

from machine import I2CTarget

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

SPI

Magistrală

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

Magistrală

TX

RX

CAN1

P2

P3

Notă

CAN nu este încă acceptat pe această placă în firmware‑ul 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

Ambele canale ADC trec printr‑un divizor de tensiune tamponat cu amplificator operațional înainte de a ajunge la MCU, așa că read_u16() este mapat la o tensiune de intrare la scară completă diferită pe fiecare pin.

Pin

Scară completă

Note

P6_ADC

~3,3 V

pad de uz general, legat intern la P6

BAT_ADC

~5,0 V

canal intern pentru bateria LiPo

 
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

Temporizator / canal

P4

TIM2 CH3

P5

TIM2 CH4

P6

TIM12 CH1

P7

TIM4 CH1

P8

TIM4 CH2

P9

TIM17 CH1

P10

TIM15 CH2

Conduceți oricare dintre ele prin machine.PWM

from machine import Pin, PWM

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

Magistrale software bit‑banged

machine.SoftI2C și machine.SoftSPI funcționează pe orice GPIO dacă aveți nevoie de o magistrală suplimentară.

Senzor termic (extern plăcii)

Firmware‑ul include driverul fir — driver pentru senzori termici (fir == far infrared) pentru imagistice termice conectate extern:

  • MLX90621 — matrice IR 16 × 4

  • MLX90640 — matrice IR 32 × 24

  • MLX90641 — matrice IR 16 × 12

  • AMG8833 — matrice IR 8 × 8

Conectați modulul la magistrala I²C a plăcii și citiți cadre cu 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())

Driverul fir comunică cu senzorul doar prin I²C 2 — conectați modulul la P4 (SCL) și P5 (SDA).

Temporizare

time

Modulul time acoperă întârzieri blocante, tact‑uri monotone și măsurarea timpului scurs:

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)

Temporizatoare virtuale

machine.Timer programează funcții de retroapelare (callback) periodice sau unice fără a consuma un slot de temporizator hardware. Transmiteți -1 ca id pentru a folosi un temporizator virtual (software):

from machine import Timer

one_shot = Timer(-1)
one_shot.init(period=5_000, mode=Timer.ONE_SHOT,
              callback=lambda t: print("once"))

periodic = Timer(-1)
periodic.init(period=2_000, mode=Timer.PERIODIC,
              callback=lambda t: print("tick"))

Valorile perioadei sunt în milisecunde. Apelați deinit() pentru a opri și elibera slotul.

Ceas în timp real

machine.RTC păstrează ora de perete între resetări și (cu bateria opțională de rezervă de 3,3 V conectată la pad‑urile din spate, vezi Pini de alimentare) în cazul pierderii totale a alimentării:

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‑ul funcționează de asemenea pe durata somnului profund, așa că îl puteți folosi ca sursă de trezire pentru machine.deepsleep().

Watchdog

machine.WDT resetează placa dacă aplicația se blochează. Odată pornit, nu poate fi oprit sau reconfigurat — alimentați‑l periodic în interiorul buclei principale:

from machine import WDT

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

Informații de pornire și de rulare

Fereastra bootloader‑ului USB

La fiecare pornire camera rulează un bootloader scurt (câteva secunde) care permite OpenMV IDE să actualizeze firmware‑ul fără ca utilizatorul să fie nevoit să intre în modul DFU. După expirarea ferestrei, bootloader‑ul predă controlul către boot.py și apoi către main.py.

Un script în execuție poate reintra în bootloader la cerere apelând machine.bootloader()

import machine

machine.bootloader()

Sistemul de fișiere și ordinea de pornire

Firmware‑ul N6 montează până la trei sisteme de fișiere la pornire:

  • Memorie flash internă — întotdeauna montată la /flash. Conține implicit main.py și README.txt; creată la prima pornire.

  • Card microSD — dacă un card este introdus, acesta este montat la /sdcard.

  • ROMFS — sistem de fișiere doar‑citire, mapat în memorie la /rom, folosit pentru a livra resurse mari de date (de exemplu, modele AI) care beneficiază de acces fără copiere. Montat automat de MicroPython la pornire, înainte de rularea oricărui cod Python al utilizatorului.

După montare, directorul de lucru este setat la /sdcard când cardul este prezent, altfel la /flash. Interpretorul rulează apoi scripturile din acel director:

  • boot.py este executat la fiecare resetare soft (pornire la rece, Ctrl‑D din REPL sau ori de câte ori scriptul în execuție se încheie).

  • main.py este executat doar la pornirea la rece, imediat după boot.py. Resetările soft ulterioare reexecută boot.py dar trec direct la REPL — pentru a reexecuta main.py trebuie să resetați complet placa.

Plasarea unui boot.py sau main.py pe cardul SD anulează copia din memoria flash fără a o atinge — ambele fișiere sunt căutate în directorul de pornire (/sdcard când cardul este montat, altfel /flash).

Fișierul main.py implicit livrat pe o placă proaspăt programată doar face să clipească canalul albastru al LED‑ului RGB de utilizator ca semnal de viață (două impulsuri scurte, pauză scurtă), așa că puteți spune că firmware‑ul a pornit corect fără niciun host atașat.

sys.path este extins pentru a include toate cele trei sisteme de fișiere și subdirectoarele lor lib/, așa că modulele importabile pot fi în /flash/lib, /sdcard/lib sau /rom/lib.

Pentru a forța sistemul să ignore un card SD introdus (de exemplu pentru a rula main.py din flash chiar și cu un card prezent), creați un fișier gol numit SKIPSD în rădăcina /flash.

Când este conectat prin USB, sistemul de fișiere de pornire (/sdcard dacă un card este prezent, altfel /flash) se enumeră de asemenea ca unitate de stocare în masă USB pe host, permițându‑vă să editați direct boot.py, main.py și orice alte fișiere. Ejectați unitatea înainte de a reseta camera pentru ca host‑ul să golească scrierile sale din cache.

Notă

Deoarece sistemul de operare tratează unitatea ca un dispozitiv de bloc pasiv, fișierele create sau modificate de codul care rulează pe OpenMV Cam nu vor apărea până când host‑ul nu remontează unitatea. Dacă atât sistemul de operare, cât și OpenMV Cam scriu în același sistem de fișiere în același timp, sistemul de operare va câștiga și va suprascrie modificările făcute de cameră. Folosiți cardul SD pentru orice date pe care scriptul le scrie înapoi și remontați înainte de a citi acele fișiere de pe host.

Notă

Canalul roșu al LED‑ului RGB de utilizator se poate aprinde scurt în timp ce host‑ul citește din sau scrie în unitatea de stocare în masă USB — acesta este un indicator de activitate condus de firmware, nu o defecțiune.

Dimensiunile de stocare

N6 este livrat cu:

  • /flash — sistem de fișiere FAT de 4 MB, citire/scriere.

  • /rom — ROMFS doar‑citire mapat în memorie de 24 MB, folosit pentru a livra scripturi și modele ML care beneficiază de acces mmap fără copiere.

  • /sdcard — dimensiunea completă a oricărui card microSD introdus (când este prezent), citire/scriere.

Indicator de eroare gravă (hard fault)

Dacă LED‑ul RGB de utilizator parcurge rapid toate culorile — suficient de rapid încât tinde să arate ca un LED alb scânteietor mai degrabă decât ca nuanțe distincte — firmware‑ul a întâmpinat o eroare gravă irecuperabilă (hard fault). Reprogramați firmware‑ul pentru a recupera; dacă reprogramarea nu ajută, placa poate fi deteriorată fizic.

Biblioteci software

Consultați indexul de biblioteci pentru lista completă de module — inclusiv cele care sunt unice pentru build‑ul N6.