OpenMV Cam H7 Plus

La OpenMV Cam H7 Plus abbina lo STMicroelectronics STM32H743 (Cortex‑M7 @ 480 MHz) a 32 MB di SDRAM esterna, 32 MB di flash QSPI, un codec JPEG hardware e il modulo camera OV5640 da 5MP su un supporto rimovibile. La memoria aggiuntiva è particolarmente adatta all’acquisizione ad alta risoluzione e a grandi buffer di immagini.

OpenMV Cam H7 Plus

Per il datasheet completo, foto e dimensioni consulta la pagina prodotto della OpenMV Cam H7 Plus.

Caratteristiche principali

  • STMicroelectronics STM32H743 Cortex‑M7 a 480 MHz (1027 DMIPS).

  • Encoder/decoder JPEG hardware.

  • 32 MB di SDRAM esterna (32‑bit @ 100 MHz, 400 MB/s) più 1 MB di SRAM interna.

  • 2 MB di flash interna + 32 MB di flash QSPI esterna (lettura ~100 MB/s).

  • Sensore rolling‑shutter OV5640 da 5MP.

  • USB full‑speed (12 Mb/s) — appare all’host come VCP + dispositivo di archiviazione di massa USB.

  • Slot microSD — SD fino a 2 GB, SDHC fino a 32 GB, SDXC fino a 2 TB.

  • Connettore per batteria LiPo (nessun caricabatterie integrato — fornire una cella carica oppure alimentare da VIN/USB).

  • 10 pin di I/O, tolleranti 5 V con uscita a 3,3 V, 25 mA per pin (120 mA totali sull’intero header), con capacità di interrupt. P6 non è tollerante 5 V quando usato in modalità ADC o DAC.

  • LED RGB utente e due LED IR a 850 nm ad alta potenza per l’illuminazione attiva nella visione in condizioni di scarsa luce.

Nota

La H7 Plus non ha un chip di gestione dell’alimentazione integrato: non ci sono caricabatterie, ADC per la tensione della batteria, LED di stato di carica/alimentazione, né pulsante di accensione hardware. Collega una LiPo pre‑caricata al connettore JST della batteria oppure alimenta la scheda da USB / VIN.

Pinout

Pinout della OpenMV Cam H7 Plus OV5640

Riferimento dei pin

Nome pin

Funzione

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 digitale

RESET

collegare a GND per resettare la scheda

SYN

pad di frame‑sync — cablato solo al sensore della camera

BOOT0

collegare a 3,3 V all’accensione per il bootloader DFU / ROM

LED_RED

canale rosso del LED RGB (attivo basso)

LED_GREEN

canale verde del LED RGB (attivo basso)

LED_BLUE

canale blu del LED RGB (attivo basso)

LED_IR

LED IR ad alta potenza (entrambi i canali pilotati insieme)

Nota

Il pad SYN sull’header è collegato direttamente alla linea di trigger / esposizione del sensore della camera — sulla H7 Plus non è instradato al MCU. Pilotalo o leggilo esternamente; non puoi commutarlo da MicroPython.

Pin di alimentazione

  • 3.3V — rail regolato a 3,3 V. Fino a 250 mA disponibili per le shield (meno se la scheda microSD è in uso). A differenza delle camere più recenti questo pin è bidirezionale — vedi l’avvertenza qui sotto.

  • VIN — ingresso 3,6 – 5 V. Alimenta la scheda attraverso il regolatore integrato.

  • GND — massa comune.

È presente anche un connettore per LiPo a 3,7 V, ma la H7 Plus non dispone di un caricabatterie — collega una cella pre‑caricata, oppure fornisci VIN / USB.

Nota

Quando sono presenti sia USB che VIN/LiPo, prevale l’ingresso VIN/LiPo — l’interruttore di alimentazione integrato lo preferisce all’USB per alimentare la scheda.

Avvertimento

Il connettore della batteria e VIN sono collegati insieme sulla H7 Plus. Non collegare una LiPo e applicare VIN contemporaneamente — le due alimentazioni si contrasterebbero a vicenda e potrebbero danneggiare la batteria, la scheda, o entrambe.

Avvertimento

Puoi alimentare la H7 Plus fornendo 3,3 V direttamente al pin 3.3V se non vuoi passare attraverso il regolatore integrato. In tal caso, non applicare contemporaneamente anche VIN o l’alimentazione USB — il back‑driving del regolatore mentre un’altra alimentazione è attiva può danneggiare in modo permanente e distruggere la camera.

Suggerimento

Usa lo stimatore della durata della batteria per modellare quanto a lungo la H7 Plus funzionerà a batteria per un dato duty cycle di attività / deep-sleep.

Pin di recupero e debug

  • RESET — collegare a GND per resettare la scheda. Rilasciandolo il MCU si avvia normalmente.

  • BOOT0 — collegare a 3,3 V durante l’alimentazione della scheda per entrare nel bootloader ROM dell’STM32 (modalità DFU). OpenMV IDE usa questa modalità per riflashare il bootloader integrato.

La scheda espone un header di debug SWD (RST / SWCLK / SWDIO / SWO) accanto all’header GPIO, compatibile con gli adattatori ST‑LINK e SEGGER J‑Link.

Nota

Il pin di trace SWO è condiviso con la linea di clock SPI dell’header della camera. SWO non può essere usato contemporaneamente a qualsiasi modulo camera che comunica con il MCU tramite SPI — ad esempio il FLIR® Lepton® Adapter Module — scegline uno o l’altro.

Periferiche integrate

LED

La H7 Plus ha un singolo LED RGB utente più una coppia di LED IR a 850 nm ad alta potenza:

  • LED RGB utente — controllabile via software, esposto come LED_RED, LED_GREEN e LED_BLUE

    from machine import LED

LED("LED_RED").on()
LED("LED_GREEN").on()
LED("LED_BLUE").on()

  • LED IR — entrambi i LED sono pilotati insieme attraverso il pin LED_IR. LED_IR è cablato in hardware come attivo alto mentre il firmware tratta tutti gli altri LED integrati come attivi bassi, quindi usa low() / high() invece di on() / off() (che invertirebbero la logica):

    from machine import LED

ir = LED("LED_IR")
ir.low()    # turn IR illumination ON
ir.high()   # turn IR illumination OFF

Sensore della camera

L’OV5640 è pilotato attraverso il modulo csi — sensori camera

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

L’OV5640 dispone di un compressore JPEG integrato. Imposta csi.CSI.pixformat su csi.JPEG e il sensore consegna i frame compressi direttamente alla camera tramite il bus della camera, il che rende pratiche le acquisizioni ad alta risoluzione: csi.HD (1280×720), csi.FHD (1920×1080) e l’intero da 5MP csi.WQXGA2 (2592×1944) vengono tutti trasmessi come JPEG. Regola la compressione con csi.CSI.quality (0-100, più alto = frame più grandi, più dettaglio):

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

Il sensore è montato su un modulo rimovibile — sostituiscilo con uno qualsiasi degli altri moduli camera OpenMV (global shutter, termico, risoluzione più alta, ecc.) senza modificare il resto della scheda.

Machine learning

ml — Machine Learning esegue modelli TFLite quantizzati sul Cortex‑M7 con kernel CMSIS‑NN — abbastanza veloce per detector compatti a pochi frame al secondo. I modelli sul filesystem di sola lettura /rom si caricano direttamente dalla flash senza copiarli in RAM. Ecco un detector BlazeFace 128×128 che sovrappone su ogni frame il volto rilevato e i suoi sei punti di riferimento:

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

scheda microSD

Quando una scheda è inserita viene montata automaticamente in /sdcard ed è utilizzabile attraverso il normale file system:

import os

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

Riferimento dei bus

GPIO

Usa machine.Pin per leggere o pilotare uno qualsiasi dei pin serigrafati. Le uscite sono CMOS a 3,3 V, tolleranti 5 V sul lato di ingresso, e possono assorbire/erogare fino a 25 mA per pin (120 mA totali sull’intero 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())

Qualsiasi pin di ingresso può anche generare un interrupt sulle transizioni di bordo:

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

Lo stesso hardware può anche essere usato in modalità target (slave) attraverso machine.I2CTarget per esporre una regione di memoria a un altro controller 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 è l’unico pin analogico utente. Può essere usato come ingresso ADC a 12 bit oppure come uscita DAC.

  • ADC — fondo scala a 3,3 V sul pin:

    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 — attraverso pyb.DAC. Il valore a 8 bit copre 0–3,3 V:

    from pyb import DAC

dac = DAC("P6")
voltage = 1.65
dac.write(int(voltage / 3.3 * 255))

In modalità ADC o DAC P6 è tollerante solo 3,3 V — non fornirgli 5 V.

PWM

Pin

Timer / canale

P4

TIM2 CH3

P5

TIM2 CH4

P6

TIM2 CH1

P7

TIM4 CH1

P8

TIM4 CH2

Nota

TIM1 è riservato dal firmware per generare il pixel clock del sensore della camera, quindi i canali di TIM1 che sono fisicamente su P0/P1/P2 non possono essere usati per il PWM utente senza compromettere la camera.

TIM4 è condiviso con pyb.Servo — istanziare un servo riconfigura l’intero timer per il funzionamento a 50 Hz, quindi non mescolare machine.PWM su P7/P8 con pyb.Servo nello stesso script.

Pilota uno qualsiasi di essi tramite machine.PWM

from machine import Pin, PWM

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

Bus software bit‑banged

machine.SoftI2C e machine.SoftSPI funzionano su qualsiasi GPIO se hai bisogno di un bus aggiuntivo.

Sensore termico (esterno)

Il firmware include il driver fir — driver del sensore termico (fir == far infrared) per imager termici cablati esternamente:

  • MLX90621 — array IR 16 × 4

  • MLX90640 — array IR 32 × 24

  • MLX90641 — array IR 16 × 12

  • AMG8833 — array IR 8 × 8

Collega il modulo al bus I²C della scheda e leggi i frame con 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())

Il driver fir comunica con il sensore solo tramite I²C 2 — collega il modulo a P4 (SCL) e P5 (SDA).

Temporizzazione

time

Il modulo time copre i ritardi bloccanti, i tick monotonici e la misurazione del tempo trascorso:

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)

Timer virtuali

machine.Timer programma callback periodici o one‑shot senza consumare uno slot di timer hardware. Passa -1 come id per usare un timer virtuale (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"))

I valori di periodo sono in millisecondi. Chiama deinit() per fermarlo e rilasciare lo slot.

Orologio in tempo reale

machine.RTC mantiene l’ora dell’orologio attraverso i reset:

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 resetta la scheda se l’applicazione si blocca. Una volta avviato non può essere fermato o riconfigurato — alimentalo periodicamente all’interno del tuo loop principale:

from machine import WDT

wdt = WDT(timeout=5_000)   # 5 second window
while True:
    # ...do work...
    wdt.feed()

Informazioni su boot e runtime

Finestra del bootloader USB

A ogni accensione la camera esegue un breve bootloader (alcuni secondi) che permette a OpenMV IDE di aggiornare il firmware senza che l’utente debba entrare in modalità DFU. Allo scadere della finestra il bootloader passa il controllo a boot.py e poi a main.py.

Uno script in esecuzione può rientrare nel bootloader su richiesta chiamando machine.bootloader()

import machine

machine.bootloader()

Filesystem e ordine di boot

Il firmware della H7 Plus monta fino a tre filesystem all’avvio:

  • Flash interna — sempre montata in /flash. Contiene main.py e README.txt per impostazione predefinita; creata al primissimo avvio.

  • scheda microSD — se una scheda è inserita viene montata in /sdcard.

  • ROMFS — filesystem di sola lettura, mappato in memoria, in /rom, usato per distribuire grandi asset di dati (ad es. modelli AI) che traggono vantaggio dall’accesso zero‑copy. Montato automaticamente da MicroPython all’avvio, prima che venga eseguito qualsiasi codice Python utente.

Dopo il montaggio, la directory di lavoro è impostata su /sdcard quando la scheda è presente, altrimenti su /flash. L’interprete esegue quindi gli script da quella directory:

  • boot.py viene eseguito a ogni soft reset (cold boot, Ctrl‑D dalla REPL, o ogni volta che lo script in esecuzione ritorna).

  • main.py viene eseguito solo al cold boot, immediatamente dopo boot.py. I soft reset successivi rieseguono boot.py ma passano direttamente alla REPL — per rieseguire main.py devi resettare completamente la scheda.

Posizionare un boot.py o un main.py sulla scheda SD sovrascrive la copia in flash senza modificarla — entrambi i file vengono cercati nella directory di boot (/sdcard quando la scheda è montata, altrimenti /flash).

Il main.py predefinito fornito su una scheda appena flashata fa semplicemente lampeggiare il canale blu del LED RGB utente come heartbeat (due brevi impulsi, breve pausa), così puoi capire che il firmware è partito correttamente senza alcun host collegato.

sys.path viene esteso per includere tutti e tre i filesystem e le loro sottodirectory lib/, così i moduli importabili possono risiedere in /flash/lib, /sdcard/lib o /rom/lib.

Per forzare il sistema a ignorare una scheda SD inserita (ad esempio per eseguire il main.py della flash anche con una scheda presente), crea un file vuoto chiamato SKIPSD nella radice di /flash.

Quando connessa via USB, il filesystem di boot (/sdcard se è presente una scheda, altrimenti /flash) viene enumerato anche come un’unità di archiviazione di massa USB sull’host, permettendoti di modificare direttamente boot.py, main.py e qualsiasi altro file. Espelli l’unità prima di resettare la camera così che l’host scarichi le sue scritture in cache.

Nota

Poiché il sistema operativo tratta l’unità come un dispositivo a blocchi passivo, i file creati o modificati dal codice in esecuzione sulla OpenMV Cam non appariranno finché l’host non rimonta l’unità. Se sia il sistema operativo sia la OpenMV Cam scrivono lo stesso filesystem contemporaneamente, vince il sistema operativo e sovrascrive le modifiche fatte dalla camera. Usa la scheda SD per qualsiasi dato che lo script riscrive, e rimonta prima di leggere quei file dall’host.

Nota

Il canale rosso del LED RGB utente può accendersi brevemente mentre l’host legge da o scrive sull’unità di archiviazione di massa USB — è un indicatore di attività pilotato dal firmware, non un guasto.

Dimensioni di archiviazione

La H7 Plus viene fornita con:

  • /flash — filesystem FAT da 24 MB, lettura/scrittura.

  • /rom — ROMFS di sola lettura mappato in memoria da 8 MB, usato per distribuire script e modelli ML che traggono vantaggio dall’accesso mmap zero-copy.

  • /sdcard — dimensione completa di qualsiasi scheda microSD inserita (quando presente), lettura/scrittura.

Indicatore di hard‑fault

Se il LED RGB utente cicla rapidamente attraverso tutti i colori — abbastanza velocemente da sembrare un LED bianco scintillante piuttosto che tonalità distinte — il firmware ha incontrato un hard fault irrecuperabile. Riflasha il firmware per recuperare; se il riflash non aiuta, la scheda potrebbe essere danneggiata fisicamente.

Librerie software

Consulta l”indice della libreria per l’elenco completo dei moduli — incluso quali sono esclusivi della build per la H7 Plus.