OpenMV Cam H7 Plus¶

A OpenMV Cam H7 Plus combina o STMicroelectronics STM32H743 (Cortex‑M7 a 480 MHz) com 32 MB de SDRAM externa, 32 MB de flash QSPI, um codec JPEG por hardware e o módulo de câmara OV5640 de 5 MP numa placa removível. A memória extra é adequada para capturas de 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/descodificador JPEG por hardware.
32 MB de SDRAM externa (32 bits a 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 5 MP com obturador rolante.
USB Full‑Speed (12 Mb/s) — aparece como VCP + armazenamento de massa USB no anfitrião.
Encaixe microSD — SD até 2 GB, SDHC até 32 GB, SDXC até 2 TB.
Conector de bateria LiPo (sem carregador incorporado — ligue 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 pelo conector), com suporte a interrupções. O pino P6 não é tolerante a 5 V quando usado no modo ADC ou DAC.
LED RGB de utilizador 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 gestão de energia: 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 conector JST da 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	E/S digital
RESET	ligar ao GND para reiniciar a placa
SYN	pino de sincronização de fotograma — ligado apenas ao sensor da câmara
BOOT0	ligar a 3,3 V na inicialização para entrar no modo DFU / bootloader ROM
LED_RED	canal vermelho do LED RGB (ativo no nível baixo)
LED_GREEN	canal verde do LED RGB (ativo no nível baixo)
LED_BLUE	canal azul do LED RGB (ativo no nível baixo)
LED_IR	LEDs IR de alta potência (ambos os canais acionados em conjunto)

Nota

O pino SYN no conector está ligado diretamente à linha de disparo / exposição do sensor da câmara — não está ligado ao MCU na H7 Plus. 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 incorporado.
GND — massa comum.

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

Nota

Quando USB e VIN/LiPo estão presentes em simultâneo, a entrada VIN/LiPo tem prioridade — o interruptor de alimentação incorporado seleciona-a em detrimento do USB para alimentar a placa.

Aviso

O conector de bateria e o VIN estão ligados em conjunto na H7 Plus. Não ligue uma LiPo e aplique VIN ao mesmo tempo — as duas fontes de alimentação irão competir entre si e podem danificar a bateria, a placa ou ambas.

Aviso

Pode alimentar a H7 Plus fornecendo 3,3 V diretamente no pino 3.3V se não quiser utilizar o regulador incorporado. Nesse caso, não aplique VIN ou alimentação USB ao mesmo tempo — alimentar o regulador inversamente enquanto outra fonte está ativa pode danificá-lo permanentemente e destruir a câmara.

Dica

Use o estimador de autonomia da bateria para calcular durante quanto tempo a H7 Plus funcionará com uma bateria para um determinado 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 inicia normalmente.
BOOT0 — ligar a 3,3 V ao ligar a placa para entrar no bootloader ROM do STM32 (modo DFU). O OpenMV IDE usa este modo para reflashear o bootloader incorporado.

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

Nota

O pino de rastreio SWO é partilhado com a linha de relógio SPI do conector da câmara. O SWO não pode ser usado ao mesmo tempo que qualquer módulo de câmara que comunique com o MCU via SPI — por exemplo, o Módulo Adaptador FLIR® Lepton® — escolha um ou o outro.

Periféricos integrados¶

LEDs¶

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

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 em hardware com lógica ativa no nível alto, enquanto o firmware trata todos os outros LEDs integrados como ativos no nível baixo; por isso, 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âmara¶

O OV5640 é 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 OV5640 tem um compressor JPEG integrado. Defina csi.CSI.pixformat como csi.JPEG e o sensor entrega fotogramas comprimidos diretamente para a câmara pelo bus da câmara, tornando as capturas de alta resolução práticas: csi.HD (1280×720), csi.FHD (1920×1080) e os 5 MP completos csi.WQXGA2 (2592×1944) são todos transmitidos como JPEG. Ajuste a compressão com csi.CSI.quality (0-100, maior = fotogramas maiores, mais detalhe):

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

O sensor está num módulo removível — substitua-o por qualquer um dos outros módulos de câmara OpenMV (obturador global, térmico, maior resolução, etc.) sem alterar o resto da placa.

Aprendizagem automática¶

ml — Machine Learning executa modelos TFLite quantizados no Cortex‑M7 com kernels CMSIS‑NN — rápido o suficiente para detetores compactos a alguns fotogramas por segundo. Os modelos no sistema de ficheiros de leitura /rom carregam diretamente da flash sem copiar para a RAM. Aqui está um detetor BlazeFace de 128×128 que sobrepõe o rosto detetado e os seus seis pontos-chave em cada fotograma:

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, é montado automaticamente em /sdcard e pode ser usado através do sistema de ficheiros normal:

import os

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

Referência de buses¶

GPIO¶

Use machine.Pin para ler ou acionar qualquer um dos pinos serigrafiados. As saídas são CMOS de 3,3 V, tolerantes a 5 V no lado da entrada, e conseguem drenar/fornecer até 25 mA por pino (120 mA no total pelo 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 flanco:

def handler(pin):
    print("triggered:", pin)

Pin("P1", Pin.IN, Pin.PULL_UP).irq(
    handler, Pin.IRQ_FALLING | Pin.IRQ_RISING,
)

UART¶

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

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

Bus	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)¶

Bus	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 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 lhe aplique 5 V.

PWM¶

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

Nota

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

O TIM4 é partilhado com pyb.Servo — instanciar um servo reconfigura o temporizador inteiro para operação a 50 Hz, por isso 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)

Buses emulados por software¶

machine.SoftI2C e machine.SoftSPI funcionam em qualquer GPIO se precisar de um bus adicional.

Sensor térmico (externo)¶

O firmware inclui o controlador fir — driver de sensor térmico (fir == infravermelho longínquo) para imagiadores 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 bus 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 controlador fir comunica com o sensor apenas via I²C 2 — ligue o módulo ao 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 de disparo único sem consumir um slot de temporizador por hardware. Passe -1 como id para usar um temporizador virtual (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 de tempo real¶

machine.RTC mantém a hora do relógio 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 suspensa. Uma vez iniciado, não pode ser parado nem reconfigurado — alimente-o periodicamente dentro do 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 execução¶

Janela do bootloader USB¶

Em cada ligação, a câmara executa um bootloader curto (alguns segundos) que permite ao OpenMV IDE atualizar o firmware sem que o utilizador tenha de entrar no modo DFU. Após o término da janela, o bootloader passa o controlo para boot.py e depois para main.py.

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

import machine

machine.bootloader()

Sistema de ficheiros e ordem de arranque¶

O firmware da H7 Plus 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 de leitura com mapeamento de memória em /rom, usado para distribuir grandes recursos de dados (p.ex., modelos de IA) que beneficiam do 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, caso contrário /flash. O interpretador executa então scripts a partir desse diretório:

boot.py é executado em cada reinício suave (arranque a frio, Ctrl‑D a partir do REPL, ou sempre que o script em execução termina).
main.py é executado apenas no arranque a frio, imediatamente após boot.py. Os reinícios suaves subsequentes voltam a executar boot.py mas vão diretamente para o REPL — para voltar a executar main.py tem de reiniciar 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 fornecido numa placa recentemente flasheada faz simplesmente piscar o canal azul do LED RGB de utilizador como sinal de vida (dois pulsos curtos, intervalo curto), para que possa verificar que o firmware arrancou corretamente sem nenhum anfitrião ligado.

O sys.path é expandido para incluir os três sistemas de ficheiros e os seus 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 via USB, o sistema de ficheiros de arranque (/sdcard se um cartão estiver presente, caso contrário /flash) também aparece como 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 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 em execução na OpenMV Cam não aparecerão enquanto o anfitrião não 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. Use o cartão SD para quaisquer dados que o script escreva, 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 — isto é um indicador de atividade controlado pelo firmware, não uma falha.

Tamanhos de armazenamento¶

A H7 Plus é fornecida com:

/flash — sistema de ficheiros FAT de 24 MB, leitura/escrita.
/rom — ROMFS de leitura apenas com mapeamento de memória de 8 MB, usado para distribuir scripts e modelos de ML que beneficiam do acesso mmap sem cópia.
/sdcard — tamanho completo do cartão microSD inserido (quando presente), leitura/escrita.

Indicador de falha grave¶

Se o LED RGB de utilizador estiver a ciclar rapidamente por todas as cores — suficientemente rápido para parecer um LED branco a piscar em vez de tonalidades distintas — o firmware sofreu uma falha grave irrecuperável. Reflashee o firmware para recuperar; se 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 versão H7 Plus.