OpenMV Cam M7¶

A OpenMV Cam M7 é uma placa de visão de máquina 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 quadros em escala de cinza 640×480 ou RGB565 320×240 a até 150 FPS, e o cabeçalho de usuário de 10 pinos expõe os periféricos UART, I²C, SPI, CAN, ADC/DAC e PWM.

Para o datasheet completo, fotos 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 cinza 640×480 ou RGB565 320×240 a até 150 FPS.
USB full‑speed (12 Mb/s) — aparece como VCP + armazenamento de massa USB para o host.
Soquete microSD — SD até 2 GB, SDHC até 32 GB, SDXC até 2 TB.
10 pinos de I/O, tolerantes a 5 V com saída de 3,3 V, 25 mA por pino (120 mA no total no cabeçalho), com capacidade de interrupção. P6 não é tolerante a 5 V quando usado em modo ADC ou DAC.
LED RGB de usuário e dois LEDs IR de 850 nm de alta potência para iluminação ativa em visão com pouca luz.

Nota

A M7 não possui chip de gerenciamento de energia integrado: não há conector de bateria, carregador de bateria, ADC de tensão de bateria, LEDs de status de carga / energia, nem botão de energia em hardware. Alimente a placa pela USB ou pela 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	puxe para GND para reiniciar a placa
SYN	pad de sincronização de quadro (frame‑sync) — conectado apenas ao sensor da câmera
BOOT0	puxe para 3,3 V na inicialização para DFU / bootloader de 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 juntos)

Nota

O pad SYN no cabeçalho está conectado diretamente à linha de gatilho / exposição do sensor da câmera — ele não se conecta ao MCU na M7. Acione‑o ou leia‑o externamente; você não pode alterná‑lo a partir do MicroPython.

Pinos de alimentação¶

3.3V — trilho regulado de 3,3 V. Até 250 mA disponíveis para shields (menos se o cartão microSD estiver em uso). Diferentemente das câmeras mais novas, este pino é bidirecional — veja o aviso abaixo.
VIN — entrada de 3,6 – 5 V. Alimenta a placa através do regulador integrado.
GND — terra comum.

Nota

Quando tanto a USB quanto a VIN estão presentes, aquela que tiver a tensão mais alta alimenta a placa — os diodos integrados simplesmente selecionam o trilho mais forte.

Aviso

Você pode alimentar a M7 fornecendo 3,3 V diretamente no pino 3.3V caso não queira passar pelo regulador integrado. Nesse caso, não aplique também VIN ou alimentação USB ao mesmo tempo — alimentar o regulador no sentido reverso enquanto outra fonte está ativa pode danificar permanentemente e destruir a câmera.

Dica

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

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

RESET — puxe para GND para reiniciar a placa. Liberá‑lo permite que o MCU inicie normalmente.
BOOT0 — puxe para 3,3 V enquanto alimenta a placa para entrar no bootloader de ROM do STM32 (modo DFU). A OpenMV IDE usa esse modo para regravar o bootloader integrado.

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

Periféricos integrados¶

LEDs¶

A M7 tem um único LED RGB de usuário, além de um par de LEDs IR de 850 nm de alta potência:

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

LEDs IR — ambos os LEDs são acionados juntos através do pino LED_IR. LED_IR é ligado como ativo em nível alto no hardware, enquanto o firmware trata todos os outros LEDs integrados como ativos em nível baixo, então use 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âmera¶

O OV7725 é 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 sensor é soldado à placa na M7 — ele não está em um módulo intercambiável.

cartão microSD¶

Quando um cartão é inserido, ele é montado automaticamente em /sdcard e pode ser usado 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, tolerantes a 5 V no lado de entrada, e podem drenar/fornecer até 25 mA por pino (120 mA no total em todo o cabeçalho).

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

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 usuário. Ele pode ser usado como entrada ADC de 12 bits ou saída DAC.

ADC — fundo de escala em 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, P6 é tolerante apenas a 3,3 V — não aplique 5 V.

PWM¶

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

Nota

TIM1 é reservado pelo firmware para gerar o clock de pixel do sensor da câmera, então os canais do TIM1 que estão fisicamente em P0/P1/P2 não podem ser usados para PWM de usuário sem quebrar o funcionamento da câmera.

TIM4 é compartilhado com pyb.Servo — instanciar um servo reconfigura o timer inteiro para operação em 50 Hz, então não misture machine.PWM em P7/P8/P9 com pyb.Servo no mesmo script.

Acione qualquer um deles via machine.PWM

from machine import Pin, PWM

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

Barramentos por software (bit‑banged)¶

machine.SoftI2C e machine.SoftSPI funcionam em qualquer GPIO caso você precise de um barramento extra.

Sensor térmico (externo à placa)¶

O firmware inclui o driver fir — driver de sensor térmico (fir == far infrared) para sensores 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 os 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 pela 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 de disparo único 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 reinicializações:

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 travar. Uma vez iniciado, ele não pode ser parado ou 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 inicialização, a câmera executa um breve bootloader (alguns segundos) que permite que a OpenMV IDE atualize o firmware sem que o usuário precise entrar no modo DFU. Após o término dessa janela, o bootloader transfere o controle para o boot.py e em seguida para 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 M7 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 estiver inserido, ele é montado em /sdcard.
ROMFS — sistema de arquivos somente leitura, mapeado em memória, em /rom, usado para embarcar grandes ativos de dados (por exemplo, modelos de IA) que se beneficiam de acesso sem cópia. 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 a cada soft reset (boot a frio, Ctrl‑D a partir do REPL, ou sempre que o script em execução retorna).
main.py é executado somente 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 reiniciar totalmente a placa.

Colocar um boot.py ou main.py no cartão SD substitui a cópia na flash sem alterá‑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 batimento cardíaco (dois pulsos curtos, breve intervalo), para que você possa saber que o firmware inicializou corretamente sem nenhum host conectado.

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 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 uma unidade de armazenamento de massa USB no host, permitindo que você edite boot.py, main.py e quaisquer outros arquivos diretamente. Ejete a unidade antes de reiniciar a câmera para que o host descarregue suas gravações em cache.

Nota

Como o SO trata a unidade como um dispositivo de bloco passivo, os arquivos criados ou modificados pelo código em execução na OpenMV Cam não aparecerão até que o host remonte a unidade. Se tanto o SO quanto a OpenMV Cam gravarem 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 qualquer dado 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 lê ou grava na unidade de armazenamento de massa USB — isso é um indicador de atividade controlado pelo firmware, não uma falha.

Tamanhos de armazenamento¶

A M7 vem com:

/flash — sistema de arquivos FAT de 96 KB, leitura/gravação.
/rom — ROMFS de 256 KB somente leitura, mapeado em memória.
/sdcard — tamanho total de qualquer cartão microSD inserido (quando presente), leitura/gravação.

Indicador de falha grave (hard fault)¶

Se o LED RGB de usuário estiver ciclando rapidamente por todas as cores — rápido o suficiente para parecer um LED branco cintilante em vez de tons distintos — o firmware encontrou uma falha grave irrecuperável (hard fault). 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 M7.