OpenMV Cam H7¶

A OpenMV Cam H7 é uma placa de visão de máquina 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 é fornecida 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 o datasheet completo, fotos e dimensões, consulte a página do produto OpenMV Cam H7.

Destaques¶

STMicroelectronics STM32H743 Cortex‑M7 a 480 MHz (1027 DMIPS).
Codificador/decodificador 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) — aparece como VCP + armazenamento em massa USB para o host.
Soquete microSD — SD até 2 GB, SDHC até 32 GB, SDXC até 2 TB.
Conector de bateria LiPo (sem carregador embarcado — forneça uma célula carregada ou alimente via VIN/USB).
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ção. O P6 não é tolerante a 5 V quando usado no 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 H7 não possui chip de gerenciamento de energia embarcado: não há carregador de bateria, ADC de tensão de bateria, LEDs de status de carregamento/energia, nem botão físico de energia. Conecte 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	puxe para GND para resetar 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 o bootloader DFU / 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 conector é ligado diretamente à linha de gatilho / exposição do sensor da câmera — ele não é roteado para o MCU na H7. 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). Diferente das câmeras mais recentes, este pino é bidirecional — veja o aviso abaixo.
VIN — entrada de 3,6 – 5 V. Alimenta a placa através do regulador embarcado.
GND — terra comum.

Também há um conector LiPo de 3,7 V, mas a H7 não possui carregador de bateria — conecte uma célula pré‑carregada ou forneça VIN / USB.

Nota

Quando USB e VIN/LiPo estão presentes ao mesmo tempo, a entrada VIN/LiPo prevalece — a chave de energia embarcada a escolhe em vez do USB para alimentar a placa.

Aviso

O conector de bateria e o VIN estão interligados na H7. Não conecte uma LiPo e aplique VIN ao mesmo tempo — as duas fontes vão disputar entre si e podem danificar a bateria, a placa, ou ambas.

Aviso

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

Dica

Use o estimador de vida útil da bateria para modelar por quanto tempo a H7 funcionará com bateria para um determinado ciclo de trabalho ativo / sono profundo.

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

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

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

Periféricos embarcados¶

LEDs¶

A H7 tem um único LED RGB de usuário mais 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. O LED_IR é ligado como ativo em nível alto no hardware, enquanto o firmware trata todos os outros LEDs embarcados 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 (ou MT9M114 na H7 R2) é 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 fica em um módulo removível — troque‑o por qualquer um dos outros módulos de câmera OpenMV (global shutter, térmico, maior resolução, etc.) sem alterar o resto da placa.

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

No modo ADC ou DAC, o P6 é tolerante apenas a 3,3 V — não o alimente com 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

O 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 a câmera.

O TIM4 é compartilhado com pyb.Servo — instanciar um servo reconfigura todo o timer para operação a 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‑bang)¶

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

Ligue 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 pelo 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)

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 (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 liberar o slot.

Relógio de tempo real¶

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

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 reseta a placa se a aplicação travar. Uma vez iniciado, não pode ser parado ou reconfigurado — alimente‑o periodicamente dentro do seu loop 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¶

Em cada inicialização, a câmera executa um bootloader curto (alguns segundos) que permite à OpenMV IDE atualizar o firmware sem que o usuário precise entrar no modo DFU. Após o término dessa janela, o bootloader passa o controle para boot.py e em seguida para 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 H7 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 na primeira inicialização.
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 distribuir 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 de qualquer código Python do usuário 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 então executa os scripts a partir desse diretório:

boot.py é executado em cada soft reset (cold boot, Ctrl‑D no REPL, ou sempre que o script em execução retorna).
main.py é executado apenas no cold boot, imediatamente após boot.py. Soft resets subsequentes reexecutam boot.py mas caem direto no REPL — para reexecutar main.py você precisa resetar completamente 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 (dois pulsos curtos, intervalo curto), para que você saiba que o firmware inicializou corretamente sem nenhum host conectado.

O sys.path é estendido para incluir os três sistemas de arquivos e seus subdiretórios lib/, de modo que módulos importáveis podem ficar 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 conectado por 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 editar boot.py, main.py e quaisquer outros arquivos diretamente. Ejete a unidade antes de resetar 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, arquivos criados ou modificados por 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 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 lê ou grava na unidade de armazenamento em massa USB — este é um indicador de atividade controlado pelo firmware, não uma falha.

Tamanhos de armazenamento¶

A H7 é fornecida com:

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

Indicador de hard fault¶

Se o LED RGB de usuário estiver alternando rapidamente entre todas as cores — rápido o suficiente para parecer um LED branco cintilante em vez de tons distintos — o firmware encontrou 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 H7.