OpenMV Cam RT1062

A OpenMV Cam RT1062 é uma placa de visão por computador 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 5 MP num módulo amovível. A câmara consome apenas ~30 µA de uma bateria LiPo em modo de sono profundo, o que a torna muito adequada para projetos alimentados por bateria.

OpenMV Cam RT1062

Para o datasheet completo, fotografias 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 bits @ 160 MHz, 320 MB/s) mais 1 MB de SRAM interna e 16 MB de flash QSPI (133 MHz 4 bits SDR, 66 MB/s de leitura); 4 KB de EEPROM na R6+.

  • Sensor OV5640 de 5 MP com obturador rolante.

  • IMU integrado (acelerómetro de 3 eixos de 12 bits, ±2/4/8 g).

  • USB‑C de alta velocidade (480 Mb/s, limite de 1,5 A), Ethernet 10/100 Mb/s (com suporte a PoE via shield), Wi‑Fi a/b/g/n + Bluetooth 5.1 (antena integrada ou opção U.FL).

  • Conector microSD — SD até 2 GB, SDHC até 32 GB, SDXC até 2 TB.

  • Carregador LiPo (500 mA na R6+, 100 mA na R4/R5), RTC com pads de bateria de reserva. O sono profundo consome ~30 µA com 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 utilizador, botão SW de utilizador, botão de alimentação por hardware (máquina de estados de sono profundo / despertar) e um LED de estado separado para carregamento / USB / alimentação VIN.

Aviso

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

Pinout

OpenMV Cam RT1062 OV5640 Pinout

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 / sincronização de fotograma I/O

P11

despertar (ativo baixo, ligar ao GND para despertar)

P12

RESET — ligar ao GND para reiniciar a placa (não é um GPIO)

P13

I/O digital

P14

I/O digital

ON/OFF

pad de cabeçalho que replica o botão de alimentação por hardware (ativo baixo)

SW

botão de utilizador (ativo baixo)

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 há alimentação VIN ou USB

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 da câmara e ao cabeçalho de utilizador em simultâneo. A direção é definida pela aplicação — o MCU, o sensor ou um sinal externo pode controlá-la consoante a configuração do sensor. Certifique-se de que apenas um controlador está ativo de cada vez.

Nota

ON/OFF e P11 estã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 para poderem funcionar no rail RAW. Se precisar absolutamente de comportamento GPIO direto a 3,3 V em ON/OFF ou P11 (por exemplo, para os controlar a partir de um MCU a 3,3 V sem passar pelo conversor), a placa expõe pads de pull‑up e pontes de 0 ohm que permitem contornar o conversor. Trata-se de uma modificação de hardware avançada — a maioria dos utilizadores deve deixá-la como está.

Nota

P13 e P14 são GPIO simples por defeito sem função especial. Os pads podem, opcionalmente, ser redirecionados para outros sinais ao refundir as pontes de resistência de 0 ohm na parte traseira da placa:

  • P13 ↔ estado CHG / JTAG TRSTB

  • P14 ↔ estado ST / JTAG TDI

A maioria dos utilizadores não irá tocar nestas pontes — deixe-as no modo GPIO predefinido, a não ser que precise especificamente de leitura de estado de gestão de energia ou de JTAG.

Pinos de alimentação

  • 3.3V — rail regulado de 3,3 V. Apenas saída no RT1062 — não ligue alimentação 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 pode também ser usado como entrada. Deve colocar um díodo em série com RAW ao injetar alimentação — caso contrário, a corrente fluirá de volta para VIN/USB e poderá danificar a fonte ou a proteção integrada.

  • GND — terra comum.

Nota

O chip de gestão de energia integrado seleciona automaticamente USB ou VIN, consoante a tensão mais elevada, para alimentar a placa e o carregador de bateria. Se uma LiPo estiver ligada, carrega com a margem disponível, e o controlador recorre à bateria para manter a placa em funcionamento se VIN/USB baixar ou for desligado.

Nota

A parte traseira da placa tem pads de solda para uma bateria de reserva RTC de 3,3 V externa. Ligar uma pilha de botão a estes pads mantém o RTC em funcionamento enquanto o resto da placa está sem alimentação.

Dica

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

Pinos Ethernet

O RT1062 expõe os pares MDI do PHY Ethernet 10/100 Mb/s em pads dedicados junto ao cabeçalho GPIO. Os pinos MDI não são seguros para ligar diretamente a um RJ45 — são obrigatórios magnéticos Ethernet (um transformador de isolamento, integrado num magjack ou num shield) entre o PHY e o cabo. O shield PoE da OpenMV já os inclui; se estiver a usar 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 existe ligação; pisca com tráfego.

  • ETH_TXP / ETH_TXN — par de transmissão.

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

Nota

O cabeçalho também expõe quatro pads com a serigrafia Reserved. Estes são compatíveis com os pares Ethernet gigabit da OpenMV N6 (DC P/N e DD P/N), para que o mesmo shield Ethernet / PoE possa ser ligado a qualquer uma das placas. O PHY do RT1062 só suporta 10/100 Mb/s, pelo que esses quatro pads não têm conectividade elétrica — deixe-os desligados.

Pinos de recuperação e depuração

  • RESET — ligar ao GND para reiniciar a placa. Ao soltar, o MCU arranca normalmente.

  • SBL — ligar a 3,3 V durante a alimentação da placa para entrar no modo de bootloader ROM (Serial Boot Loader). O OpenMV IDE usa este modo para re-flashar o bootloader integrado.

Está incluído um cabeçalho dedicado ARM 10 pinos SWD/JTAG, compatível com adaptadores ST‑LINK e SEGGER J‑Link.

Nota

O RT1062 expõe apenas depuração SWD através deste conector por defeito. O JTAG completo não está disponível de raiz.

Periféricos integrados

LEDs

O RT1062 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 rapidamente o estado da alimentação.

    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 permanece aceso enquanto uma LiPo está a carregar.

Botões

O RT1062 tem dois botões:

  • SW — botão de utilizador de uso geral. Legível por código como uma entrada GPIO normal ativa baixa:

    from machine import Pin

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

  • Botão de alimentação — controlado por uma máquina de estados dedicada no hardware da placa RT1062, inteiramente em hardware. Não está exposto ao código de utilizador; o controlador decide o que fazer com base no tempo de pressão:

    • Manter ~5 s enquanto a placa está em funcionamento → a máquina de estados passa para modo de sono profundo.

    • Manter ~1 s enquanto a placa está em sono profundo → a máquina de estados volta a ligar o sistema.

    Baixar o pad de cabeçalho ON/OFF tem o mesmo efeito que pressionar o botão de alimentação integrado — útil para ligar um interruptor externo ou controlar a linha a partir de outro microcontrolador.

Pinos de estado de alimentação

Três entradas de estado ativas baixas do chip de gestão de energia integrado:

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

  • ST — baixo quando a placa está a funcionar em VIN, alto quando está em alimentação USB. Não ligado por defeito.

  • CHG — baixo enquanto uma bateria LiPo ligada está a carregar. Não ligado por defeito.

from machine import Pin

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

Sensor da câmara

O OV5640 é 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.QVGA)
cam.snapshot(time=2000)       # let auto‑exposure settle

while True:
    img = cam.snapshot()

O OV5640 possui um compressor JPEG integrado. Defina csi.CSI.pixformat como csi.JPEG e o sensor entrega fotogramas comprimidos diretamente à câmara através do barramento de câmara, tornando as capturas de alta resolução práticas: csi.HD (1280×720), csi.FHD (1920×1080) e o csi.WQXGA2 completo de 5 MP (2592×1944) são transmitidos como JPEG. Ajuste a compressão com csi.CSI.quality (0-100, maior = fotogramas maiores, mais detalhe):

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

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

Machine learning

ml — Machine Learning executa modelos TFLite quantizados no Cortex‑M7 com kernels CMSIS‑NN — rápido o suficiente para detetores compactos a alguns fotogramas por segundo. Os modelos no sistema de ficheiros só de leitura /rom carregam diretamente da flash sem copiar para a RAM. Eis um detetor BlazeFace 128×128 que sobrepõe a face detetada e os seus seis pontos de referência em cada fotograma:

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 do RT1062 não liga o acelerómetro integrado ao módulo imu — sensor imu. Em vez disso, comunique com ele diretamente através do barramento I²C interno — o chip está no endereço 0x15 e disponibiliza três canais de aceleração assinados de 12 bits mais um byte de temperatura de 8 bits a partir do registo 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 que o acelerómetro. (As revisões anteriores não têm — chamar estes excertos em R4/R5 resultará em timeout por falta de ack I²C.) Utilize a API machine.I2C padrão com readfrom_mem / writeto_mem e endereço de memória de 16 bits:

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 como as escritas devem permanecer dentro de uma página de 32 bytes. Divida qualquer transferência maior numa chamada por página e adicione o atraso de ~5 ms do ciclo de escrita entre escritas consecutivas.

Wi‑Fi

O módulo da família CYW43 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 módulo sem fios também expõe Bluetooth 5.1. Utilize aioble — BLE Assíncrono para BLE compatível com asyncio — por exemplo, anunciar como periférico e aguardar a ligaçã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) está ligado aos pads MDI, o PHY 10/100 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 barramentos

GPIO

Utilize machine.Pin para ler ou controlar qualquer um dos pinos com serigrafia. As saídas são CMOS a 3,3 V e podem drenar/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 pode também disparar uma interrupção em transições de flanco:

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 pode também 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(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

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 ADC de utilizador é P6, com escala completa a ~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

Controle qualquer um deles via machine.PWM

from machine import Pin, PWM

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

Barramentos por software (bit‑banging)

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

Sensor térmico (externo)

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

  • MLX90621 — matriz IR de 16 × 4

  • MLX90640 — matriz IR de 32 × 24

  • MLX90641 — matriz IR de 16 × 12

  • AMG8833 — matriz IR de 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 4 — ligue o módulo a P4 (SCL) e P5 (SDA).

Temporização

time

O módulo time cobre atrasos bloqueantes, tiques 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 uma slot de temporizador de 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 a slot.

Relógio em tempo real

machine.RTC mantém a hora do relógio entre resets e (com a bateria de reserva opcional de 3,3 V ligada aos pads traseiros, consulte 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 despertar 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 dentro do seu ciclo principal:

from machine import WDT

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

Informação de arranque e tempo de execução

Janela de bootloader USB

Em cada arranque, a câmara executa um bootloader breve (alguns segundos) que permite ao OpenMV IDE atualizar o firmware sem que o utilizador tenha de entrar em modo DFU. Após a janela expirar, o bootloader passa o controlo para boot.py e depois para 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 RT1062 monta até três sistemas de ficheiros no arranque:

  • Flash interna — sempre montada em /flash. Contém main.py e README.txt por defeito; 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 em memória em /rom, usado para disponibilizar grandes recursos de dados (ex.: 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 desse diretório:

  • boot.py é executado em cada reset suave (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. Resets suaves subsequentes executam novamente boot.py mas passam diretamente para o REPL — para executar novamente main.py é necessário reiniciar 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 incluído numa placa recentemente flashada 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 dispositivo anfitrião 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 com o nome SKIPSD na raiz de /flash.

Quando ligada por USB, o sistema de ficheiros de arranque (/sdcard se houver cartão, caso contrário /flash) também é enumerado como unidade de armazenamento em massa USB no anfitrião, permitindo editar boot.py, main.py e quaisquer outros ficheiros diretamente. Ejete a unidade antes de reiniciar a câmara para que o anfitrião escreva as suas alterações 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 enquanto o anfitrião não remontar a unidade. Se tanto o sistema operativo como a OpenMV Cam escreverem no mesmo sistema de ficheiros ao mesmo tempo, o sistema operativo prevalece e sobrescreve as alterações feitas pela câmara. Use o cartão SD para quaisquer dados que o script escreva, e remonte antes de ler esses ficheiros a partir do anfitrião.

Nota

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

Tamanhos de armazenamento

O RT1062 é fornecido com:

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

  • /rom — ROMFS só de leitura com mapeamento em memória de 8 MB, usado para disponibilizar scripts e modelos de 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 — suficientemente rápido para parecer um LED branco cintilante em vez de matizes distintos — o firmware sofreu uma falha grave irrecuperável. Reflashe o firmware para recuperar; se isso 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 compilação do RT1062.