OpenMV Cam H7 Plus

OpenMV Cam H7 Plus kombinerar STMicroelectronics STM32H743 (Cortex‑M7 @ 480 MHz) med 32 MB externt SDRAM, 32 MB QSPI-flashminne, en JPEG-kodek i hårdvara och OV5640 5MP-kameramodulen på en löstagbar bärare. Det extra minnet lämpar sig väl för högupplöst infångning och stora bildbuffertar.

För fullständigt datablad, foton och mått, se produktsidan för OpenMV Cam H7 Plus.

Höjdpunkter

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

• JPEG-kodare/avkodare i hårdvara.

• 32 MB externt SDRAM (32‑bitars @ 100 MHz, 400 MB/s) plus 1 MB internt SRAM.

• 2 MB internt flashminne + 32 MB externt QSPI-flashminne (~100 MB/s läsning).

• OV5640 5MP rolling‑shutter-sensor.

• Full‑speed USB (12 Mb/s) — visas som VCP + USB-masslagring för värddatorn.

• microSD-uttag — SD upp till 2 GB, SDHC upp till 32 GB, SDXC upp till 2 TB.

• LiPo-batterikontakt (ingen inbyggd laddare — anslut en laddad cell eller driv från VIN/USB).

• 10 I/O-stift, 5 V-toleranta med 3,3 V-utgång, 25 mA per stift (120 mA totalt över listen), avbrottskapabla. P6 är inte 5 V-tolerant när det används i ADC- eller DAC-läge.

• Användar-RGB-LED och två högeffekts 850 nm IR-LED:er för aktiv belysning vid maskinseende i svagt ljus.

Anteckning

H7 Plus har inget inbyggt strömhanteringschip: det finns ingen batteriladdare, ingen ADC för batterispänning, inga ladd-/strömstatus-LED:er och ingen strömbrytare i hårdvara. Anslut ett förladdat LiPo till batteri-JST:en eller driv kortet från USB / VIN.

Stiftutgång

Stiftreferens

Stiftnamn	Funktion
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	digital I/O
RESET	dra till GND för att återställa kortet
SYN	bildsynkroniseringspad — kopplad endast till kamerasensorn
BOOT0	dra till 3,3 V vid uppstart för DFU / ROM-startladdare
LED_RED	RGB-LED röd kanal (aktiv låg)
LED_GREEN	RGB-LED grön kanal (aktiv låg)
LED_BLUE	RGB-LED blå kanal (aktiv låg)
LED_IR	högeffekts IR-LED:er (båda kanalerna drivs tillsammans)

Anteckning

SYN-paden på listen är direkt ansluten till kamerasensorns trigger-/exponeringslinje — den går inte vidare till MCU:n på H7 Plus. Driv eller läs den externt; du kan inte växla den från MicroPython.

Strömstift

• 3.3V — reglerad 3,3 V-skena. Upp till 250 mA tillgängligt för shields (mindre om microSD-kortet används). Till skillnad från de nyare kamerorna är detta stift dubbelriktat — se varningen nedan.

• VIN — 3,6 – 5 V ingång. Driver kortet genom den inbyggda regulatorn.

• GND — gemensam jord.

En 3,7 V LiPo-kontakt finns också, men H7 Plus har ingen batteriladdare — anslut en förladdad cell, eller mata VIN / USB istället.

Anteckning

När både USB och VIN/LiPo är anslutna vinner VIN/LiPo-ingången — den inbyggda strömbrytaren väljer den framför USB för att driva kortet.

Varning

Batterikontakten och VIN är sammankopplade på H7 Plus. Anslut inte ett LiPo och mata VIN samtidigt — de två matningarna kommer att motverka varandra och kan skada batteriet, kortet eller bådadera.

Varning

Du får driva H7 Plus genom att mata 3,3 V direkt till 3.3V-stiftet om du inte vill gå via den inbyggda regulatorn. I så fall, mata inte även VIN eller USB samtidigt — att backmata regulatorn medan en annan matning är aktiv kan permanent skada och förstöra kameran.

Tips

Använd batterilivslängdsberäknaren för att modellera hur länge H7 Plus kommer att köra på ett batteri för en given arbetscykel av aktivt läge / djupsömn.

Återställnings- och felsökningsstift

• RESET — dra till GND för att återställa kortet. När den släpps kan MCU:n starta upp normalt.

• BOOT0 — dra till 3,3 V medan kortet matas för att gå in i STM32 ROM-startladdaren (DFU-läge). OpenMV IDE använder detta läge för att flasha om den inbyggda startladdaren.

Kortet exponerar en SWD-felsökningslist (RST / SWCLK / SWDIO / SWO) bredvid GPIO-listen, kompatibel med ST‑LINK- och SEGGER J‑Link-adaptrar.

Anteckning

SWO-spårningsstiftet delas med kameralistens SPI-klockledning. SWO kan inte användas samtidigt som någon kameramodul som kommunicerar med MCU:n över SPI — till exempel FLIR® Lepton® Adapter Module — välj det ena eller det andra.

Inbyggd kringutrustning

LED:er

H7 Plus har en enda användar-RGB-LED plus ett par högeffekts 850 nm IR-LED:er:

• Användar-RGB-LED — programvarustyrbar, exponerad som LED_RED, LED_GREEN och LED_BLUE

  from machine import LED
  
  LED("LED_RED").on()
  LED("LED_GREEN").on()
  LED("LED_BLUE").on()
  

• IR-LED:er — båda LED:erna drivs tillsammans genom LED_IR-stiftet. LED_IR är kopplad aktiv hög i hårdvaran medan den fasta programvaran behandlar alla andra inbyggda LED:er som aktiv låg, så använd low() / high() istället för on() / off() (som skulle invertera betydelsen):

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

Kamerasensor

OV5640 drivs genom csi — kamerasensorer-modulen:

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

OV5640 har en inbyggd JPEG-kompressor. Sätt csi.CSI.pixformat till csi.JPEG så levererar sensorn komprimerade bildrutor direkt till kameran över kamerabussen, vilket gör högupplösta infångningar praktiska: csi.HD (1280×720), csi.FHD (1920×1080) och full 5MP csi.WQXGA2 (2592×1944) strömmar alla som JPEG. Justera kompressionen med csi.CSI.quality (0-100, högre = större bildrutor, mer detaljer):

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

Sensorn sitter på en löstagbar modul — byt ut den mot någon av de andra OpenMV-kameramodulerna (global shutter, termisk, högre upplösning osv.) utan att ändra resten av kortet.

Maskininlärning

ml — Maskininlärning kör kvantiserade TFLite-modeller på Cortex‑M7 med CMSIS‑NN-kärnor — snabbt nog för kompakta detektorer vid några bildrutor per sekund. Modeller på det skrivskyddade /rom-filsystemet laddas direkt från flashminnet utan kopiering till RAM. Här är en 128×128 BlazeFace-detektor som lägger det detekterade ansiktet och dess sex landmärken som överlägg på varje bildruta:

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

microSD-kort

När ett kort sätts i monteras det automatiskt på /sdcard och kan användas genom det vanliga filsystemet:

import os

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

Bussreferens

GPIO

Använd machine.Pin för att läsa eller driva något av de silkscreentryckta stiften. Utgångar är 3,3 V CMOS, 5 V-toleranta på ingångssidan, och kan sänka/leverera upp till 25 mA per stift (120 mA totalt över hela listen).

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

Vilket ingångsstift som helst kan också utlösa ett avbrott vid kantövergångar:

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

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

UART

Buss	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

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

Samma hårdvara kan också användas i target-läge (slav) genom machine.I2CTarget för att exponera ett minnesområde för en annan I²C-styrenhet:

from machine import I2CTarget

buf = bytearray(32)
target = I2CTarget(2, addr=0x42, mem=buf)

SPI

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

Buss	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 och DAC

P6 är det enda analoga användarstiftet. Det kan användas antingen som en 12‑bitars ADC-ingång eller en DAC-utgång.

• ADC — fullskala vid 3,3 V på stiftet:

  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 — genom pyb.DAC. Det 8‑bitars värdet täcker 0–3,3 V:

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

I ADC- eller DAC-läge är P6 endast 3,3 V-tolerant — mata det inte med 5 V.

PWM

Stift	Timer / kanal
P4	TIM2 CH3
P5	TIM2 CH4
P6	TIM2 CH1
P7	TIM4 CH1
P8	TIM4 CH2

Anteckning

TIM1 är reserverad av den fasta programvaran för att generera kamerasensorns pixelklocka, så de TIM1-kanaler som fysiskt finns på P0/P1/P2 kan inte användas för användar-PWM utan att kameran slutar fungera.

TIM4 delas med pyb.Servo — att instansiera en servo konfigurerar om hela timern för 50 Hz-drift, så blanda inte machine.PWM på P7/P8 med pyb.Servo i samma skript.

Driv vilken som helst av dem via machine.PWM

from machine import Pin, PWM

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

Programvarubaserade bit‑bangade bussar

machine.SoftI2C och machine.SoftSPI fungerar på vilket GPIO som helst om du behöver en extra buss.

Termisk sensor (extern)

Den fasta programvaran inkluderar drivrutinen fir — drivrutin för värmesensor (fir == far infrared) för externt kopplade termiska kameror:

• MLX90621 — 16 × 4 IR-array

• MLX90640 — 32 × 24 IR-array

• MLX90641 — 16 × 12 IR-array

• AMG8833 — 8 × 8 IR-array

Koppla modulen till kortets I²C-buss och läs bildrutor med 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())

Drivrutinen fir kommunicerar med sensorn endast över I²C 2 — koppla modulen till P4 (SCL) och P5 (SDA).

Tidshantering

tid

time-modulen täcker blockerande fördröjningar, monotona tick och mätning av förfluten tid:

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)

Virtuella timrar

machine.Timer schemalägger periodiska eller engångs-återanrop utan att förbruka en hårdvarutimer-plats. Skicka -1 som id för att använda en virtuell (programvaru-)timer:

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

Periodvärden anges i millisekunder. Anropa deinit() för att stoppa och frigöra platsen.

Realtidsklocka

machine.RTC håller väggklockstid över återställningar:

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

Vakthund

machine.WDT återställer kortet om applikationen hänger sig. När den väl startats kan den inte stoppas eller omkonfigureras — mata den periodiskt inuti din huvudloop:

from machine import WDT

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

Boot- och körtidsinformation

USB-startladdarfönster

Vid varje uppstart kör kameran en kort startladdare (några sekunder) som låter OpenMV IDE uppdatera den fasta programvaran utan att användaren behöver gå in i DFU-läge. När fönstret löper ut överlämnar startladdaren till boot.py och därefter main.py.

Ett körande skript kan vid behov återgå till startladdaren genom att anropa machine.bootloader()

import machine

machine.bootloader()

Filsystem och bootordning

Den fasta programvaran för H7 Plus monterar upp till tre filsystem vid boot:

• Internt flashminne — alltid monterat på /flash. Innehåller main.py och README.txt som standard; skapas vid allra första boot.

• microSD-kort — om ett kort sätts i monteras det på /sdcard.

• ROMFS — skrivskyddat, minnesmappat filsystem på /rom som används för att leverera stora datatillgångar (t.ex. AI-modeller) som drar nytta av åtkomst utan kopiering. Monteras automatiskt av MicroPython vid uppstart, innan någon användar-Python körs.

Efter monteringen sätts arbetskatalogen till /sdcard när kortet finns, annars /flash. Tolken kör sedan skript från den katalogen:

• boot.py körs vid varje mjuk återställning (kallstart, Ctrl‑D från REPL, eller närhelst det körande skriptet returnerar).

• main.py körs endast vid kallstart, omedelbart efter boot.py. Efterföljande mjuka återställningar kör om boot.py men hoppar direkt till REPL — för att köra om main.py måste du återställa kortet helt.

Att lägga en boot.py eller main.py på SD-kortet åsidosätter kopian i flashminnet utan att röra den — båda filerna slås upp i bootkatalogen (/sdcard när kortet är monterat, annars /flash).

Standard-main.py som levereras på ett nyflashat kort blinkar bara den blå kanalen på användar-RGB-LED:en som en hjärtslagsindikator (två korta pulser, kort paus), så du kan avgöra att den fasta programvaran startade rent utan någon värddator ansluten.

sys.path utökas till att inkludera alla tre filsystemen och deras lib/-underkataloger, så importerbara moduler kan ligga i /flash/lib, /sdcard/lib eller /rom/lib.

För att tvinga systemet att ignorera ett isatt SD-kort (till exempel för att köra main.py i flashminnet även med ett kort isatt), skapa en tom fil med namnet SKIPSD i roten av /flash.

När den är ansluten över USB enumereras även bootfilsystemet (/sdcard om ett kort finns, annars /flash) som en USB-masslagringsenhet på värddatorn, vilket låter dig redigera boot.py, main.py och alla andra filer direkt. Mata ut enheten innan du återställer kameran så att värddatorn tömmer sina cachade skrivningar.

Anteckning

Eftersom operativsystemet behandlar enheten som en passiv blockenhet kommer filer som skapas eller ändras av kod som körs på OpenMV Cam inte att synas förrän värddatorn monterar om enheten. Om både operativsystemet och OpenMV Cam skriver till samma filsystem samtidigt kommer operativsystemet att vinna och skriva över ändringar som gjorts av kameran. Använd SD-kortet för all data som skriptet skriver tillbaka, och montera om innan du läser de filerna från värddatorn.

Anteckning

Den röda kanalen på användar-RGB-LED:en kan kort tändas medan värddatorn läser från eller skriver till USB-masslagringsenheten — detta är en aktivitetsindikator driven av den fasta programvaran, inte ett fel.

Lagringsstorlekar

H7 Plus levereras med:

• /flash — 24 MB FAT-filsystem, läs/skriv.

• /rom — 8 MB skrivskyddat minnesmappat ROMFS, används för att leverera skript och ML-modeller som drar nytta av mmap-åtkomst utan kopiering.

• /sdcard — full storlek på vilket microSD-kort som än sätts i (när det finns), läs/skriv.

Hårdfels-indikator

Om användar-RGB-LED:en snabbt växlar genom alla färger — snabbt nog att det tenderar att se ut som en tindrande vit LED snarare än distinkta nyanser — har den fasta programvaran träffat ett oåterkalleligt hårdfel. Flasha om den fasta programvaran för att återhämta dig; om omflashning inte hjälper kan kortet vara fysiskt skadat.

Programvarubibliotek

Se biblioteksindexet för den fullständiga listan över moduler — inklusive vilka som är unika för H7 Plus-bygget.