OpenMV Cam H7¶

La OpenMV Cam H7 è una scheda di visione artificiale Cortex‑M7 costruita attorno allo STMicroelectronics STM32H743 a 480 MHz con 1 MB di SRAM interna, 2 MB di flash interna e un codec JPEG hardware. La scheda è disponibile in due revisioni del sensore — la H7 con l”OV7725 e la H7 R2 con l”ON Semi MT9M114 — ma firmware, pinout e API Python sono identici.

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

Caratteristiche principali¶

STMicroelectronics STM32H743 Cortex‑M7 a 480 MHz (1027 DMIPS).
Encoder/decoder JPEG hardware.
1 MB di SRAM interna — nessuna SDRAM esterna.
2 MB di flash interna (nessuna flash QSPI esterna).
Sensore OV7725 (oppure MT9M114 sulla H7 R2).
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 a bordo — fornisci una cella già carica oppure alimenta da VIN/USB).
10 pin di I/O, tolleranti a 5 V con uscita a 3,3 V, 25 mA per pin (120 mA totali sull’intero header), in grado di gestire interrupt. P6 non è tollerante a 5 V quando viene usato in modalità ADC o DAC.
LED RGB utente e due LED IR ad alta potenza da 850 nm per l’illuminazione attiva nella visione in condizioni di scarsa luminosità.

Nota

La H7 non ha un chip di gestione dell’alimentazione a bordo: non c’è caricabatterie, non c’è ADC per la tensione della batteria, non ci sono LED di carica / stato dell’alimentazione e non c’è un pulsante di accensione hardware. Collega una LiPo precaricata al connettore JST della batteria oppure alimenta la scheda da USB / VIN.

Pinout¶

Riferimento dei pin¶

Nome del 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	TIM4 CH3
RESET	collega a GND per resettare la scheda
SYN	pad di sincronizzazione frame — collegato solo al sensore della camera
BOOT0	collega 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 non è instradato all’MCU. Pilotalo o leggilo esternamente; non puoi commutarlo da MicroPython.

Pin di alimentazione¶

3.3V — linea regolata a 3,3 V. Fino a 250 mA disponibili per gli shield (meno se la scheda microSD è in uso). A differenza delle camere più recenti questo pin è bidirezionale — vedi l’avviso più sotto.
VIN — ingresso 3,6 – 5 V. Alimenta la scheda attraverso il regolatore a bordo.
GND — massa comune.

È presente anche un connettore LiPo da 3,7 V, ma la H7 non ha un caricabatterie — collega una cella precaricata, oppure fornisci VIN / USB.

Nota

Quando sono presenti sia USB sia VIN/LiPo, l’ingresso VIN/LiPo vince — il commutatore di alimentazione a bordo lo preferisce all’USB per alimentare la scheda.

Avvertimento

Sulla H7 il connettore della batteria e VIN sono collegati tra loro. Non collegare una LiPo e applicare VIN contemporaneamente — le due alimentazioni si contrasteranno a vicenda e possono danneggiare la batteria, la scheda o entrambe.

Avvertimento

Puoi alimentare la H7 fornendo 3,3 V direttamente sul pin 3.3V se non vuoi passare attraverso il regolatore a bordo. In tal caso, non applicare contemporaneamente anche VIN o l’alimentazione USB — pilotare a ritroso il regolatore mentre un’altra alimentazione è attiva può danneggiare e distruggere in modo permanente la camera.

Suggerimento

Usa lo stimatore di durata della batteria per modellare quanto a lungo la H7 funzionerà a batteria per un dato ciclo di lavoro attivo / deep-sleep.

Pin di recovery e debug¶

RESET — collega a GND per resettare la scheda. Rilasciandolo l’MCU si avvia normalmente.
BOOT0 — collega a 3,3 V mentre alimenti la scheda per entrare nel bootloader ROM dell’STM32 (modalità DFU). OpenMV IDE usa questa modalità per riprogrammare il bootloader a bordo.

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

Periferiche a bordo¶

LED¶

La H7 dispone di un singolo LED RGB utente più una coppia di LED IR ad alta potenza da 850 nm:

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 tramite il pin LED_IR. LED_IR è cablato attivo alto in hardware mentre il firmware tratta ogni altro LED a bordo come attivo basso, 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’OV7725 (o il MT9M114 sulla H7 R2) viene 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()

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.

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 a 5 V sul lato 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 fronte:

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) tramite 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 — tramite 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 a 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
P9	TIM4 CH3

Nota

TIM1 è riservato dal firmware per generare il pixel clock del sensore della camera, quindi i canali TIM1 fisicamente presenti 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/P9 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 ti serve 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 monotoni 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 pianifica callback periodiche 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 del periodo sono in millisecondi. Chiama deinit() per fermare e liberare lo slot.

Orologio in tempo reale¶

machine.RTC mantiene l’ora reale 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 né 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 di avvio e runtime¶

Finestra del bootloader USB¶

A ogni accensione la camera esegue un breve bootloader (qualche secondo) che consente 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 avvio¶

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

Flash interna — sempre montata in /flash. Contiene main.py e README.txt di default; creata al primo avvio in assoluto.
scheda microSD — se una scheda è inserita viene montata in /sdcard.
ROMFS — filesystem in sola lettura, mappato in memoria in /rom, usato per distribuire grandi asset di dati (ad esempio modelli IA) 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 (avvio a freddo, Ctrl‑D dal REPL, o ogni volta che lo script in esecuzione termina).
main.py viene eseguito solo all’avvio a freddo, immediatamente dopo boot.py. I soft reset successivi rieseguono boot.py ma passano direttamente al REPL — per rieseguire main.py devi resettare completamente la scheda.

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

Il main.py di default fornito su una scheda appena programmata si limita a far lampeggiare il canale blu del LED RGB utente come heartbeat (due brevi impulsi, breve pausa), così puoi capire che il firmware è stato avviato 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 (per esempio per eseguire il main.py in flash anche con una scheda presente), crea un file vuoto chiamato SKIPSD nella radice di /flash.

Quando è collegata via USB, il filesystem di avvio (/sdcard se una scheda è presente, altrimenti /flash) viene enumerato anche come unità di archiviazione di massa USB sull’host, permettendoti di modificare boot.py, main.py e qualsiasi altro file direttamente. Espelli l’unità prima di resettare la camera così l’host scarica le 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 compariranno finché l’host non rimonta l’unità. Se sia il sistema operativo sia la OpenMV Cam scrivono sullo stesso filesystem nello stesso momento, il sistema operativo vincerà e sovrascriverà 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 è fornita con:

/flash — filesystem FAT da 128 KB, in lettura/scrittura.
/rom — ROMFS da 128 KB in sola lettura mappato in memoria.
/sdcard — dimensione completa della scheda microSD inserita (quando presente), in lettura/scrittura.

Indicatore di hard‑fault¶

Se il LED RGB utente sta ciclando rapidamente attraverso tutti i colori — abbastanza velocemente da sembrare un LED bianco scintillante piuttosto che tonalità distinte — il firmware ha incontrato un hard fault irreversibile. Riprogramma il firmware per ripristinare; se la riprogrammazione 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 della H7.