OpenMV Cam H7 Plus¶

A OpenMV Cam H7 Plus combina o STMicroelectronics STM32H743 (Cortex‑M7 @ 480 MHz) com 32 MB de SDRAM externa, 32 MB de flash QSPI, um codec JPEG por hardware e o módulo de câmera OV5640 de 5MP em um suporte removível. A memória extra é bem adequada para captura em alta resolução e grandes buffers de imagem.

Para o datasheet completo, fotos e dimensões, consulte a página do produto OpenMV Cam H7 Plus.

Destaques¶

STMicroelectronics STM32H743 Cortex‑M7 a 480 MHz (1027 DMIPS).
Codificador/decodificador JPEG por hardware.
32 MB de SDRAM externa (32 bits @ 100 MHz, 400 MB/s) mais 1 MB de SRAM interna.
2 MB de flash interna + 32 MB de flash QSPI externa (~100 MB/s de leitura).
Sensor OV5640 de 5MP com rolling shutter.
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 embutido — forneça uma célula carregada ou alimente via VIN/USB).
10 pinos de I/O, tolerantes a 5 V com saída de 3,3 V, 25 mA por pino (120 mA no total ao longo do header), capazes 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 H7 Plus não tem chip de gerenciamento de energia embutido: não há carregador de bateria, nem ADC de tensão da bateria, nem LEDs de status de carga/energia e nem botão de energia por hardware. Conecte uma LiPo pré‑carregada ao JST de bateria ou alimente a placa via USB / VIN.

Pinagem¶

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	I/O digital
RESET	puxe para GND para resetar a placa
SYN	pad de frame‑sync — ligado somente ao sensor da câmera
BOOT0	puxe para 3,3 V na inicialização 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 juntos)

Nota

O pad SYN no header é conectado diretamente à linha de trigger / exposição do sensor da câmera — ele não se conecta ao MCU na H7 Plus. Acione 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 embutido.
GND — terra comum.

Também há um conector LiPo de 3,7 V, mas a H7 Plus não possui um 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 vence — a chave de energia embutida a escolhe em vez do USB para alimentar a placa.

Aviso

O conector de bateria e VIN estão interligados na H7 Plus. 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 Plus injetando 3,3 V diretamente no pino 3.3V se não quiser passar pelo regulador embutido. Nesse caso, não aplique também VIN ou alimentação USB ao mesmo tempo — forçar a alimentação reversa do regulador 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 Plus vai funcionar com uma bateria para um dado ciclo de trabalho ativo / deep‑sleep.

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

RESET — puxe para GND para resetar a placa. Soltá-lo permite que o MCU inicie 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 embutido.

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

Nota

O pino de trace SWO é compartilhado com a linha de clock SPI do header da câmera. O SWO não pode ser usado ao mesmo tempo que qualquer módulo de câmera que se comunique com o MCU via SPI — por exemplo o Módulo Adaptador FLIR® Lepton® — escolha um ou outro.

Periféricos embutidos¶

LEDs¶

A H7 Plus 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 ativo em nível alto no hardware, enquanto o firmware trata todos os outros LEDs embutidos 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 OV5640 é 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 OV5640 tem um compressor JPEG embutido. Defina csi.CSI.pixformat como csi.JPEG e o sensor entrega quadros comprimidos diretamente para a câmera pelo barramento da câmera, o que torna práticas as capturas em alta resolução: csi.HD (1280×720), csi.FHD (1920×1080) e o csi.WQXGA2 completo de 5MP (2592×1944) todos transmitem como JPEG. Ajuste a compressão com csi.CSI.quality (0-100, maior = quadros maiores, mais detalhes):

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

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, resolução maior, etc.) sem alterar o restante da placa.

Aprendizado de máquina¶

ml — Aprendizado de Máquina executa modelos TFLite quantizados no Cortex‑M7 com kernels CMSIS‑NN — rápido o suficiente para detectores compactos a alguns quadros por segundo. Modelos no sistema de arquivos somente leitura /rom carregam diretamente da flash sem copiar para a RAM. Aqui está um detector BlazeFace de 128×128 sobrepondo o rosto detectado e seus seis pontos de referência em cada quadro:

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

Cartão microSD¶

Quando um cartão é inserido, ele é montado automaticamente em /sdcard e fica utilizável 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 da entrada e podem absorver/fornecer até 25 mA por pino (120 mA no total ao longo de todo o header).

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 target (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¶

P6 é o único pino analógico de usuário. Ele pode ser usado tanto como entrada ADC de 12 bits quanto 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))

Em modo ADC ou DAC, 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

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 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 bit‑banging via software¶

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 sensores térmicos conectados 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

Conecte o módulo ao barramento I²C da placa e leia 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ó conversa com o sensor através do I²C 2 — conecte o módulo a P4 (SCL) e P5 (SDA).

Temporização¶

time¶

O módulo time cobre delays 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 por 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 o horário de relógio 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, ele não pode ser parado nem 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¶

A cada inicialização, a câmera executa um bootloader curto (alguns segundos) que permite à OpenMV IDE atualizar o firmware sem o usuário precisar entrar no modo DFU. Após a janela expirar, o bootloader passa o controle para o boot.py e depois 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 H7 Plus 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 for inserido, ele é montado em /sdcard.
ROMFS — sistema de arquivos somente leitura, mapeado em memória, em /rom, usado para distribuir grandes assets de dados (por exemplo, modelos de IA) que se beneficiam de acesso sem cópia (zero‑copy). 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 todo soft reset (boot a frio, Ctrl‑D a partir do REPL ou sempre que o script em execução retorna).
main.py é executado apenas no boot a frio, imediatamente após o boot.py. Soft resets subsequentes reexecutam o boot.py mas caem direto no REPL — para reexecutar o main.py você precisa resetar totalmente a placa.

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

O 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 em massa USB no host, permitindo que você edite 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 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 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 está lendo ou gravando na unidade de armazenamento em massa USB — isso é um indicador de atividade controlado pelo firmware, não uma falha.

Tamanhos de armazenamento¶

A H7 Plus vem com:

/flash — sistema de arquivos FAT de 24 MB, leitura/gravação.
/rom — ROMFS somente leitura, mapeado em memória, de 8 MB, usado para distribuir scripts e modelos de ML que se beneficiam de acesso mmap sem cópia (zero‑copy).
/sdcard — tamanho total de qualquer cartão microSD inserido (quando presente), leitura/gravação.

Indicador de 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 matizes distintos — o firmware atingiu 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 da biblioteca para a lista completa de módulos — incluindo quais são exclusivos da build da H7 Plus.