OpenMV Cam H7¶

A OpenMV Cam H7 é uma placa de visão por computador baseada em Cortex‑M7, construída em torno do STMicroelectronics STM32H743 a 480 MHz, com 1 MB de SRAM interna, 2 MB de flash interna e um codec JPEG por hardware. A placa existe em duas revisões de sensor — a H7 com o OV7725 e a H7 R2 com o ON Semi MT9M114 — mas o firmware, o pinout e a API Python são idênticos.

Para a ficha técnica completa, fotografias e dimensões, consulte a página do produto OpenMV Cam H7.

Destaques¶

STMicroelectronics STM32H743 Cortex‑M7 a 480 MHz (1027 DMIPS).
Encoder/decoder JPEG por hardware.
1 MB de SRAM interna — sem SDRAM externa.
2 MB de flash interna (sem flash QSPI externa).
Sensor OV7725 (ou MT9M114 na H7 R2).
USB full‑speed (12 Mb/s) — surge como VCP + armazenamento em massa USB no host.
Conector microSD — SD até 2 GB, SDHC até 32 GB, SDXC até 2 TB.
Conector de bateria LiPo (sem carregador integrado — utilize uma célula carregada ou alimente via VIN/USB).
10 pinos de E/S, tolerantes a 5 V com saída a 3,3 V, 25 mA por pino (120 mA no total no conector), com suporte a interrupções. O 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 H7 não tem chip de gestão de energia integrado: não há carregador de bateria, ADC de tensão de bateria, LEDs de estado de carga/alimentação nem botão de energia por hardware. Ligue uma LiPo pré-carregada ao JST de bateria ou alimente a placa via USB / VIN.

Pinout¶

Referência de pinos¶

Nome do pino	Função
P0	UART1 RX / SPI2 MOSI
P1	UART1 TX / SPI2 MISO
P2	SPI2 SCK / FDCAN2 TX
P3	SPI2 NSS (CS) / FDCAN2 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 no arranque para DFU / bootloader de ROM
LED_RED	canal vermelho do LED RGB (ativo a baixo)
LED_GREEN	canal verde do LED RGB (ativo a baixo)
LED_BLUE	canal azul do LED RGB (ativo a 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 é encaminhado para o MCU na H7. Acione-o ou leia-o externamente; não é possível controlá-lo a partir do MicroPython.

Pinos de alimentação¶

3.3V — rail regulado a 3,3 V. 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 integrado.
GND — massa comum.

Está também presente um conector LiPo de 3,7 V, mas a H7 não tem carregador de bateria — ligue uma célula pré-carregada ou alimente via VIN / USB.

Nota

Quando estão presentes USB e VIN/LiPo em simultâneo, a entrada VIN/LiPo prevalece — o comutador de alimentação integrado prioriza-a sobre o USB para alimentar a placa.

Aviso

O conector de bateria e o VIN estão ligados entre si na H7. Não ligue uma LiPo e aplique VIN ao mesmo tempo — as duas fontes entrarão em conflito e podem danificar a bateria, a placa ou ambos.

Aviso

Pode alimentar a H7 injetando 3,3 V diretamente no pino 3.3V se não quiser passar pelo regulador integrado. Nesse caso, não aplique também VIN ou alimentação USB ao mesmo tempo — retroalimentar o regulador enquanto outra fonte está ativa pode danificá-lo permanentemente e destruir a câmara.

Dica

Utilize o estimador de autonomia da bateria para modelar quanto tempo a H7 funcionará com uma bateria para um dado ciclo de trabalho ativo / em 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 ligar a placa para entrar no bootloader de ROM do STM32 (modo DFU). O OpenMV IDE usa este modo para reprogramar o bootloader integrado.

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

LEDs¶

A H7 tem um único LED RGB de utilizador e 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 é ligado ativo a alto por hardware, enquanto o firmware trata todos os outros LEDs integrados como ativos a baixo, pelo que deve usar 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 (ou MT9M114 na H7 R2) é 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 encontra-se num módulo amovível — pode trocá-lo por qualquer outro módulo de câmara OpenMV (obturador global, térmico, maior resolução, etc.) sem alterar o resto da placa.

Cartão microSD¶

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

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 serigrafia. As saídas são CMOS a 3,3 V, tolerantes a 5 V no lado da 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 nível:

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 no 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 (FDCAN)¶

Barramento	TX	RX
FDCAN2	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¶

O P6 é o único pino analógico de utilizador. Pode ser usado 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))

No modo ADC ou DAC, o P6 é tolerante apenas a 3,3 V — não aplique 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 usados para PWM de utilizador sem quebrar o funcionamento da câmara.

O TIM4 é partilhado com pyb.Servo — instanciar um servo reconfigura todo o temporizador para operação a 50 Hz, por isso 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-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 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 comunica com o sensor apenas via 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 um 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 estão em milissegundos. Chame deinit() para parar e libertar o slot.

Relógio em tempo real¶

machine.RTC mantém a hora do relógio entre 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 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 runtime¶

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 necessite de entrar no modo DFU. Após expirar a janela, o bootloader passa o controlo a boot.py e depois a main.py.

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

import machine

machine.bootloader()

Sistema de ficheiros e ordem de arranque¶

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

Flash interna — montada sempre em /flash. Contém main.py e README.txt por predefinição; criada no primeiro arranque.
Cartão microSD — se um cartão estiver inserido, é montado em /sdcard.
ROMFS — sistema de ficheiros de leitura apenas, mapeado em memória em /rom, usado para distribuir grandes recursos de dados (por 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, ou /flash caso contrário. O interpretador executa então os scripts a partir 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. Os resets suaves subsequentes re-executam boot.py mas passam diretamente para o REPL — para re-executar main.py é necessário reinicializar 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 que é distribuído numa placa recém-programada apenas faz piscar o canal azul do LED RGB de utilizador como batida cardíaca (dois pulsos curtos, pausa curta), para que seja possível confirmar que o firmware arrancou corretamente sem qualquer host ligado.

sys.path é alargado 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 ligado via 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 host, permitindo editar diretamente boot.py, main.py e quaisquer outros ficheiros. Ejete a unidade antes de reiniciar a câmara para que o host descarregue as escritas 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 até o host remontar 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 escreva, e remonte antes de ler esses ficheiros a partir do host.

Nota

O canal vermelho do LED RGB de utilizador pode acender brevemente enquanto o host 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¶

A H7 é fornecida com:

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

Indicador de hard fault¶

Se o LED RGB de utilizador estiver a percorrer rapidamente todas as cores — rápido o suficiente para parecer um LED branco a piscar em vez de tonalidades distintas — o firmware sofreu um hard fault irrecuperável. Reprogramar o firmware para recuperar; se a reprogramaçã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 compilação H7.