OpenMV N6¶

A OpenMV N6 é construída em torno do STMicroelectronics STM32N657 (Cortex‑M55 @ 800 MHz) com uma NPU on‑chip de 1 GHz avaliada em 600 GOPS INT8. A placa combina a NPU com o sensor de global shutter PAG7936 de 1 MP em um carrier removível, Ethernet gigabit, USB‑C high‑speed, Wi‑Fi e Bluetooth 5.1, e executa inferência YOLOv8/YOLOv11 a 30 FPS junto com streaming de vídeo ao vivo.

Para a folha de dados 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 — 6,4 gigaops de throughput vetorial.
NPU de 1 GHz, 600 GOPS INT8 — executa detecção YOLOv8/YOLOv11 a 30 FPS.
ISP para RAW Bayer de até 5 MP, GPU 2D para escalonamento e rotação 3D, codificação H.264 até 1080p e codec JPEG em hardware.
64 MB de SDRAM externa (16 bits @ 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 global shutter colorido PAG7936 de 1 MP.
IMU integrada (acelerômetro + giroscópio) e microfone para fusão de áudio + movimento.
USB‑C high‑speed (480 Mb/s, limite de corrente de 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).
Soquete microSD — SD até 2 GB, SDHC até 32 GB, SDXC até 2 TB.
Carregador LiPo (carga rápida de 500 mA), ADC de tensão da bateria, RTC com 8 KB de RAM de backup e um pino dedicado de bateria de backup.
18 pinos de I/O, todos com saída 3,3 V / tolerantes a 3,3 V, 20 mA por pino, com suporte a interrupção.
LED RGB de usuário, botão de usuário e um LED de status separado para carga / USB / alimentação VIN.

Aviso

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

Pinagem¶

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 — veja `P6_ADC`)
P6_ADC	entrada de ADC dedicada de 12 bits (ligada internamente a P6)
P7	TIM4 CH1
P8	TIM4 CH2
P9	TIM17 CH1
P10	TIM15 CH2 / I/O de frame sync
P11	wakeup (ativo em nível baixo, WKUP3)
P12	RESET — puxe para GND para resetar 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 usuário (ativo em nível baixo)
ONOFF (SW2)	botão de wakeup de deep‑sleep (ativo em nível baixo, WKUP2)
ST	baixo na alimentação VIN, alto na alimentação USB
CHG	ativo em nível baixo; baixo enquanto uma bateria LiPo conectada está carregando
PG	ativo em nível baixo; baixo quando há alimentação VIN ou USB presente
BAT_ADC	canal de ADC interno que mede a tensão da bateria LiPo conectada
LED_RED	canal vermelho do LED RGB (ativo em nível baixo)
LED_GREEN	canal verde do LED RGB (ativo em nível baixo)
LED_BLUE	canal azul do LED RGB (ativo em nível baixo)

Nota

A linha de frame‑sync P10 é um barramento compartilhado. Ela está ligada ao MCU, ao pino de trigger / exposição do sensor da câmera e ao header de usuário, tudo ao mesmo tempo. A direção é definida pela aplicação — o MCU, o sensor ou um sinal externo podem acioná‑la, dependendo de como o sensor está configurado (alguns sensores podem usar o mesmo pino como entrada de trigger ou como saída de exposição). Certifique‑se de que apenas um driver esteja ativo por vez.

Nota

ONOFF e P11 são referenciados ao rail RAW sempre ativo (não ao rail comutado de 3,3 V), portanto permanecem funcionais enquanto o restante da placa está em modo de deep sleep / baixo consumo. Ambas as entradas são ativas em nível baixo.

Esses pinos passam por level shifters para poderem operar no rail RAW. Se você realmente precisar de comportamento de GPIO direto em 3,3 V em ONOFF ou P11 (por exemplo, para acioná‑los a partir de um MCU de 3,3 V sem passar pelo shifter), a placa expõe pads de jumper com pull‑up e de 0 ohm que permitem contornar o shifter. Esta é uma modificação de hardware avançada — a maioria dos usuários deve deixá‑los como estão.

Nota

P15–P18 são compartilhados com o PHY de Ethernet Gigabit, que está cabeado e ativo por padrão. Para usar esses pinos como I/O de usuário, você precisa fazer reflow do resistor de 0 ohm na parte de trás da placa para a posição GPIO. Isso desabilita apenas a Ethernet gigabit — a Ethernet de 10/100 Mb/s continua funcionando em seus pinos dedicados.

Pinos de alimentação¶

3.3V — rail regulado de 3,3 V. Apenas saída na N6 — não alimente potência externa neste pino. Até 1 A disponível 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). Conduz qualquer fonte que estiver ativa (VIN, USB ou bateria conectada) e também pode ser usado como entrada. Você precisa acionar RAW através de um diodo em série ao fornecer potência por ele — caso contrário, a corrente fluirá de volta para VIN/USB e danificará a alimentação ou a proteção integrada.
GND — terra comum.

Nota

O chip de gerenciamento de energia integrado escolhe automaticamente qual entre USB ou VIN tem a tensão mais alta para alimentar a placa e o carregador da bateria. Se uma LiPo estiver conectada, ela carrega com a folga restante, e o controlador recorre à bateria para manter a placa funcionando caso VIN/USB caiam ou sejam desconectados.

Nota

A parte de trás da placa tem pads de solda para uma bateria de backup de 3,3 V para o RTC externa. Soldar uma bateria de moeda nesses pads mantém o RTC e os 8 KB de RAM de backup funcionando enquanto o restante da placa está sem alimentação.

Dica

Use o estimador de vida útil da bateria para modelar por quanto tempo a N6 funcionará com uma bateria para um determinado ciclo de trabalho ativo / deep‑sleep.

Pinos de Ethernet¶

A N6 expõe os pares MDI do PHY de Ethernet em pads dedicados ao lado do header de GPIO. Os pinos MDI não são seguros para ligar diretamente a um RJ45 — magnéticos de Ethernet (um transformador de isolamento, seja integrado a um magjack ou no shield) são obrigatórios entre o PHY e o cabo. O PoE shield da OpenMV os inclui; se você estiver montando seu próprio conector, use um RJ45 com magnéticos integrados ou um transformador externo.

ETH_LED — LED de link/atividade. Ativo em nível baixo quando há link estabelecido; pisca durante o tráfego.
DA P / DA N — par A (TX em 10/100, usado por todas as velocidades).
DB P / DB N — par B (RX em 10/100, usado por todas as velocidades).
DC P / DC N — par C, usado apenas em gigabit.
DD P / DD N — par D, usado apenas em gigabit.

10/100 Mb/s só precisa dos pares A e B. Gigabit precisa dos quatro pares A–D.

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

RESET — puxe para GND para resetar a placa. Soltá‑lo permite que o MCU inicialize normalmente.
BOOT0 — puxe para 3,3 V ao alimentar a placa para entrar no modo bootloader da ROM. A OpenMV IDE usa esse modo para reprogramar o bootloader integrado.
BOOT1 — chave que coloca a placa em modo de desenvolvedor para uso com as ferramentas da ST (um ST‑LINK conectado ao header SWD/JTAG ARM de 10 pinos). Deixe isso desabilitado para operação normal com o firmware e as ferramentas da OpenMV.

Um header SWD/JTAG ARM de 10 pinos dedicado está montado, compatível com adaptadores ST‑LINK e SEGGER J‑Link.

Periféricos integrados¶

LEDs¶

A N6 tem dois LEDs RGB:

LED RGB de usuário — 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 — acionado diretamente pelo hardware de gerenciamento de energia integrado, sem controle por software. Use‑o para ler rapidamente o que a alimentação está fazendo.

Durante a execução:

Canal

Significado

Azul

VIN está alimentando a placa (apagado no USB)

Verde

alimentação USB ou VIN presente

Vermelho

carregando uma bateria LiPo conectada

Em deep sleep, todos os canais ficam apagados exceto o Vermelho, que ainda acende enquanto uma LiPo está carregando.

Canal	Significado
Azul	VIN está alimentando a placa (apagado no USB)
Verde	alimentação USB ou VIN presente
Vermelho	carregando uma bateria LiPo conectada

Botões de usuário¶

A N6 tem dois botões:

SW — botão de usuário de propósito geral. Ativo quando puxado para nível baixo.
ONOFF (SW2) — botão de wakeup. O único botão que pode tirar a placa do deep sleep.

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 deep sleep e fazer com que o ONOFF (SW2) a desperte, basta chamar machine.deepsleep() — nenhuma configuração de wakeup é necessária, o botão está ligado diretamente à entrada WKUP2:

import machine

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

Você também pode ligar o ONOFF como uma chave de alimentação por software. Dispare na borda de subida — a linha estabiliza em nível alto depois que o usuário solta o botão, de modo que o próximo pressionamento é, sem ambiguidade, um evento de wake:

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 status de alimentação¶

Três entradas de status ativas em nível baixo permitem que o firmware veja o que o chip de gerenciamento de energia integrado está fazendo:

ST — baixo quando a placa está funcionando com VIN, alto quando funcionando com alimentação USB.
CHG — baixo enquanto uma bateria LiPo conectada está carregando.
PG — baixo quando há alimentação VIN ou USB 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 da câmera¶

O PAG7936 é acionado através do módulo csi — sensores de câmera

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 fica em um módulo removível — troque‑o por qualquer um dos outros módulos de câmera da OpenMV (global shutter, térmico, resolução mais alta, etc.) sem alterar o restante da placa.

O PAG7936 suporta modo triggered — a integração de pixels se alinha exatamente com cada chamada csi.CSI.snapshot em vez do clock de quadro de execução livre, útil para sincronizar a captura com um evento externo ou outro sensor. Habilite‑o através de csi.CSI.ioctl com csi.IOCTL_SET_TRIGGERED_MODE. A taxa de quadros cai para cerca de metade do modo de execução livre porque a leitura não faz mais pipeline com a integração do próximo quadro:

cam.ioctl(csi.IOCTL_SET_TRIGGERED_MODE, True)

NPU¶

A NPU Neural‑ART de 1 GHz da N6 (600 GOPS INT8) é exposta através do módulo ml — Aprendizado de Máquina. Modelos armazenados no sistema de arquivos somente leitura /rom carregam diretamente da flash sem copiar para a RAM, de modo que mesmo detectores grandes cabem confortavelmente ao lado do framebuffer ao vivo. Execute um detector YOLOv8 em cada quadro e desenhe as previsões sobre a imagem ao vivo:

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 de 16 bits com sinal, o que torna trivial alimentá‑lo no ulab/numpy para DSP rápido. Um detector de volume simples — imprime sempre que o volume RMS ultrapassa 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 da câmera é 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 uma interface de estação. Após a conexão, ipconfig("addr4") retorna 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 amigável a asyncio — por exemplo, anuncie‑se como periférico e aguarde um central se conectar:

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) é conectado aos pads MDI, o PHY gigabit aparece como uma interface LAN. O DHCP é executado automaticamente assim que o link sobe:

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, ele é montado automaticamente em /sdcard e fica utilizável através do sistema de arquivos normal:

import os

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

Referência de barramentos¶

GPIO¶

Use machine.Pin para ler ou acionar qualquer um dos pinos serigrafados. As saídas são 3,3 V CMOS 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 borda:

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 target (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 de ADC passam por um divisor de tensão com buffer de amp‑op antes de chegar ao MCU, de modo que read_u16() é mapeado para uma tensão de entrada de fundo de escala diferente em cada pino.

Pino	Fundo de escala	Notas
P6_ADC	~3,3 V	pad de propósito 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	Timer / canal
P4	TIM2 CH3
P5	TIM2 CH4
P6	TIM12 CH1
P7	TIM4 CH1
P8	TIM4 CH2
P9	TIM17 CH1
P10	TIM15 CH2

Acione qualquer um deles via machine.PWM

from machine import Pin, PWM

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

Barramentos por bit‑banging em software¶

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

Sensor térmico (externo)¶

O firmware inclui o driver fir — driver de sensor térmico (fir == far infrared) para imageadores térmicos cabeados externamente:

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

Conecte o módulo ao barramento I²C da placa e leia quadros 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 só se comunica com o sensor através do I²C 2 — conecte o módulo a P4 (SCL) e P5 (SDA).

Temporização¶

time¶

O módulo time cobre 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)

Timers virtuais¶

machine.Timer agenda callbacks periódicos ou únicos sem consumir um slot de timer de hardware. Passe -1 como id para usar um timer virtual (de 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 são em milissegundos. Chame deinit() para parar e liberar o slot.

Relógio de tempo real¶

machine.RTC mantém a hora do relógio através de resets e (com a bateria de backup opcional de 3,3 V cabeada aos pads traseiros, veja Pinos de alimentação) através de 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 deep sleep, então você pode usá‑lo como fonte de wakeup para machine.deepsleep().

Watchdog¶

machine.WDT reseta a placa se a aplicação travar. Uma vez iniciado, ele não pode ser parado ou reconfigurado — alimente‑o periodicamente dentro do seu loop principal:

from machine import WDT

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

Informações de boot e tempo de execução¶

Janela do bootloader USB¶

A cada inicialização, a câmera executa um bootloader curto (alguns segundos) que permite à OpenMV IDE atualizar o firmware sem que o usuário tenha que entrar no modo DFU. Após o término da janela, o bootloader passa o controle para o boot.py e depois o main.py.

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

import machine

machine.bootloader()

Sistema de arquivos e ordem de boot¶

O firmware da N6 monta até três sistemas de arquivos no boot:

Flash interna — sempre montada em /flash. Contém main.py e README.txt por padrão; criada na primeira inicialização.
Cartão microSD — se um cartão for inserido, ele é montado em /sdcard.
ROMFS — sistema de arquivos somente leitura, mapeado em memória, em /rom, usado para distribuir grandes ativos de dados (por exemplo, modelos de IA) que se beneficiam de acesso zero‑copy. Montado automaticamente pelo MicroPython na inicialização, antes de qualquer código Python do usuário 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 então executa scripts a partir desse diretório:

boot.py é executado em todo soft reset (boot a frio, Ctrl‑D do REPL ou sempre que o script em execução retorna).
main.py é executado apenas no boot a frio, imediatamente após o boot.py. Soft resets subsequentes reexecutam o boot.py mas vão direto para o REPL — para reexecutar o main.py você precisa resetar totalmente a placa.

Colocar um boot.py ou main.py no cartão SD sobrepõe a cópia na flash sem tocá‑la — ambos os arquivos são procurados no diretório de boot (/sdcard quando o cartão está montado, caso contrário /flash).

O main.py padrão fornecido em uma placa recém‑programada apenas pisca o canal azul do LED RGB de usuário como um heartbeat (dois pulsos curtos, intervalo curto), de modo que você pode saber que o firmware inicializou corretamente sem nenhum host conectado.

O sys.path é estendido para incluir os três sistemas de arquivos e seus subdiretórios lib/, de modo que módulos importáveis podem ficar 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 arquivo vazio chamado SKIPSD na raiz de /flash.

Quando conectada via USB, o sistema de arquivos de boot (/sdcard se um cartão estiver presente, caso contrário /flash) também é enumerado como um drive de armazenamento em massa USB no host, permitindo que você edite boot.py, main.py e quaisquer outros arquivos diretamente. Ejete o drive antes de resetar a câmera para que o host descarregue suas gravações em cache.

Nota

Como o SO trata o drive como um dispositivo de bloco passivo, arquivos criados ou modificados por código em execução na OpenMV Cam não aparecerão até que o host remonte o drive. Se tanto o SO quanto a OpenMV Cam escreverem no mesmo sistema de arquivos ao mesmo tempo, o SO vencerá e sobrescreverá as alterações feitas pela câmera. Use o cartão SD para quaisquer dados que o script grave de volta e remonte antes de ler esses arquivos a partir do host.

Nota

O canal vermelho do LED RGB de usuário pode acender brevemente enquanto o host está lendo ou gravando no drive de armazenamento em massa USB — este é um indicador de atividade acionado pelo firmware, não uma falha.

Tamanhos de armazenamento¶

A N6 vem com:

/flash — sistema de arquivos FAT de 4 MB, leitura/gravação.
/rom — ROMFS somente leitura mapeado em memória de 24 MB, usado para distribuir scripts e modelos de ML que se beneficiam de acesso por mmap zero‑copy.
/sdcard — tamanho total do cartão microSD inserido (quando presente), leitura/gravação.

Indicador de hard fault¶

Se o LED RGB de usuário estiver alternando rapidamente entre todas as cores — rápido o suficiente para parecer um LED branco cintilante em vez de tons distintos — o firmware atingiu um hard fault irrecuperável. Reprograme o firmware para recuperar; se reprogramar não ajudar, a placa pode estar fisicamente danificada.

Bibliotecas de software¶

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