OpenMV Cam H7 Plus

Az OpenMV Cam H7 Plus a STMicroelectronics STM32H743 (Cortex‑M7 @ 480 MHz) processzort párosítja 32 MB külső SDRAM-mal, 32 MB QSPI flash memóriával, hardveres JPEG kodekkel és az OV5640 5MP-es kameramodullal egy cserélhető hordozón. A többletmemória kiválóan alkalmas nagy felbontású felvételekhez és nagy méretű képpufferekhez.

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

Kiemelt jellemzők

• STMicroelectronics STM32H743 Cortex‑M7, 480 MHz-en (1027 DMIPS).

• Hardveres JPEG kódoló/dekódoló.

• 32 MB külső SDRAM (32 bit @ 100 MHz, 400 MB/s) plusz 1 MB belső SRAM.

• 2 MB belső flash memória + 32 MB külső QSPI flash memória (~100 MB/s olvasás).

• OV5640 5MP-es rolling‑shutter érzékelő.

• 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 beépített töltő — használj feltöltött cellát, vagy táplálj VIN/USB felől).

• 10 I/O láb, 5 V toleráns 3,3 V kimenettel, 25 mA lábanként (összesen 120 mA a teljes fejlécen), megszakítás-képes. A P6 nem 5 V toleráns ADC vagy DAC módban használva.

• 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ényviszonyok melletti látáshoz.

Megjegyzés

A H7 Plus nem rendelkezik beépített energiagazdálkodási chippel: nincs akkumulátortöltő, nincs akkufeszültség-ADC, nincsenek töltés-/tápállapot-jelző LED-ek, és nincs hardveres bekapcsológomb. Csatlakoztass egy előre feltöltött LiPo cellát a JST akkumulátor-csatlakozóhoz, vagy táplálj az USB / VIN felől.

Lábkiosztás

Lábkiosztás-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	digitális I/O
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 piros csatornája (aktív alacsony)
LED_GREEN	RGB LED zöld csatornája (aktív alacsony)
LED_BLUE	RGB LED kék csatornája (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ós vonalához csatlakozik — a H7 Plus esetében nem vezet az MCU-hoz. Vezéreld vagy olvasd ki külsőleg; MicroPythonból nem tudod átkapcsolni.

Tápfeszültség-lábak

• 3.3V — szabályozott 3,3 V-os sín. Legfeljebb 250 mA áll rendelkezésre a shieldek számára (kevesebb, ha a microSD kártya használatban van). Az újabb kamerákkal ellentétben ez a láb kétirányú — lásd az alábbi figyelmeztetést.

• VIN — 3,6 – 5 V bemenet. A kártyát a beépített szabályozón keresztül táplálja.

• GND — közös föld.

Egy 3,7 V-os LiPo csatlakozó is jelen van, de a H7 Plus nem rendelkezik akkumulátortöltővel — csatlakoztass egy előre feltöltött cellát, vagy táplálj inkább VIN / USB felől.

Megjegyzés

Ha az USB és a VIN/LiPo egyszerre van jelen, a VIN/LiPo bemenet nyer — a beépített tápkapcsoló ezt választja az USB helyett a kártya táplálásához.

Figyelem

A H7 Plus esetében az akkumulátor-csatlakozó és a VIN össze van kötve. Ne csatlakoztass LiPo-t és ne kapcsolj VIN-t egyszerre — a két tápforrás egymással fog harcolni, és kárt tehet az akkumulátorban, a kártyában, vagy mindkettőben.

Figyelem

A H7 Plus-t táplálhatod úgy, hogy 3,3 V-ot vezetsz közvetlenül a 3.3V lábra, ha nem akarsz a beépített szabályozón keresztül menni. Ebben az esetben ne kapcsolj egyszerre VIN-t vagy USB tápot is — a szabályozó visszafelé hajtása, miközben egy másik tápforrás aktív, tartósan károsíthatja és tönkreteheti a kamerát.

Javaslat

Használd az akkumulátor-élettartam becslőt annak modellezésére, hogy meddig fog működni a H7 Plus egy akkumulátorról adott aktív / mélyalvási kitöltési tényező mellett.

Helyreállító és hibakereső 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 bekapcsolása közben az STM32 ROM rendszerbetöltőjébe (DFU mód) lépéshez. Az OpenMV IDE ezt a módot használja a beépített rendszerbetöltő újraflasheléséhez.

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

Megjegyzés

Az SWO nyomkövető láb meg van osztva a kamera fejlécének SPI órajel-vonalával. Az SWO nem használható egyidejűleg semmilyen olyan kameramodullal, amely SPI-n keresztül kommunikál az MCU-val — például a FLIR® Lepton® Adapter Module — válaszd az egyiket vagy a másikat.

Beépített perifériák

LED-ek

A H7 Plus egyetlen felhasználói RGB LED-del, valamint egy pár nagy teljesítményű 850 nm-es IR LED-del rendelkezik:

• Felhasználói RGB LED — szoftveresen vezérelhető, a 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 beépített LED-et aktív alacsonyként kezel, ezért használd a low() / high() metódusokat a on() / off() helyett (amelyek invertálnák az értelmezést):

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

Kamera érzékelő

Az OV5640-et a csi — kameraérzékelők modulon keresztül vezéreljük:

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 OV5640 beépített JPEG tömörítővel rendelkezik. Állítsd a csi.CSI.pixformat értékét csi.JPEG-re, és az érzékelő tömörített képkockákat szállít közvetlenül a kamerának a kamerabuszon keresztül, ami praktikussá teszi a nagy felbontású felvételeket: a csi.HD (1280×720), a csi.FHD (1920×1080) és a teljes 5MP-es csi.WQXGA2 (2592×1944) mind JPEG-ként streamel. Hangold a tömörítést a csi.CSI.quality (0-100, magasabb = nagyobb képkockák, több részlet) értékével:

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

Az érzékelő egy cserélhető modulon ül — cseréld ki bármelyik másik OpenMV kameramodulra (global shutter, hőkamera, nagyobb felbontás stb.) anélkül, hogy a kártya többi részét megváltoztatnád.

Gépi tanulás

A ml — Gépi tanulás kvantált TFLite modelleket futtat a Cortex‑M7-en CMSIS‑NN kernelekkel — elég gyorsan kompakt detektorokhoz másodpercenként néhány képkocka mellett. A csak olvasható /rom fájlrendszeren lévő modellek közvetlenül a flash memóriából töltődnek be, RAM-ba másolás nélkül. Íme egy 128×128-as BlazeFace detektor, amely minden képkockán rávetíti az észlelt arcot és annak hat kulcspontját:

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 kártya

Ha 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 CMOS-ak, a bemeneti oldalon 5 V toleránsak, és lábanként legfeljebb 25 mA-t tudnak nyelni/szolgáltatni (összesen 120 mA a teljes fejlécen).

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 meg is szakítást tud kiváltani él-átmeneteknél:

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 tegyen elérhetővé egy másik I²C vezérlő számára:

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 0–3,3 V-ot fed 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

Megjegyzés

A TIM1 fenntartott a firmware által a kamera érzékelőjének képpont-órajelének előállításához, ezért a TIM1 csatornái, amelyek fizikailag a P0/P1/P2 lábakon vannak, nem használhatók felhasználói PWM-hez a kamera működésének megzavarása 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 átkonfigurálja 50 Hz-es működésre, ezért ne keverd a machine.PWM-et a P7/P8 lábakon a pyb.Servo osztállyal ugyanabban a szkriptben.

Bármelyiket vezéreld a machine.PWM segítségével:

from machine import Pin, PWM

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

Szoftveres bit‑bang buszok

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

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

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

• MLX90621 — 16 × 4 IR tömb

• MLX90640 — 32 × 24 IR tömb

• MLX90641 — 16 × 12 IR tömb

• AMG8833 — 8 × 8 IR tömb

Kösd be a modult a kártya I²C buszára, és olvasd be 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 buszon 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 ütéseket é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 foglalna el. 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ások között is megőrzi a faliórán mért időt:

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. Miután elindult, nem állítható le és nem konfigurálható újra — etesd 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 Plus firmware induláskor legfeljebb három fájlrendszert csatol:

• Belső flash memória — mindig a /flash helyre csatolva. Alapértelmezetten a main.py és README.txt fájlokat 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óriába leképezett fájlrendszer a /rom helyen, amelyet nagy méretű adat-erőforrások (pl. AI modellek) szállítására használnak, amelyek profitálnak a másolás nélküli hozzáférésből. A MicroPython automatikusan csatolja induláskor, mielőtt bármilyen felhasználói Python kód lefutna.

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 újraindításkor lefut (hidegindítás, Ctrl‑D a REPL-ből, vagy amikor 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 újraindítások újrafuttatják a boot.py-t, de egyből a REPL-be ejtenek — 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 memóriában lévő példányt anélkül, hogy hozzányúlna — 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 a felhasználói RGB LED kék csatornáját villogtatja szívverésként (két rövid villanás, rövid szünet), így anélkül is meg tudod állapítani, hogy a firmware tisztán elindult-e, hogy bármilyen gazdagép csatlakoztatva lenne.

A sys.path kibővül mindhárom fájlrendszerrel és azok lib/ alkönyvtáraival, így az importálható modulok lakhatnak a /flash/lib, /sdcard/lib vagy /rom/lib helyeken.

Hogy a rendszert egy behelyezett SD kártya figyelmen kívül hagyására kényszerítsd (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 megjelenik a gazdagépen, lehetővé téve a boot.py, main.py és bármilyen más fájl közvetlen szerkesztését. Vedd 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 az operációs rendszer és az OpenMV Cam egyszerre írja ugyanazt a fájlrendszert, az operációs rendszer nyer, és felülírja a kamera által végzett módosítá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 piros 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 tevékenységjelző, nem hiba.

Tárolóméretek

A H7 Plus a következőkkel érkezik:

• /flash — 24 MB FAT fájlrendszer, írható/olvasható.

• /rom — 8 MB csak olvasható, memóriába leképezett ROMFS, amelyet olyan szkriptek és ML modellek szállítására használnak, amelyek profitálnak a másolás nélküli mmap hozzáférésből.

• /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égigfut az összes színen — 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 faultba ütközött. Flasheld újra a firmware-t a helyreállításhoz; 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árindexet — beleértve azt is, hogy melyek egyediek a H7 Plus build-hez.