OpenMV Cam H7

OpenMV Cam H7 är ett Cortex‑M7-kort för maskinseende byggt kring STMicroelectronics STM32H743 på 480 MHz med 1 MB internt SRAM, 2 MB internt flashminne och en JPEG-hårdvarukodek. Kortet levereras i två sensorrevisioner — H7 med OV7725 och H7 R2 med ON Semi MT9M114 — men den fasta programvaran, stiftkartan och Python-API:et är identiska.

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

Höjdpunkter

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

• JPEG-kodare/avkodare i hårdvara.

• 1 MB internt SRAM — inget externt SDRAM.

• 2 MB internt flashminne (inget externt QSPI-flashminne).

• OV7725-sensor (eller MT9M114 på H7 R2).

• 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 stiftlisten), avbrottskapabla. P6 är inte 5 V-tolerant när det används i ADC- eller DAC-läge.

• RGB-LED för användaren och två högeffekts-IR-LED på 850 nm för aktiv belysning vid seende i svagt ljus.

Anteckning

H7 har inget inbyggt strömhanteringschip: det finns ingen batteriladdare, ingen ADC för batterispänning, inga LED:ar för laddning / strömstatus och ingen hårdvaruströmknapp. Anslut ett förladdat LiPo-batteri till batteri-JST:et eller driv kortet från USB / VIN.

Stiftkarta

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	TIM4 CH3
RESET	dra till GND för att återställa kortet
SYN	bildrute‑synk-pad — kopplad endast till kamerasensorn
BOOT0	dra till 3,3 V vid påslag för DFU / ROM-startladdare
LED_RED	RGB-LED:ens röda kanal (aktiv låg)
LED_GREEN	RGB-LED:ens gröna kanal (aktiv låg)
LED_BLUE	RGB-LED:ens blå kanal (aktiv låg)
LED_IR	högeffekts-IR-LED:ar (båda kanalerna drivs tillsammans)

Anteckning

SYN-paden på stiftlisten är ansluten direkt till kamerasensorns trigger- / exponeringslinje — den dirigeras inte till MCU:n på H7. 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 har ingen batteriladdare — anslut en förladdad cell, eller mata VIN / USB i stället.

Anteckning

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

Varning

Batterikontakten och VIN är sammankopplade på H7. Anslut inte ett LiPo-batteri och mata VIN samtidigt — de två strömkällorna kommer att motverka varandra och kan skada batteriet, kortet, eller båda.

Varning

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

Tips

Använd batterilivslängdsuppskattaren för att modellera hur länge H7 kan köra på batteri för en given arbetscykel med aktivt / djupt sömnläge.

Återställnings- och felsökningsstift

• RESET — dra till GND för att återställa kortet. Att släppa det låter 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) bredvid GPIO-listen, kompatibel med ST‑LINK- och SEGGER J‑Link-adaptrar.

Inbyggd kringutrustning

LED:ar

H7 har en enda RGB-LED för användaren plus ett par högeffekts-IR-LED:ar på 850 nm:

• RGB-LED för användaren — mjukvarustyrbar, 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:ar — båda LED:arna 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:ar som aktiva låga, så använd low() / high() snarare än 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

OV7725 (eller MT9M114 på H7 R2) drivs genom modulen csi — kamerasensorer

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

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

microSD-kort

När ett kort är insatt 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 tryckta stiften. Utgångar är 3,3 V CMOS, 5 V-toleranta på ingångssidan och kan sänka/källa upp till 25 mA per stift (120 mA totalt över hela stiftlisten).

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 flankö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 mållägge (slavläge) 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 stiftet för användaren. 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
P9	TIM4 CH3

Anteckning

TIM1 är reserverad av den fasta programvaran för att generera kamerasensorns pixelklocka, så TIM1-kanalerna 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 omkonfigurerar hela timern för 50 Hz-drift, så blanda inte machine.PWM på P7/P8/P9 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)

Mjukvaru-bit‑bangade bussar

machine.SoftI2C och machine.SoftSPI fungerar på vilken 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 bildtagare:

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

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

Tidshantering

time

Modulen time 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årdvarutimerplats. Skicka -1 som id för att använda en virtuell (mjukvaru-) 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()

Start- och körtidsinformation

USB-startladdarfönster

Vid varje påslag 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 lämnar startladdaren över till boot.py och sedan main.py.

Ett körande skript kan återinträda i startladdaren på begäran genom att anropa machine.bootloader()

import machine

machine.bootloader()

Filsystem och startordning

H7-firmwaren monterar upp till tre filsystem vid start:

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

• microSD-kort — om ett kort är insatt 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 gynnas av nollkopieringsåtkomst. Monteras automatiskt av MicroPython vid uppstart, innan någon användar-Python körs.

Efter monteringen sätts arbetskatalogen till /sdcard när kortet är närvarande, 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:en, 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:en — 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 startkatalogen (/sdcard när kortet är monterat, annars /flash).

Standard-main.py som levereras på ett nyflashat kort blinkar bara den blå kanalen på RGB-LED:en för användaren som ett hjärtslag (två korta pulser, kort paus), så att du kan se att firmwaren startade rent utan någon värd 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 insatt SD-kort (till exempel för att köra main.py i flashminnet även med ett kort närvarande), skapa en tom fil med namnet SKIPSD i roten av /flash.

När den är ansluten över USB räknas även startfilsystemet (/sdcard om ett kort är närvarande, annars /flash) upp som en USB-masslagringsenhet på värden, vilket låter dig redigera boot.py, main.py och andra filer direkt. Mata ut enheten innan du återställer kameran så att värden spolar 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 visas förrän värden monterar om enheten. Om både operativsystemet och OpenMV Cam skriver till samma filsystem samtidigt vinner operativsystemet och skriver ö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 dessa filer från värden.

Anteckning

Den röda kanalen på RGB-LED:en för användaren kan kortvarigt lysa upp medan värden läser från eller skriver till USB-masslagringsenheten — detta är en firmware-driven aktivitetsindikator, inte ett fel.

Lagringsstorlekar

H7 levereras med:

• /flash — 128 KB FAT-filsystem, läs/skriv.

• /rom — 128 KB skrivskyddat minnesmappat ROMFS.

• /sdcard — full storlek på det microSD-kort som är insatt (när det är närvarande), läs/skriv.

Hårdfelsindikator

Om RGB-LED:en för användaren snabbt växlar genom alla färger — så snabbt att det tenderar att se ut som en glittrande 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.

Mjukvarubibliotek

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