OpenMV Cam H7¶

Az OpenMV Cam H7 egy Cortex‑M7 alapú gépi látás kártya, amely az STMicroelectronics STM32H743 köré épül, 480 MHz‑en, 1 MB belső SRAM‑mal, 2 MB belső flash memóriával és hardveres JPEG codec‑kel. A kártya két érzékelő‑változatban kapható — a H7 az OV7725‑tel, a H7 R2 pedig az ON Semi MT9M114‑gyel —, de a firmware, a kiosztás és a Python API mindkettőnél azonos.

A teljes adatlapért, fényképekért és méretekért lásd az OpenMV Cam H7 termékoldalt.

Kiemelt jellemzők¶

STMicroelectronics STM32H743 Cortex‑M7 480 MHz‑en (1027 DMIPS).
Hardveres JPEG kódoló/dekódoló.
1 MB belső SRAM — nincs külső SDRAM.
2 MB belső flash memória (nincs külső QSPI flash memória).
OV7725 érzékelő (vagy MT9M114 a H7 R2‑n).
Full‑speed USB (12 Mb/s) — a gazdagép felé VCP + USB tömegtárolóként jelenik meg.
microSD foglalat — SD legfeljebb 2 GB, SDHC legfeljebb 32 GB, SDXC legfeljebb 2 TB.
LiPo akkumulátor‑csatlakozó (nincs fedélzeti töltő — használj feltöltött cellát, vagy táplálj a VIN/USB felől).
10 I/O láb, 5 V‑toleráns 3,3 V‑os kimenettel, lábanként 25 mA (a fejlécen összesen 120 mA), megszakítás‑képes. A P6 nem 5 V‑toleráns, ha ADC vagy DAC módban használod.
Felhasználói RGB LED és két nagy teljesítményű 850 nm‑es IR LED az aktív megvilágításhoz gyenge fényű látási feladatoknál.

Megjegyzés

A H7‑nek nincs fedélzeti energiagazdálkodási chipje: nincs akkumulátortöltő, nincs akkumulátorfeszültség‑ADC, nincs töltés‑/tápállapot‑LED és nincs hardveres bekapcsológomb. Csatlakoztass egy előre feltöltött LiPo cellát az akkumulátor JST‑hez, vagy táplálj a kártyát USB / VIN felől.

Kiosztás¶

Láb‑referencia¶

Láb neve	Funkció
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	húzd GND‑re a kártya újraindításához
SYN	képkocka‑szinkron pad — csak a kamera érzékelőjéhez van bekötve
BOOT0	húzd 3,3 V‑ra bekapcsoláskor a DFU / ROM rendszerbetöltőhöz
LED_RED	RGB LED vörös csatorna (aktív alacsony)
LED_GREEN	RGB LED zöld csatorna (aktív alacsony)
LED_BLUE	RGB LED kék csatorna (aktív alacsony)
LED_IR	nagy teljesítményű IR LED‑ek (mindkét csatorna együtt vezérelve)

Megjegyzés

A fejlécen lévő SYN pad közvetlenül a kamera érzékelőjének trigger / expozíció vonalához csatlakozik — a H7‑en nem vezet az MCU‑hoz. Vezéreld vagy olvasd kívülről; MicroPython‑ból nem kapcsolható.

Táplábak¶

3.3V — szabályozott 3,3 V‑os sín. Bővítőkártyák számára legfeljebb 250 mA érhető el (kevesebb, ha a microSD kártya használatban van). Az újabb kameráktól eltérően ez a láb kétirányú — lásd az alábbi figyelmeztetést.
VIN — 3,6 – 5 V bemenet. A fedélzeti szabályozón keresztül táplálja a kártyát.
GND — közös föld.

Egy 3,7 V‑os LiPo csatlakozó is jelen van, de a H7‑nek nincs akkumulátortöltője — csatlakoztass egy előre feltöltött cellát, vagy táplálj VIN / USB felől helyette.

Megjegyzés

Ha mind az USB, mind a VIN/LiPo jelen van, a VIN/LiPo bemenet nyer — a fedélzeti tápkapcsoló ezt választja az USB helyett a kártya táplálásához.

Figyelem

Az akkumulátor‑csatlakozó és a VIN össze van kötve a H7‑en. Ne csatlakoztass LiPo‑t és kapcsolj VIN‑t egyszerre — a két táp egymással szemben dolgozik, és tönkreteheti az akkumulátort, a kártyát vagy mindkettőt.

Figyelem

Táplálhatod a H7‑et úgy is, hogy közvetlenül 3,3 V‑ot vezetsz a 3.3V lábra, ha nem akarsz a fedélzeti szabályozón keresztülmenni. Ebben az esetben ne kapcsolj egyidejűleg VIN‑t vagy USB tápot is — a szabályozó visszahajtása egy másik aktív táp mellett tartósan károsíthatja és tönkreteheti a kamerát.

Javaslat

Használd az akkumulátor‑élettartam becslőt annak modellezéséhez, hogy a H7 mennyi ideig fog futni egy akkumulátorról adott aktív / mélyalvás kitöltési tényező mellett.

Helyreállítási és hibakeresési lábak¶

RESET — húzd GND‑re a kártya újraindításához. Elengedve az MCU normálisan elindul.
BOOT0 — húzd 3,3 V‑ra a kártya táplálása közben az STM32 ROM rendszerbetöltőbe (DFU mód) való belépéshez. Az OpenMV IDE ezt a módot használja a fedélzeti rendszerbetöltő újraflashelésére.

A kártya egy SWD hibakeresési fejlécet (RST / SWCLK / SWDIO) tesz elérhetővé a GPIO fejléc mellett, amely kompatibilis az ST‑LINK és SEGGER J‑Link adapterekkel.

Fedélzeti perifériák¶

LED‑ek¶

A H7‑nek egyetlen felhasználói RGB LED‑je van, plusz egy pár nagy teljesítményű 850 nm‑es IR LED:

Felhasználói RGB LED — szoftveresen vezérelhető, LED_RED, LED_GREEN és LED_BLUE néven elérhető:
```
from machine import LED

LED("LED_RED").on()
LED("LED_GREEN").on()
LED("LED_BLUE").on()
```
IR LED‑ek — mindkét LED együtt van vezérelve a LED_IR lábon keresztül. A LED_IR hardveresen aktív magas bekötésű, miközben a firmware minden más fedélzeti LED‑et aktív alacsonyként kezel, ezért a low() / high() metódusokat használd a on() / off() helyett (amelyek megfordítanák az értelmét):
```
from machine import LED

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

Kamera érzékelő¶

Az OV7725 (vagy a H7 R2‑n az MT9M114) az csi — kameraérzékelők modulon keresztül van vezérelve:

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

Az érzékelő egy cserélhető modulon ül — cseréld ki bármelyik másik OpenMV kameramodulra (globális zár, hőkamera, magasabb felbontás stb.) a kártya többi részének megváltoztatása nélkül.

microSD kártya¶

Amikor egy kártya be van helyezve, automatikusan a /sdcard helyre csatolódik, és a szokásos fájlrendszeren keresztül használható:

import os

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

Busz‑referencia¶

GPIO¶

Használd a machine.Pin osztályt bármelyik szitanyomott láb olvasásához vagy vezérléséhez. A kimenetek 3,3 V‑os CMOS‑ok, a bemeneti oldalon 5 V‑toleránsak, és lábanként legfeljebb 25 mA‑t tudnak nyelni/szolgáltatni (a teljes fejlécen összesen 120 mA).

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

Bármelyik bemeneti láb megszakítást is kiválthat élátmenetekre:

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

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

UART¶

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

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

Ugyanaz a hardver cél (slave) módban is használható a machine.I2CTarget segítségével, hogy egy memóriaterületet egy másik I²C vezérlő számára tegyen elérhetővé:

from machine import I2CTarget

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

SPI¶

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

Busz	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 és DAC¶

A P6 az egyetlen felhasználói analóg láb. Használható akár 12‑bites ADC bemenetként, akár DAC kimenetként.

ADC — teljes skála 3,3 V‑on a lábon:

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 — a pyb.DAC osztályon keresztül. A 8‑bites érték a 0–3,3 V tartományt fedi le:

from pyb import DAC

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

ADC vagy DAC módban a P6 csak 3,3 V‑toleráns — ne tápláld 5 V‑tal.

PWM¶

Láb	Időzítő / csatorna
P4	TIM2 CH3
P5	TIM2 CH4
P6	TIM2 CH1
P7	TIM4 CH1
P8	TIM4 CH2
P9	TIM4 CH3

Megjegyzés

A TIM1‑et a firmware fenntartja a kamera érzékelő képpontórájának előállításához, ezért a P0/P1/P2 lábakon fizikailag jelen lévő TIM1 csatornák nem használhatók felhasználói PWM‑hez a kamera működésének megsértése nélkül.

A TIM4 meg van osztva a pyb.Servo osztállyal — egy szervó példányosítása az egész időzítőt 50 Hz‑es működésre konfigurálja át, ezért ne keverd a machine.PWM‑et a P7/P8/P9 lábakon a pyb.Servo osztállyal ugyanabban a szkriptben.

Vezéreld bármelyiket a machine.PWM segítségével:

from machine import Pin, PWM

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

Szoftveres bit‑banged buszok¶

A machine.SoftI2C és a machine.SoftSPI bármelyik GPIO‑n működik, ha plusz buszra van szükséged.

Hőkamera érzékelő (kártyán kívüli)¶

A firmware tartalmazza az fir — hőérzékelő-meghajtó (fir == far infrared, távoli infravörös) illesztőprogramot a külsőleg bekötött hőkamera‑érzékelőkhöz:

MLX90621 — 16 × 4 IR mátrix
MLX90640 — 32 × 24 IR mátrix
MLX90641 — 16 × 12 IR mátrix
AMG8833 — 8 × 8 IR mátrix

Kösd be a modult a kártya I²C buszára, és olvasd a képkockákat a fir.init() + fir.snapshot() segítségével:

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

A fir illesztőprogram csak az I²C 2‑n keresztül kommunikál az érzékelővel — kösd be a modult a P4 (SCL) és P5 (SDA) lábakra.

Időzítés¶

time¶

A time modul lefedi a blokkoló késleltetéseket, a monoton tick‑eket és az eltelt idő mérését:

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)

Virtuális időzítők¶

A machine.Timer periodikus vagy egyszeri visszahívásokat ütemez anélkül, hogy egy hardveres időzítő‑helyet felhasználna. Add át a -1 értéket id‑ként egy virtuális (szoftveres) időzítő használatához:

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

A periódusértékek ezredmásodpercben vannak megadva. Hívd meg a deinit() metódust a leállításhoz és a hely felszabadításához.

Valós idejű óra¶

A machine.RTC az újraindításokon átívelő óraidőt tartja nyilván:

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¶

A machine.WDT újraindítja a kártyát, ha az alkalmazás lefagy. Egyszer elindítva nem állítható le és nem konfigurálható újra — tápláld periodikusan a fő ciklusodon belül:

from machine import WDT

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

Indítási és futásidejű információk¶

USB rendszerbetöltő ablak¶

Minden bekapcsoláskor a kamera lefuttat egy rövid rendszerbetöltőt (néhány másodperc), amely lehetővé teszi az OpenMV IDE számára a firmware frissítését anélkül, hogy a felhasználónak DFU módba kellene lépnie. Az ablak lejárta után a rendszerbetöltő átadja a vezérlést a boot.py‑nak, majd a main.py‑nak.

Egy futó szkript igény szerint újra beléphet a rendszerbetöltőbe a machine.bootloader() meghívásával:

import machine

machine.bootloader()

Fájlrendszer és indítási sorrend¶

A H7 firmware indításkor legfeljebb három fájlrendszert csatol:

Belső flash memória — mindig a /flash helyre csatolva. Alapértelmezetten a main.py‑t és a README.txt‑t tartalmazza; a legelső indításkor jön létre.
microSD kártya — ha egy kártya be van helyezve, a /sdcard helyre csatolódik.
ROMFS — csak olvasható, memória‑leképezett fájlrendszer a /rom helyen, amelyet nagy adat‑erőforrások (pl. AI modellek) szállítására használnak, amelyek profitálnak a zéró‑másolatos hozzáférésből. A MicroPython automatikusan csatolja induláskor, minden felhasználói Python futtatása előtt.

A csatolás után a munkakönyvtár a /sdcard lesz, ha a kártya jelen van, egyébként a /flash. Az értelmező ezután abból a könyvtárból futtatja a szkripteket:

A boot.py minden szoftveres reset esetén lefut (hidegindítás, Ctrl‑D a REPL‑ből, vagy valahányszor a futó szkript visszatér).
A main.py csak hidegindításkor fut le, közvetlenül a boot.py után. A későbbi szoftveres reset‑ek újra lefuttatják a boot.py‑t, de egyenesen a REPL‑re ugranak — a main.py újrafuttatásához teljesen újra kell indítanod a kártyát.

Egy boot.py vagy main.py SD kártyára helyezése felülírja a flash‑ben lévő példányt anélkül, hogy hozzáérne — mindkét fájl az indítási könyvtárban kerül keresésre (/sdcard, ha a kártya csatolva van, egyébként /flash).

A frissen flashelt kártyán szállított alapértelmezett main.py csak villogtatja a felhasználói RGB LED kék csatornáját szívverésként (két rövid impulzus, rövid szünet), így gazdagép csatlakoztatása nélkül is meg tudod állapítani, hogy a firmware tisztán elindult.

A sys.path ki van bővítve mindhárom fájlrendszerrel és azok lib/ alkönyvtáraival, így az importálható modulok a /flash/lib, /sdcard/lib vagy /rom/lib helyen lakhatnak.

Ahhoz, hogy a rendszer figyelmen kívül hagyjon egy behelyezett SD kártyát (például a flash main.py futtatásához akkor is, ha kártya van jelen), hozz létre egy SKIPSD nevű üres fájlt a /flash gyökerében.

USB‑n keresztül csatlakoztatva az indítási fájlrendszer (/sdcard, ha kártya van jelen, egyébként /flash) USB tömegtároló meghajtóként is felsorolódik a gazdagépen, lehetővé téve a boot.py, a main.py és bármely más fájl közvetlen szerkesztését. Vesd ki a meghajtót a kamera újraindítása előtt, hogy a gazdagép kiürítse a gyorsítótárazott írásokat.

Megjegyzés

Mivel az operációs rendszer a meghajtót passzív blokkeszközként kezeli, az OpenMV Cam‑en futó kód által létrehozott vagy módosított fájlok nem jelennek meg, amíg a gazdagép újra nem csatolja a meghajtót. Ha egyszerre ír mind az operációs rendszer, mind az OpenMV Cam ugyanarra a fájlrendszerre, az operációs rendszer nyer, és felülírja a kamera által végzett változtatásokat. Használd az SD kártyát minden olyan adathoz, amelyet a szkript visszaír, és csatold újra, mielőtt ezeket a fájlokat a gazdagépről olvasnád.

Megjegyzés

A felhasználói RGB LED vörös csatornája röviden felvillanhat, miközben a gazdagép az USB tömegtároló meghajtóról olvas vagy arra ír — ez egy firmware által vezérelt aktivitásjelző, nem hiba.

Tárolóméretek¶

A H7 a következőkkel kerül szállításra:

/flash — 128 KB FAT fájlrendszer, írható/olvasható.
/rom — 128 KB csak olvasható, memória‑leképezett ROMFS.
/sdcard — a behelyezett microSD kártya teljes mérete (ha jelen van), írható/olvasható.

Hard‑fault jelző¶

Ha a felhasználói RGB LED gyorsan végigjárja az összes színt — elég gyorsan ahhoz, hogy inkább csillogó fehér LED‑nek tűnjön, mint különálló árnyalatoknak —, a firmware helyrehozhatatlan hard fault‑ba ütközött. A helyreállításhoz flasheld újra a firmware‑t; ha az újraflashelés nem segít, a kártya fizikailag sérült lehet.

Szoftverkönyvtárak¶

A modulok teljes listájáért lásd a könyvtár‑indexet — beleértve azt is, hogy melyek egyediek a H7 build‑hez.