OpenMV Cam RT1062

A OpenMV Cam RT1062 é uma placa de visão de máquina de baixo consumo construída em torno do NXP i.MX RT1062 (Cortex‑M7 @ 600 MHz). A placa combina rede USB‑C de alta velocidade, Wi‑Fi/Bluetooth e Ethernet 10/100 com um sensor OV5640 de 5MP em um suporte removível. A câmera consome apenas ~30 µA de uma bateria LiPo em sono profundo, o que a torna bem adequada a projetos alimentados por bateria.

OpenMV Cam RT1062

Para o datasheet completo, fotos e dimensões, consulte a página do produto OpenMV Cam RT1062.

Destaques

  • NXP i.MX RT1062 Cortex‑M7 a 600 MHz.

  • 32 MB de SDRAM externa (16‑bit @ 160 MHz, 320 MB/s) mais 1 MB de SRAM interna e 16 MB de flash QSPI (133 MHz SDR de 4‑bit, leitura de 66 MB/s); 4 KB de EEPROM em R6+.

  • Sensor OV5640 de 5MP com rolling‑shutter.

  • IMU integrada (acelerômetro de 3 eixos de 12‑bit, ±2/4/8 g).

  • USB‑C de alta velocidade (480 Mb/s, limite de corrente de 1,5 A), Ethernet 10/100 Mb/s (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 (500 mA em R6+, 100 mA em R4/R5), RTC com pads para bateria de backup. O sono profundo consome ~30 µA na bateria.

  • 14 pinos de I/O, todos com saída de 3,3 V / tolerantes a 3,3 V, 4 mA por pino, com suporte a interrupção.

  • LED RGB de usuário, botão SW de usuário, botão de energia em hardware (máquina de estados de sono profundo / despertar) e um LED de status separado para carga / USB / alimentação VIN.

Aviso

Os pinos de I/O da RT1062 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 placa somente através de VIN.

Pinagem

Pinagem da OpenMV Cam RT1062 OV5640

Referência de pinos

Nome do pino

Função

P0

SPI1 MOSI / PWM2 B3

P1

SPI1 MISO / CAN0 TX

P2

SPI1 SCLK / PWM2 B3

P3

SPI1 SS / CAN0 RX

P4

I2C1 SCL / UART1 TX / PWM1 X2

P5

I2C1 SDA / UART1 RX / PWM1 X3

P6

ADC

P7

PWM2 A0

P8

PWM2 B0

P9

PWM1 A3

P10

PWM1 B3 / I/O de frame sync

P11

despertar (ativo em nível baixo, conecte ao GND para despertar)

P12

RESET — puxe para GND para resetar a placa (não é um GPIO)

P13

I/O digital

P14

I/O digital

ON/OFF

pad de header que replica o botão de energia em hardware (ativo em nível baixo)

SW

botão de usuário (ativo em nível baixo)

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

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á conectada 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. Certifique‑se de que apenas um driver esteja ativo por vez.

Nota

ON/OFF e P11 são referenciados ao trilho RAW sempre ligado (e não ao trilho de 3,3 V comutado), de modo que permanecem funcionais enquanto o restante da placa está em modo de sono profundo / baixo consumo. Ambas as entradas são ativas em nível baixo.

Esses pinos passam por level shifters para que possam operar no trilho RAW. Se você realmente precisar de comportamento de GPIO direto em 3,3 V em ON/OFF 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 de pull‑up e de 0 ohm que permitem contornar o shifter. Esta é uma modificação avançada de hardware — a maioria dos usuários deve deixá‑la em paz.

Nota

P13 e P14 são GPIO comuns por padrão, sem função especial. Os pads podem opcionalmente ser redirecionados para outros sinais refazendo a solda das pontes de resistor de 0 ohm na parte de trás da placa:

  • P13 ↔ status CHG / JTAG TRSTB

  • P14 ↔ status ST / JTAG TDI

A maioria dos usuários não vai mexer nesses jumpers — deixe‑os no padrão de GPIO, a menos que você precise especificamente de leitura do gerenciamento de energia ou de JTAG.

Pinos de alimentação

  • 3.3V — trilho regulado de 3,3 V. Somente saída na RT1062 — não injete alimentação 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 ligado (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ê deve acionar o RAW através de um diodo em série ao fornecer energia para ele — 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 gerenciamento de energia integrado escolhe automaticamente entre USB ou VIN, aquele que tiver a tensão mais alta para alimentar a placa e o carregador da bateria. Se uma LiPo estiver conectada, ela carrega com a margem 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 RTC externa de 3,3 V. Conectar uma célula tipo moeda a esses pads mantém o RTC 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 RT1062 funcionará com uma bateria para um determinado ciclo de trabalho ativo / sono profundo.

Pinos de Ethernet

A RT1062 expõe os pares MDI do PHY Ethernet 10/100 Mb/s em pads dedicados ao lado do header de GPIO. Os pinos MDI não são seguros para serem conectados diretamente a um RJ45 — magnéticos Ethernet (um transformador de isolamento, integrado a um magjack ou no shield) são obrigatórios entre o PHY e o cabo. O shield PoE da OpenMV os inclui; se você estiver fazendo 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á um link ativo; pisca durante o tráfego.

  • ETH_TXP / ETH_TXN — par de transmissão.

  • ETH_RXP / ETH_RXN — par de recepção.

Nota

O header também expõe quatro pads serigrafados como Reserved. Eles são compatíveis em footprint com os pares de Ethernet gigabit da OpenMV N6 (DC P/N e DD P/N), de modo que o mesmo shield de Ethernet / PoE pode ser conectado a qualquer uma das placas. O PHY da RT1062 só funciona em 10/100 Mb/s, portanto esses quatro pads não têm conectividade elétrica — deixe‑os desconectados.

Pinos de recuperação e depuração

  • RESET — puxe para GND para resetar a placa. Soltá‑lo permite que o MCU inicialize normalmente.

  • SBL — puxe para 3,3 V enquanto alimenta a placa para entrar no modo ROM bootloader (Serial Boot Loader). O OpenMV IDE usa esse modo para regravar o bootloader integrado.

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

Nota

A RT1062 expõe somente depuração SWD através deste conector por padrão. O JTAG completo não está disponível de fábrica.

Periféricos integrados

LEDs

A RT1062 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 energia — acionado diretamente pelo hardware de gerenciamento de energia integrado, sem controle por software. Use‑o para ver de relance o que a fonte de alimentação está fazendo.

    Em funcionamento:

    Canal

    Significado

    Azul

    VIN está alimentando a placa (apagado em USB)

    Verde

    alimentação USB ou VIN presente

    Vermelho

    carregando uma bateria LiPo conectada

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

Botões

A RT1062 tem dois botões:

  • SW — botão de usuário de propósito geral. Legível a partir do código como uma entrada GPIO ativa em nível baixo normal:

    from machine import Pin

sw = Pin("SW", Pin.IN)
print(sw.value())

  • Botão de energia — acionado por uma máquina de estados dedicada do controlador de energia na placa RT1062, inteiramente em hardware. Ele não é exposto ao código do usuário; o controlador decide o que fazer com base em quanto tempo ele é mantido pressionado:

    • Mantenha pressionado por ~5 s enquanto a placa está em funcionamento → a máquina de estados transita para o sono profundo.

    • Mantenha pressionado por ~1 s enquanto a placa está em sono profundo → a máquina de estados liga o sistema novamente.

    Puxar o pad de header ON/OFF para nível baixo tem o mesmo efeito que pressionar o botão de energia integrado — útil para conectar um interruptor externo ou acionar a linha a partir de outro microcontrolador.

Pinos de status de energia

Três entradas de status ativas em nível baixo do chip de gerenciamento de energia integrado:

  • PG — baixo quando há alimentação VIN ou USB presente. Sempre conectado.

  • ST — baixo quando a placa está funcionando com VIN, alto quando funcionando com alimentação USB. Não conectado por padrão.

  • CHG — baixo enquanto uma bateria LiPo conectada está carregando. Não conectado por padrão.

from machine import Pin

power_ok = not Pin("PG", Pin.IN).value()

Sensor da câmera

O OV5640 é controlado através do módulo csi — sensores de câmera

import csi

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

while True:
    img = cam.snapshot()

O OV5640 tem um compressor JPEG integrado. Defina csi.CSI.pixformat como csi.JPEG e o sensor entrega quadros comprimidos diretamente à câmera pelo barramento da câmera, o que torna práticas as capturas de alta resolução: csi.HD (1280×720), csi.FHD (1920×1080) e o 5MP completo csi.WQXGA2 (2592×1944) são todos transmitidos como JPEG. Ajuste a compressão com csi.CSI.quality (0-100, maior = quadros maiores, mais detalhes):

cam.pixformat(csi.JPEG)
cam.framesize(csi.WQXGA2)
cam.quality(90)

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.

Aprendizado de máquina

ml — Aprendizado de Máquina executa modelos TFLite quantizados no Cortex‑M7 com kernels CMSIS‑NN — rápido o suficiente para detectores compactos a alguns quadros por segundo. Modelos no sistema de arquivos somente leitura /rom carregam diretamente da flash sem copiar para a RAM. Aqui está um detector BlazeFace de 128×128 sobrepondo o rosto detectado e seus seis pontos de referência em cada quadro:

import csi
import time
import ml
from ml.postprocessing.mediapipe import BlazeFace

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

# Load built-in face detection model
model = ml.Model("/rom/blazeface_front_128.tflite", postprocess=BlazeFace(threshold=0.4))
print(model)

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

    # faces is a list of ((x, y, w, h), score, keypoints) tuples
    for r, score, keypoints in model.predict([img]):
        ml.utils.draw_predictions(img, [r], ("face",), ((0, 0, 255),), format=None)

        # keypoints is a ndarray of shape (6, 2)
        # 0 - right eye (x, y)
        # 1 - left eye (x, y)
        # 2 - nose (x, y)
        # 3 - mouth (x, y)
        # 4 - right ear (x, y)
        # 5 - left ear (x, y)
        ml.utils.draw_keypoints(img, keypoints, color=(255, 0, 0))

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

IMU

O firmware da RT1062 não conecta o acelerômetro integrado ao módulo imu — sensor imu. Em vez disso, fale com ele diretamente pelo barramento I²C interno — o chip reside no endereço 0x15 e empacota três canais de aceleração de 12‑bit com sinal mais um byte de temperatura de 8‑bit a partir do registrador 0x03

import machine
import time

ADDR     = 0x15
DATA_REG = 0x03
LSB_PER_G = 1024.0    # ±2 g range

def s12(hi, lo):
    v = ((hi << 8) | lo) >> 4
    return v - 0x1000 if v & 0x800 else v

bus = machine.I2C(2)
print("Devices on I²C2:", bus.scan())

while True:
    d = bus.readfrom_mem(ADDR, DATA_REG, 7)
    x = s12(d[0], d[1]) / LSB_PER_G
    y = s12(d[2], d[3]) / LSB_PER_G
    z = s12(d[4], d[5]) / LSB_PER_G
    temp_c = d[6] * 0.586 + 25.0
    print("x=%+.2fg  y=%+.2fg  z=%+.2fg  T=%.1f°C" % (x, y, z, temp_c))
    time.sleep_ms(100)

EEPROM

As placas R6 e posteriores incluem uma EEPROM I²C genérica de 4 KB no mesmo barramento interno do acelerômetro. (Revisões anteriores não a possuem — chamar estes trechos em R4/R5 resultará em timeout por falta de ack do I²C.) Use a API padrão machine.I2C readfrom_mem / writeto_mem com um endereço de memória de 16‑bit:

import machine
import time

EEPROM_ADDR = 0x50            # default address
PAGE_SIZE   = 32              # bytes per page (both read and write)
EEPROM_SIZE = 4096

bus = machine.I2C(2)

# Dump the entire 4 KB one page at a time
data = bytearray()
for offset in range(0, EEPROM_SIZE, PAGE_SIZE):
    data += bus.readfrom_mem(EEPROM_ADDR, offset, PAGE_SIZE, addrsize=16)
print(len(data), "bytes")

# Write a small payload back at offset 0 (fits in one page)
bus.writeto_mem(EEPROM_ADDR, 0, b"hello, world", addrsize=16)
time.sleep_ms(10)             # ~5 ms write cycle after each page

# Read it back
print(bus.readfrom_mem(EEPROM_ADDR, 0, 12, addrsize=16))

Tanto as leituras quanto as escritas devem permanecer dentro de uma página de 32 bytes. Divida qualquer transferência maior em uma chamada por página e adicione o atraso de ciclo de escrita de ~5 ms entre escritas consecutivas.

Wi‑Fi

O módulo integrado da família CYW43 é exposto via network — configuração de rede como uma interface de estação. Após conectar, 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 módulo sem fio também expõe o Bluetooth 5.1. Use aioble — BLE Assíncrono para BLE compatível com asyncio — por exemplo, anuncie como periférico e aguarde a conexão de um central:

import asyncio
import aioble

async def run():
    while True:
        conn = await aioble.advertise(250_000, name="OpenMV-RT1062")
        print("Connected:", conn.device)
        await conn.disconnected()

asyncio.run(run())

Ethernet

Quando um RJ45 (com magnéticos) é conectado aos pads MDI, o PHY 10/100 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 CMOS de 3,3 V e podem absorver/fornecer até 4 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

UART1

P4

P5

 
from machine import UART

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

I²C

Barramento

SCL

SDA

I2C1

P4

P5

 
from machine import I2C

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

SPI

Barramento

MOSI

MISO

SCK

CS

SPI1

P0

P1

P2

P3

 
from machine import SPI
from machine import Pin

spi = SPI(1, 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

P1

P3

Nota

O 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

O único pino de ADC de usuário é o P6, que tem fundo de escala em ~3,3 V:

from machine import ADC
import time

adc = ADC("P6")
while True:
    voltage = adc.read_u16() * 3.3 / 65535
    print(voltage)
    time.sleep_ms(100)

PWM

Pino

Canal FlexPWM

P0

PWM2 B3

P2

PWM2 B3

P4

PWM1 X2

P5

PWM1 X3

P7

PWM2 A0

P8

PWM2 B0

P9

PWM1 A3

P10

PWM1 B3

Acione qualquer um deles via machine.PWM

from machine import Pin, PWM

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

Barramentos bit‑banged por software

machine.SoftI2C e machine.SoftSPI funcionam em qualquer GPIO caso você precise 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 conectados 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 pelo I²C 4 — 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 de disparo único sem consumir um slot de timer em hardware. Passe -1 como id para usar um timer virtual (em 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 conectada 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 continua funcionando durante o sono profundo, então você pode usá‑lo como fonte de despertar para machine.deepsleep().

Watchdog

machine.WDT reseta a placa se a aplicação travar. Uma vez iniciado, não pode ser parado nem reconfigurado — alimente‑o periodicamente dentro do seu laço 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 ligação, a câmera executa um bootloader curto (alguns segundos) que permite ao OpenMV IDE atualizar o firmware sem que o usuário precise 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 RT1062 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 no primeiro boot.

  • 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 recursos de dados (por exemplo, modelos de IA) que se beneficiam de acesso zero‑copy. Montado automaticamente pelo MicroPython na inicialização, antes que qualquer código Python do usuário seja 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 os scripts a partir desse diretório:

  • boot.py é executado em todo soft reset (cold boot, Ctrl‑D a partir do REPL ou sempre que o script em execução retorna).

  • main.py é executado somente no cold boot, 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 sobrescreve 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‑gravada apenas pisca o canal azul do LED RGB de usuário como um heartbeat (dois pulsos curtos, intervalo curto), de modo que você consegue saber que o firmware inicializou corretamente sem nenhum host conectado.

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

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

Nota

Como o SO trata a unidade como um dispositivo de bloco passivo, arquivos criados ou modificados por código executando na OpenMV Cam não aparecerão até que o host remonte a unidade. 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 na unidade de armazenamento em massa USB — isso é um indicador de atividade controlado pelo firmware, não uma falha.

Tamanhos de armazenamento

A RT1062 vem com:

  • /flash — sistema de arquivos FAT de 4 MB, leitura/escrita.

  • /rom — ROMFS somente leitura mapeado em memória de 8 MB, usado para distribuir scripts e modelos de ML que se beneficiam de acesso mmap zero‑copy.

  • /sdcard — tamanho total de qualquer cartão microSD inserido (quando presente), leitura/escrita.

Indicador de hard‑fault

Se o LED RGB de usuário estiver ciclando rapidamente por todas as cores — rápido o suficiente para tender a parecer um LED branco cintilante em vez de tons distintos — o firmware atingiu um hard fault irrecuperável. Regrave o firmware para recuperar; se a regravação 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 build da RT1062.