OpenMV Cam M7¶

A OpenMV Cam M7 é uma placa de visão por computador baseada em Cortex‑M7, construída em torno do STMicroelectronics STM32F765 a 216 MHz, com 512 KB de SRAM interna e 2 MB de flash interna. O sensor OV7725 incluído captura fotogramas em escala de cinzentos de 640×480 ou RGB565 de 320×240 a até 150 FPS, e o conector de utilizador de 10 pinos expõe periféricos UART, I²C, SPI, CAN, ADC/DAC e PWM.

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

Destaques¶

STMicroelectronics STM32F765 Cortex‑M7 a 216 MHz.
512 KB de SRAM interna — sem SDRAM externa.
2 MB de flash interna (sem flash QSPI externa).
Sensor OV7725 — escala de cinzentos 640×480 ou RGB565 320×240 a até 150 FPS.
USB de alta velocidade (12 Mb/s) — aparece ao sistema anfitrião como VCP + armazenamento de massa USB.
Ranhura microSD — SD até 2 GB, SDHC até 32 GB, SDXC até 2 TB.
10 pinos de E/S, tolerantes a 5 V com saída de 3,3 V, 25 mA por pino (120 mA no total em todo o conector), com suporte a interrupções. O pino P6 não é tolerante a 5 V quando utilizado no modo ADC ou DAC.
LED RGB de utilizador e dois LEDs IR de alta potência a 850 nm para iluminação ativa em visão com pouca luz.

Nota

A M7 não possui chip de gestão de energia a bordo: não tem conector de bateria, nem carregador de bateria, nem ADC de tensão de bateria, nem LEDs de carga/estado de energia, nem botão de alimentação por hardware. Alimente a placa através de USB ou VIN.

Pinagem¶

Referência de pinos¶

Nome do pino	Função
P0	UART1 RX / SPI2 MOSI
P1	UART1 TX / SPI2 MISO
P2	SPI2 SCK / CAN2 TX
P3	SPI2 NSS (CS) / CAN2 RX
P4	I2C2 SCL / UART3 TX / TIM2 CH3
P5	I2C2 SDA / UART3 RX / TIM2 CH4
P6	ADC / DAC / TIM2 CH1
P7	I2C4 SCL / TIM4 CH1
P8	I2C4 SDA / TIM4 CH2
P9	TIM4 CH3
RESET	ligar ao GND para reiniciar a placa
SYN	pad de sincronização de fotograma — ligado apenas ao sensor da câmara
BOOT0	ligar a 3,3 V ao ligar para DFU / bootloader ROM
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)
LED_IR	LEDs IR de alta potência (ambos os canais acionados em conjunto)

Nota

O pad SYN no conector está ligado diretamente à linha de disparo/exposição do sensor da câmara — não está encaminhado para o MCU na M7. Acione-o ou leia-o externamente; não é possível controlá-lo a partir do MicroPython.

Pinos de alimentação¶

3.3V — rail de 3,3 V regulado. Até 250 mA disponíveis para shields (menos se o cartão microSD estiver em uso). Ao contrário das câmaras mais recentes, este pino é bidirecional — consulte o aviso abaixo.
VIN — entrada de 3,6–5 V. Alimenta a placa através do regulador a bordo.
GND — massa comum.

Nota

Quando USB e VIN estão presentes simultaneamente, aquele com maior tensão alimenta a placa — os díodos a bordo selecionam simplesmente o rail mais forte.

Aviso

Pode alimentar a M7 injetando 3,3 V diretamente no pino 3.3V se não quiser passar pelo regulador a bordo. Nesse caso, não aplique também alimentação por VIN ou USB ao mesmo tempo — alimentar o regulador na direção inversa enquanto outra fonte estiver ativa pode danificar e destruir permanentemente a câmara.

Dica

Utilize o estimador de duração de bateria para modelar quanto tempo a M7 funcionará com uma bateria para um dado ciclo de trabalho ativo/sono profundo.

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

RESET — ligar ao GND para reiniciar a placa. Ao libertar, o MCU arranca normalmente.
BOOT0 — ligar a 3,3 V ao alimentar a placa para entrar no bootloader ROM do STM32 (modo DFU). O OpenMV IDE utiliza este modo para reflashear o bootloader a bordo.

A placa expõe um conector de depuração SWD (RST / SWCLK / SWDIO) junto ao conector GPIO, compatível com adaptadores ST‑LINK e SEGGER J‑Link.

Periféricos a bordo¶

LEDs¶

A M7 tem um único LED RGB de utilizador mais um par de LEDs IR de alta potência a 850 nm:

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

LEDs IR — ambos os LEDs são acionados em conjunto através do pino LED_IR. O LED_IR está ligado como ativo em nível alto por hardware, enquanto o firmware trata todos os outros LEDs a bordo como ativos em nível baixo; por isso utilize low() / high() em vez de on() / off() (que inverteriam o sentido):
```
from machine import LED

ir = LED("LED_IR")
ir.low()    # turn IR illumination ON
ir.high()   # turn IR illumination OFF
```

Sensor da câmara¶

O OV7725 é 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 sensor está soldado à placa na M7 — não se encontra num módulo substituível.

Cartão microSD¶

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

import os

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

Referência de barramentos¶

GPIO¶

Utilize machine.Pin para ler ou acionar qualquer um dos pinos indicados na silkscreen. As saídas são CMOS de 3,3 V, tolerantes a 5 V no lado de entrada, e podem absorver/fornecer até 25 mA por pino (120 mA no total em todo o conector).

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 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
UART1	P1	P0
UART3	P4	P5

from machine import UART

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

I²C¶

Barramento	SCL	SDA
I2C2	P4	P5
I2C4	P7	P8

from machine import I2C

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

O mesmo hardware pode também ser utilizado 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

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
CAN2	P2	P3

from machine import CAN

can = CAN(2, 500_000)
can.set_filters(None)
can.send(0x123, b"\xDE\xAD\xBE\xEF")
print(can.recv())

ADC e DAC¶

P6 é o único pino analógico de utilizador. Pode ser utilizado como entrada ADC de 12 bits ou como saída DAC.

ADC — escala completa a 3,3 V no pino:

from machine import ADC
import time

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

DAC — através de pyb.DAC. O valor de 8 bits cobre 0–3,3 V:

from pyb import DAC

dac = DAC("P6")
voltage = 1.65
dac.write(int(voltage / 3.3 * 255))

Em modo ADC ou DAC, o P6 é tolerante apenas a 3,3 V — não o alimente com 5 V.

PWM¶

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

Nota

O TIM1 está reservado pelo firmware para gerar o clock de pixel do sensor da câmara, pelo que os canais do TIM1 que estão fisicamente em P0/P1/P2 não podem ser utilizados para PWM de utilizador sem danificar a câmara.

O TIM4 é partilhado com pyb.Servo — ao instanciar um servo reconfigura-se o temporizador inteiro para operação a 50 Hz, pelo que não se deve misturar machine.PWM em P7/P8/P9 com pyb.Servo no mesmo script.

Acione qualquer um deles através de machine.PWM

from machine import Pin, PWM

pwm = PWM(Pin("P7"), 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 imagiadores térmicos ligados externamente:

MLX90621 — array IR 16 × 4
MLX90640 — array IR 32 × 24
MLX90641 — array IR 16 × 12
AMG8833 — array 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 comunica com o sensor apenas através do I²C 2 — ligue 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)

Temporizadores virtuais¶

machine.Timer agenda callbacks periódicos ou únicos sem consumir uma 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 são em milissegundos. Chame deinit() para parar e libertar a slot.

Relógio de tempo real¶

machine.RTC mantém a hora do relógio de parede entre reinícios:

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

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ções de arranque e execução¶

Janela do 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 cede o controlo ao boot.py e depois ao main.py.

Um script em execução pode voltar ao bootloader sob pedido chamando machine.bootloader()

import machine

machine.bootloader()

Sistema de ficheiros e ordem de arranque¶

O firmware da M7 monta até três sistemas de ficheiros no arranque:

Flash interna — sempre montada em /flash. Contém main.py e README.txt por omissão; criada no primeiro arranque.
Cartão microSD — se um cartão estiver inserido, é montado em /sdcard.
ROMFS — sistema de ficheiros ROMFS de só leitura mapeado em memória em /rom, utilizado para distribuir grandes recursos de dados (p. ex. modelos de IA) que beneficiam de acesso zero-copy. 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 para /sdcard quando o cartão está presente, caso contrário para /flash. O interpretador executa então scripts a partir desse diretório:

O boot.py é executado em cada soft reset (arranque a frio, Ctrl‑D a partir do REPL, ou sempre que o script em execução terminar).
O main.py é executado apenas no arranque a frio, imediatamente após o boot.py. Os soft resets subsequentes re-executam o boot.py mas vão diretamente para o REPL — para re-executar o main.py tem de reiniciar completamente a placa.

Colocar um boot.py ou main.py no cartão SD substitui a cópia em flash sem a modificar — 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 apenas pisca o canal azul do LED RGB de utilizador como heartbeat (dois pulsos curtos, pausa curta), para que possa confirmar que o firmware arrancou corretamente sem nenhum anfitrião ligado.

O sys.path é alargado para incluir os três sistemas de ficheiros e os respetivos subdiretórios lib/, pelo que os 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 ficheiro vazio com o nome 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 uma unidade de armazenamento de 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 em execução na OpenMV Cam não aparecerão até que o anfitrião remonte a unidade. Se tanto o sistema operativo como a OpenMV Cam escreverem no mesmo sistema de ficheiros ao mesmo tempo, o sistema operativo prevalecerá e sobrescreverá as alterações feitas pela câmara. Utilize o cartão SD para quaisquer dados que o script grave, 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 lê ou escreve na unidade de armazenamento de massa USB — este é um indicador de atividade controlado pelo firmware, não uma falha.

Tamanhos de armazenamento¶

A M7 é fornecida com:

/flash — sistema de ficheiros FAT de 96 KB, leitura/escrita.
/rom — ROMFS de só leitura mapeado em memória de 256 KB.
/sdcard — tamanho total do cartão microSD inserido (quando presente), leitura/escrita.

Indicador de hard fault¶

Se o LED RGB de utilizador estiver a ciclar rapidamente por todas as cores — suficientemente rápido para parecer um LED branco a cintilar em vez de matizes distintos — o firmware atingiu um hard fault irrecuperável. Reflashee o firmware para recuperar; se o reflash não ajudar, a placa pode estar fisicamente danificada.

Bibliotecas de software¶

Consulte o índice da biblioteca para obter a lista completa de módulos — incluindo quais são exclusivos da compilação M7.