OpenMV N6¶

O OpenMV N6 é construído em torno do STMicroelectronics STM32N657 (Cortex‑M55 a 800 MHz) com uma NPU integrada a 1 GHz com 600 GOPS INT8. A placa combina a NPU com o sensor de obturador global PAG7936 de 1 MP num módulo amovível, Ethernet gigabit, USB‑C de alta velocidade, Wi‑Fi e Bluetooth 5.1, e executa inferência YOLOv8/YOLOv11 a 30 FPS com transmissão de vídeo em direto.

Para ficha técnica completa, fotos e dimensões, consulte a página do produto OpenMV N6.

Destaques¶

STM32N657 Cortex‑M55 a 800 MHz (1280 DMIPS) com ARM Helium SIMD de 128 bits — débito vetorial de 6,4 gigaops.
NPU a 1 GHz, 600 GOPS INT8 — executa deteção YOLOv8/YOLOv11 a 30 FPS.
ISP para RAW Bayer até 5 MP, GPU 2D para escalonamento e rotação 3D, codificação H.264 até 1080p, e codec JPEG por hardware.
64 MB de SDRAM externa (16 bits a 200 MHz DDR, 800 MB/s) mais 4,2 MB de SRAM interna e 32 MB de flash octal (200 MHz DDR, 400 MB/s).
Sensor de obturador global colorido PAG7936 de 1 MP.
IMU integrada (acelerómetro + giroscópio) e microfone para fusão de áudio e movimento.
USB‑C de alta velocidade (480 Mb/s, limite de corrente 1,5 A), Ethernet gigabit (compatível com PoE via shield), Wi‑Fi a/b/g/n + Bluetooth 5.1 (antena de chip ou opção U.FL).
Socket microSD — SD até 2 GB, SDHC até 32 GB, SDXC até 2 TB.
Carregador LiPo (carga rápida a 500 mA), ADC de tensão de bateria, RTC com 8 KB de RAM de reserva e um pino dedicado de bateria de reserva.
18 pinos de I/O, todos com saída 3,3 V / tolerantes a 3,3 V, 20 mA por pino, com capacidade de interrupção.
LED RGB de utilizador, botão de utilizador e um LED de estado separado para carregamento / USB / alimentação VIN.

Aviso

Os pinos de I/O do N6 não são tolerantes a 5 V. Não ligue o dispositivo diretamente a um MCU de 5 V como o Arduino Mega. Alimente o N6 apenas através de VIN.

Diagrama de pinos¶

Referência de pinos¶

Nome do pino	Função
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 (sem ADC neste pino — ver `P6_ADC`)
P6_ADC	entrada ADC dedicada de 12 bits (ligada internamente a P6)
P7	TIM4 CH1
P8	TIM4 CH2
P9	TIM17 CH1
P10	TIM15 CH2 / sincronização de fotograma I/O
P11	ativação (ativo baixo, WKUP3)
P12	RESET — ligar a GND para reiniciar a placa (não é um GPIO)
P13	UART7 RX
P14	UART7 TX
P15	SPI4 CS
P16	SPI4 SCK
P17	SPI4 MISO
P18	SPI4 MOSI
SW	botão de utilizador (ativo baixo)
ONOFF (SW2)	botão de ativação após sono profundo (ativo baixo, WKUP2)
ST	baixo com alimentação VIN, alto com alimentação USB
CHG	ativo baixo; baixo enquanto uma bateria LiPo ligada está a carregar
PG	ativo baixo; baixo quando existe alimentação VIN ou USB
BAT_ADC	canal ADC interno que mede a tensão da bateria LiPo ligada
LED_RED	canal vermelho do LED RGB (ativo baixo)
LED_GREEN	canal verde do LED RGB (ativo baixo)
LED_BLUE	canal azul do LED RGB (ativo baixo)

Nota

A linha de sincronização de fotograma P10 é um barramento partilhado. Está ligada ao MCU, ao pino de disparo/exposição do sensor de câmara e ao conector de utilizador em simultâneo. A direção é definida pela aplicação — o MCU, o sensor ou um sinal externo podem conduzi-la consoante a configuração do sensor (alguns sensores podem usar o mesmo pino como entrada de disparo ou saída de exposição). Certifique-se de que apenas um controlador está ativo de cada vez.

Nota

ONOFF e P11 são referenciados ao rail RAW sempre ativo (não ao rail de 3,3 V comutado), pelo que permanecem funcionais enquanto o resto da placa está em modo de sono profundo / baixo consumo. Ambas as entradas são ativas baixas.

Estes pinos passam por conversores de nível, pelo que podem operar no rail RAW. Se precisar absolutamente de comportamento GPIO direto a 3,3 V em ONOFF ou P11 (por exemplo para os controlar a partir de um MCU de 3,3 V sem passar pelo conversor), a placa expõe pads de resistência de pull-up e jumper de 0 ohm que permitem contornar o conversor. Trata-se de uma modificação de hardware avançada — a maioria dos utilizadores deve deixar como está.

Nota

P15–P18 são partilhados com o PHY Ethernet Gigabit, que está ligado e ativo por predefinição. Para usar estes pinos como I/O de utilizador, é necessário refundir a resistência de 0 ohm no verso da placa para a posição GPIO. Isto apenas desativa o Ethernet gigabit — o Ethernet 10/100 Mb/s continua a funcionar nos seus pinos dedicados.

Pinos de alimentação¶

3.3V — rail de 3,3 V regulado. Apenas saída no N6 — não alimente energia externa neste pino. Disponível até 1 A para shields.
VIN — entrada de 5 V. Alimenta a placa e o carregador LiPo integrado.
RAW — entrada/saída, sempre ativo (3,6 V – 5 V). Transporta a fonte ativa (VIN, USB ou bateria ligada) e também pode ser usado como entrada. Deve ligar RAW através de um díodo em série ao fornecer energia — caso contrário, a corrente fluirá de volta para VIN/USB e danificará a fonte ou a proteção integrada.
GND — terra comum.

Nota

O chip de gestão de energia integrado seleciona automaticamente a fonte com maior tensão entre USB e VIN para alimentar a placa e o carregador de bateria. Se uma bateria LiPo estiver ligada, carrega com a margem disponível, e o controlador comuta para a bateria para manter a placa a funcionar se VIN/USB diminuírem ou forem desligados.

Nota

O verso da placa tem pads de soldadura para uma bateria de reserva RTC externa de 3,3 V. Ligar uma pilha de botão a estes pads mantém o RTC e 8 KB de RAM de reserva a funcionar enquanto o resto da placa está sem alimentação.

Dica

Utilize o estimador de autonomia de bateria para modelar quanto tempo o N6 funcionará com uma bateria para um determinado ciclo de trabalho ativo/sono profundo.

Pinos Ethernet¶

O N6 expõe os pares MDI do PHY Ethernet em pads dedicados junto ao conector GPIO. Os pinos MDI não podem ser ligados diretamente a um RJ45 — é obrigatório o uso de magnéticos Ethernet (transformador de isolamento, integrado num magjack ou no shield) entre o PHY e o cabo. O shield PoE da OpenMV inclui-os; se estiver a criar o seu próprio conector, utilize um RJ45 com magnéticos integrados ou um transformador externo.

ETH_LED — LED de ligação/atividade. Ativo baixo quando há ligação; pisca com tráfego.
DA P / DA N — par A (TX em 10/100, usado em todas as velocidades).
DB P / DB N — par B (RX em 10/100, usado em todas as velocidades).
DC P / DC N — par C, apenas usado em gigabit.
DD P / DD N — par D, apenas usado em gigabit.

10/100 Mb/s apenas necessita dos pares A e B. Gigabit necessita dos quatro pares A–D.

Pinos de recuperação e depuração¶

RESET — ligar a GND para reiniciar a placa. Ao soltar, o MCU inicia normalmente.
BOOT0 — ligar a 3,3 V ao ligar a placa para entrar no modo de bootloader ROM. O OpenMV IDE usa este modo para reflashear o bootloader integrado.
BOOT1 — interruptor que coloca a placa em modo de programador para utilização com as ferramentas da ST (um ST‑LINK ligado ao conector SWD/JTAG ARM de 10 pinos). Deixe desativado para operação normal com o firmware e ferramentas OpenMV.

Está instalado um conector ARM SWD/JTAG de 10 pinos, compatível com adaptadores ST‑LINK e SEGGER J‑Link.

Periféricos integrados¶

LEDs¶

O N6 tem dois LEDs RGB:

LED RGB de utilizador — controlável por software, exposto como LED_RED, LED_GREEN e LED_BLUE

from machine import LED

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

LED de alimentação — controlado diretamente pelo hardware de gestão de energia integrado, sem controlo por software. Use-o para verificar o estado da alimentação de relance.

Durante o funcionamento:

Canal

Significado

Azul

VIN está a alimentar a placa (apagado em USB)

Verde

Alimentação USB ou VIN presente

Vermelho

a carregar uma bateria LiPo ligada

Em sono profundo, todos os canais estão apagados exceto o Vermelho, que continua a acender enquanto uma bateria LiPo está a carregar.

Canal	Significado
Azul	VIN está a alimentar a placa (apagado em USB)
Verde	Alimentação USB ou VIN presente
Vermelho	a carregar uma bateria LiPo ligada

Botões de utilizador¶

O N6 tem dois botões:

SW — botão de utilizador de uso geral. Ativo quando baixo.
ONOFF (SW2) — botão de ativação. O único botão que pode retirar a placa do sono profundo.

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

Para colocar a placa em sono profundo e ter o ONOFF (SW2) a ativá-la novamente, basta chamar machine.deepsleep() — não é necessária configuração de ativação, o botão está ligado diretamente à entrada WKUP2:

import machine

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

Também pode ligar ONOFF como interruptor de alimentação por software. Dispare na transição de subida — a linha estabiliza alto após o utilizador soltar o botão, pelo que a próxima pressão é inequivocamente um evento de ativação:

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.

Pinos de estado de alimentação¶

Três entradas de estado ativas baixas permitem ao firmware saber o que o chip de gestão de energia integrado está a fazer:

ST — baixo quando a placa está a funcionar com VIN, alto quando está a funcionar com alimentação USB.
CHG — baixo enquanto uma bateria LiPo ligada está a carregar.
PG — baixo quando a alimentação VIN ou USB está presente.

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

Sensor de câmara¶

O PAG7936 é controlado através do módulo csi — sensores de câmara

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

O sensor encontra-se num módulo amovível — troque-o por qualquer um dos outros módulos de câmara OpenMV (obturador global, térmico, resolução superior, etc.) sem alterar o resto da placa.

O PAG7936 suporta o modo disparado — a integração de píxeis alinha-se exatamente com cada chamada csi.CSI.snapshot em vez do relógio de fotograma em modo livre, útil para sincronizar a captura com um evento externo ou outro sensor. Ative-o através de csi.CSI.ioctl com csi.IOCTL_SET_TRIGGERED_MODE. A cadência de fotogramas cai para cerca de metade do modo livre porque a leitura deixa de paralelizar com a integração do fotograma seguinte:

cam.ioctl(csi.IOCTL_SET_TRIGGERED_MODE, True)

NPU¶

A NPU Neural‑ART a 1 GHz do N6 (600 GOPS INT8) é exposta através do módulo ml — Machine Learning. Os modelos armazenados no sistema de ficheiros só de leitura /rom carregam diretamente da flash sem cópia para RAM, pelo que mesmo detetores de grande dimensão cabem confortavelmente ao lado do buffer de fotograma em direto. Execute um detetor YOLOv8 em cada fotograma e desenhe as previsões sobre a imagem em direto:

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

Microfone¶

O microfone integrado é capturado através de audio — Módulo de Áudio. Cada buffer chega como um bytearray PCM com sinal de 16 bits, o que facilita a alimentação para ulab/numpy para DSP rápido. Um detetor de volume simples — imprimir sempre que o volume RMS cruza um limiar:

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¶

O acelerómetro + giroscópio integrado sob o módulo de câmara é exposto através de imu — sensor 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¶

O CYW43439 integrado é exposto via network — configuração de rede como interface de estação. Após a ligação, ipconfig("addr4") devolve o par (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¶

O mesmo CYW43439 também expõe Bluetooth 5.1. Use aioble — BLE Assíncrono para BLE compatível com asyncio — por exemplo, anuncie como um periférico e aguarde a ligação de um central:

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¶

Quando um RJ45 (com magnéticos) está ligado aos pads MDI, o PHY gigabit aparece como interface LAN. O DHCP é executado automaticamente assim que a ligação é estabelecida:

import network, time

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

Cartão microSD¶

Quando um cartão é inserido, é montado automaticamente em /sdcard e pode ser utilizado através do sistema de ficheiros normal:

import os

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

Referência de barramento¶

GPIO¶

Use machine.Pin para ler ou controlar qualquer um dos pinos serigrafados. As saídas são CMOS de 3,3 V e podem drenar/fornecer até 20 mA por pino.

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

Qualquer pino de entrada também pode disparar uma interrupção em transições de aresta:

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

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

UART¶

Barramento	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¶

Barramento	SCL	SDA
I2C2	P4	P5

from machine import I2C

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

O mesmo hardware também pode ser usado em modo alvo (escravo) através de machine.I2CTarget para expor uma região de memória a outro controlador I²C:

from machine import I2CTarget

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

SPI¶

Barramento	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¶

Barramento	TX	RX
CAN1	P2	P3

Nota

CAN ainda não é suportado nesta placa no 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¶

Ambos os canais ADC passam por um divisor de tensão com buffer de amplificador operacional antes de atingir o MCU, pelo que read_u16() é mapeado para uma tensão de plena escala de entrada diferente em cada pino.

Pino	Plena escala	Notas
P6_ADC	~3,3 V	pad de uso geral, ligado internamente a P6
BAT_ADC	~5,0 V	canal interno para a 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¶

Pino	Temporizador / canal
P4	TIM2 CH3
P5	TIM2 CH4
P6	TIM12 CH1
P7	TIM4 CH1
P8	TIM4 CH2
P9	TIM17 CH1
P10	TIM15 CH2

Controle qualquer um deles via machine.PWM

from machine import Pin, PWM

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

Barramentos bit‑banged por software¶

machine.SoftI2C e machine.SoftSPI funcionam em qualquer GPIO se precisar de um barramento extra.

Sensor térmico (externo)¶

O firmware inclui o driver fir — driver de sensor térmico (fir == infravermelho longínquo) para imagiadores térmicos ligados externamente:

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

Ligue o módulo ao barramento I²C da placa e leia fotogramas com 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())

O driver fir apenas comunica com o sensor através de I²C 2 — ligue o módulo a P4 (SCL) e P5 (SDA).

Temporização¶

time¶

O módulo time abrange atrasos bloqueantes, ticks monotónicos e medição de tempo decorrido:

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)

Temporizadores virtuais¶

machine.Timer agenda callbacks periódicos ou de disparo único sem consumir um slot de temporizador por hardware. Passe -1 como id para usar um temporizador virtual (por 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"))

Os valores de período estão em milissegundos. Chame deinit() para parar e libertar o slot.

Relógio em tempo real¶

machine.RTC mantém a hora do relógio de parede entre reinicializações e (com a bateria de reserva opcional de 3,3 V ligada aos pads traseiros, veja Pinos de alimentação) após perda total de energia:

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

O RTC também funciona durante o sono profundo, pelo que pode ser usado como fonte de ativação para machine.deepsleep().

Watchdog¶

machine.WDT reinicia a placa se a aplicação ficar bloqueada. Uma vez iniciado, não pode ser parado nem reconfigurado — alimente-o periodicamente no ciclo principal:

from machine import WDT

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

Informações de arranque e execução¶

Janela do bootloader USB¶

Em cada arranque, a câmara executa um bootloader curto (alguns segundos) que permite ao OpenMV IDE atualizar o firmware sem que o utilizador precise de entrar em modo DFU. Após o fim da janela, o bootloader cede o controlo a boot.py e depois a main.py.

Um script em execução pode reentrar no bootloader a pedido chamando machine.bootloader()

import machine

machine.bootloader()

Sistema de ficheiros e ordem de arranque¶

O firmware do N6 monta até três sistemas de ficheiros no arranque:

Flash interna — sempre montada em /flash. Contém main.py e README.txt por predefinição; criada no primeiro arranque.
Cartão microSD — se um cartão estiver inserido, é montado em /sdcard.
ROMFS — sistema de ficheiros só de leitura com mapeamento de memória em /rom, usado para fornecer grandes recursos de dados (por exemplo, modelos de IA) que beneficiam de acesso sem cópia. Montado automaticamente pelo MicroPython no arranque, antes de qualquer código Python do utilizador ser executado.

Após a montagem, o diretório de trabalho é definido como /sdcard quando o cartão está presente, caso contrário /flash. O interpretador executa então os scripts a partir desse diretório:

boot.py é executado em cada reinicialização por software (arranque a frio, Ctrl‑D no REPL, ou sempre que o script em execução termina).
main.py é executado apenas no arranque a frio, imediatamente após boot.py. Reinicializações por software subsequentes reexecutam boot.py mas vão diretamente para o REPL — para reexecutar main.py é necessário reinicializar completamente a placa.

Colocar um boot.py ou main.py no cartão SD substitui a cópia na flash sem a alterar — ambos os ficheiros são procurados no diretório de arranque (/sdcard quando o cartão está montado, caso contrário /flash).

O main.py predefinido fornecido numa placa recém-flasheada faz simplesmente piscar o canal azul do LED RGB de utilizador como batimento cardíaco (dois pulsos curtos, pausa curta), para que possa confirmar que o firmware arrancou corretamente sem qualquer host ligado.

sys.path é estendido para incluir os três sistemas de ficheiros e os seus subdiretórios lib/, pelo que os módulos importáveis podem estar em /flash/lib, /sdcard/lib ou /rom/lib.

Para forçar o sistema a ignorar um cartão SD inserido (por exemplo, para executar o main.py da flash mesmo com um cartão presente), crie um ficheiro vazio chamado SKIPSD na raiz de /flash.

Quando ligado por USB, o sistema de ficheiros de arranque (/sdcard se um cartão estiver presente, caso contrário /flash) também é enumerado como unidade de armazenamento de massa USB no host, permitindo editar boot.py, main.py e quaisquer outros ficheiros diretamente. Ejete a unidade antes de reinicializar a câmara para que o host esvazie as suas escritas em cache.

Nota

Como o sistema operativo trata a unidade como um dispositivo de blocos passivo, os ficheiros criados ou modificados por código a correr na OpenMV Cam não aparecerão até o host remontar a unidade. Se tanto o sistema operativo como a OpenMV Cam escreverem no mesmo sistema de ficheiros em simultâneo, o sistema operativo prevalecerá e substituirá as alterações feitas pela câmara. Use o cartão SD para quaisquer dados que o script escreva de volta, e remonte antes de ler esses ficheiros do host.

Nota

O canal vermelho do LED RGB de utilizador pode acender brevemente enquanto o host está a ler ou escrever na unidade de armazenamento de massa USB — este é um indicador de atividade controlado pelo firmware, não uma falha.

Tamanhos de armazenamento¶

O N6 é fornecido com:

/flash — sistema de ficheiros FAT de 4 MB, leitura/escrita.
/rom — ROMFS de 24 MB só de leitura com mapeamento de memória, usado para fornecer scripts e modelos ML que beneficiam de acesso mmap sem cópia.
/sdcard — tamanho total do cartão microSD inserido (quando presente), leitura/escrita.

Indicador de falha grave¶

Se o LED RGB de utilizador estiver a ciclar rapidamente por todas as cores — rápido o suficiente para parecer um LED branco a piscar em vez de tons distintos — o firmware sofreu uma falha grave irrecuperável. Reflasheie o firmware para recuperar; se o reflasheamento não ajudar, a placa pode estar fisicamente danificada.

Bibliotecas de software¶

Consulte o índice de bibliotecas para a lista completa de módulos — incluindo quais são exclusivos da versão N6.