OpenMV Cam H7 Plus

OpenMV Cam H7 Plus łączy układ STMicroelectronics STM32H743 (Cortex‑M7 @ 480 MHz) z 32 MB zewnętrznej pamięci SDRAM, 32 MB pamięci flash QSPI, sprzętowym kodekiem JPEG oraz modułem kamery OV5640 5MP na wymiennym nośniku. Dodatkowa pamięć doskonale nadaje się do przechwytywania obrazu w wysokiej rozdzielczości i obsługi dużych buforów obrazu.

Pełną kartę katalogową, zdjęcia i wymiary znajdziesz na stronie produktu OpenMV Cam H7 Plus.

Najważniejsze cechy

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

• Sprzętowy enkoder/dekoder JPEG.

• 32 MB zewnętrznej pamięci SDRAM (32‑bit @ 100 MHz, 400 MB/s) oraz 1 MB wewnętrznej pamięci SRAM.

• 2 MB wewnętrznej pamięci flash + 32 MB zewnętrznej pamięci flash QSPI (~100 MB/s odczyt).

• Sensor OV5640 5MP z migawką kroczącą (rolling‑shutter).

• USB w trybie Full‑speed (12 Mb/s) — widoczny dla hosta jako VCP + pamięć masowa USB.

• Gniazdo microSD — SD do 2 GB, SDHC do 32 GB, SDXC do 2 TB.

• Złącze akumulatora LiPo (brak ładowarki na płytce — podłącz naładowane ogniwo lub zasilaj z VIN/USB).

• 10 pinów I/O, tolerujących 5 V z wyjściem 3,3 V, 25 mA na pin (120 mA łącznie na całym złączu), z obsługą przerwań. P6 nie toleruje 5 V w trybie ADC lub DAC.

• Użytkowa dioda RGB LED oraz dwie diody IR 850 nm o dużej mocy zapewniające aktywne oświetlenie podczas pracy przy słabym świetle.

Informacja

H7 Plus nie ma na płytce układu zarządzania zasilaniem: brak ładowarki akumulatora, brak ADC do pomiaru napięcia akumulatora, brak diod LED stanu ładowania / zasilania oraz brak sprzętowego przycisku zasilania. Podłącz wcześniej naładowane ogniwo LiPo do złącza JST akumulatora albo zasilaj płytkę z USB / VIN.

Rozkład wyprowadzeń

Wykaz pinów

Nazwa pinu	Funkcja
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	cyfrowe I/O
RESET	zewrzyj do GND, aby zresetować płytkę
SYN	pad synchronizacji ramki — podłączony wyłącznie do sensora kamery
BOOT0	zewrzyj do 3,3 V przy włączeniu zasilania, aby uruchomić tryb DFU / bootloader ROM
LED_RED	czerwony kanał diody RGB LED (aktywny stanem niskim)
LED_GREEN	zielony kanał diody RGB LED (aktywny stanem niskim)
LED_BLUE	niebieski kanał diody RGB LED (aktywny stanem niskim)
LED_IR	diody IR o dużej mocy (oba kanały sterowane razem)

Informacja

Pad SYN na złączu jest podłączony bezpośrednio do linii wyzwalania / ekspozycji sensora kamery — nie prowadzi on do MCU w H7 Plus. Steruj nim lub odczytuj go zewnętrznie; nie da się go przełączać z poziomu MicroPython.

Piny zasilania

• 3.3V — stabilizowana szyna 3,3 V. Do 250 mA dostępne dla nakładek (mniej, gdy używana jest karta microSD). W odróżnieniu od nowszych kamer ten pin jest dwukierunkowy — zobacz ostrzeżenie poniżej.

• VIN — wejście 3,6 – 5 V. Zasila płytkę przez wbudowany stabilizator.

• GND — wspólna masa.

Obecne jest również złącze LiPo 3,7 V, ale H7 Plus nie ma ładowarki akumulatora — podłącz wcześniej naładowane ogniwo lub zasilaj zamiast tego z VIN / USB.

Informacja

Gdy jednocześnie obecne są zasilanie USB oraz VIN/LiPo, wejście VIN/LiPo ma pierwszeństwo — wbudowany przełącznik zasilania wybiera je zamiast USB do zasilania płytki.

Ostrzeżenie

Złącze akumulatora i VIN są ze sobą połączone w H7 Plus. Nie podłączaj jednocześnie ogniwa LiPo i napięcia VIN — oba źródła będą ze sobą rywalizować i mogą uszkodzić akumulator, płytkę lub jedno i drugie.

Ostrzeżenie

Możesz zasilać H7 Plus, podając 3,3 V bezpośrednio na pin 3.3V, jeśli nie chcesz korzystać z wbudowanego stabilizatora. W takim przypadku nie podawaj jednocześnie zasilania VIN ani USB — wsteczne zasilanie stabilizatora, gdy aktywne jest inne źródło, może trwale uszkodzić i zniszczyć kamerę.

Wskazówka

Użyj kalkulatora czasu pracy na baterii, aby oszacować, jak długo H7 Plus będzie działać na baterii przy zadanym cyklu pracy aktywny / głęboki sen.

Piny odzyskiwania i debugowania

• RESET — zewrzyj do GND, aby zresetować płytkę. Zwolnienie pozwala MCU uruchomić się normalnie.

• BOOT0 — zewrzyj do 3,3 V podczas zasilania płytki, aby wejść do bootloadera ROM STM32 (tryb DFU). OpenMV IDE używa tego trybu do ponownego wgrania wbudowanego bootloadera.

Płytka udostępnia złącze debugowania SWD (RST / SWCLK / SWDIO / SWO) obok złącza GPIO, kompatybilne z adapterami ST‑LINK oraz SEGGER J‑Link.

Informacja

Pin śledzenia SWO jest współdzielony z linią zegara SPI złącza kamery. SWO nie może być używany jednocześnie z żadnym modułem kamery komunikującym się z MCU przez SPI — na przykład z modułem adaptera FLIR® Lepton® — wybierz jedno albo drugie.

Urządzenia peryferyjne na płytce

Diody LED

H7 Plus ma pojedynczą użytkową diodę RGB LED oraz parę diod IR 850 nm o dużej mocy:

• Użytkowa dioda RGB LED — sterowana programowo, udostępniona jako LED_RED, LED_GREEN i LED_BLUE

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

• Diody IR — obie diody sterowane są razem przez pin LED_IR. LED_IR jest w sprzęcie podłączony jako aktywny stanem wysokim, podczas gdy oprogramowanie układowe traktuje każdą inną diodę LED na płytce jako aktywną stanem niskim, dlatego używaj low() / high() zamiast on() / off() (które odwróciłyby logikę):

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

Sensor kamery

OV5640 jest sterowany przez moduł csi — sensory kamery

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 ma wbudowany kompresor JPEG. Ustaw csi.CSI.pixformat na csi.JPEG, a sensor będzie dostarczał skompresowane ramki prosto do kamery przez magistralę kamery, co czyni przechwytywanie w wysokiej rozdzielczości praktycznym: csi.HD (1280×720), csi.FHD (1920×1080) oraz pełne 5MP csi.WQXGA2 (2592×1944) — wszystkie strumieniowane jako JPEG. Dostrój kompresję za pomocą csi.CSI.quality (0-100, wyższa wartość = większe ramki, więcej szczegółów):

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

Sensor znajduje się na wymiennym module — wymień go na dowolny z pozostałych modułów kamery OpenMV (migawka globalna, termowizja, wyższa rozdzielczość itd.) bez zmiany reszty płytki.

Uczenie maszynowe

ml — Uczenie maszynowe uruchamia skwantyzowane modele TFLite na Cortex‑M7 z jądrami CMSIS‑NN — wystarczająco szybko dla kompaktowych detektorów przy kilku klatkach na sekundę. Modele w systemie plików tylko do odczytu /rom ładowane są bezpośrednio z pamięci flash bez kopiowania do RAM. Oto detektor BlazeFace 128×128 nakładający wykrytą twarz i jej sześć punktów charakterystycznych na każdą ramkę:

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

Karta microSD

Po włożeniu karta jest automatycznie montowana w /sdcard i dostępna przez standardowy system plików:

import os

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

Wykaz magistral

GPIO

Użyj machine.Pin, aby odczytać dowolny z opisanych na płytce pinów lub nim sterować. Wyjścia są w standardzie 3,3 V CMOS, tolerują 5 V po stronie wejścia i mogą przyjmować/dostarczać do 25 mA na pin (120 mA łącznie na całym złączu).

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

Dowolny pin wejściowy może również wyzwalać przerwanie przy zmianie zbocza:

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

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

UART

Magistrala	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

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

Ten sam sprzęt może być również używany w trybie celu (slave) przez machine.I2CTarget, aby udostępnić obszar pamięci innemu kontrolerowi I²C:

from machine import I2CTarget

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

SPI

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

Magistrala	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 i DAC

P6 to jedyny użytkowy pin analogowy. Może być używany jako wejście 12‑bitowego ADC albo jako wyjście DAC.

• ADC — pełna skala przy 3,3 V na pinie:

  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 — przez pyb.DAC. Wartość 8‑bitowa pokrywa zakres 0–3,3 V:

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

W trybie ADC lub DAC P6 toleruje tylko 3,3 V — nie podawaj na niego 5 V.

PWM

Pin	Licznik czasu / kanał
P4	TIM2 CH3
P5	TIM2 CH4
P6	TIM2 CH1
P7	TIM4 CH1
P8	TIM4 CH2

Informacja

TIM1 jest zarezerwowany przez oprogramowanie układowe do generowania zegara pikseli sensora kamery, dlatego kanały TIM1 fizycznie dostępne na P0/P1/P2 nie mogą być używane do użytkowego PWM bez uszkodzenia działania kamery.

TIM4 jest współdzielony z pyb.Servo — utworzenie obiektu serwa rekonfiguruje cały licznik czasu do pracy z częstotliwością 50 Hz, więc nie mieszaj machine.PWM na P7/P8 z pyb.Servo w tym samym skrypcie.

Steruj dowolnym z nich przez machine.PWM

from machine import Pin, PWM

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

Programowo emulowane magistrale (bit‑bang)

machine.SoftI2C oraz machine.SoftSPI działają na dowolnym GPIO, jeśli potrzebujesz dodatkowej magistrali.

Sensor termiczny (zewnętrzny)

Oprogramowanie układowe zawiera sterownik fir — sterownik sensora termicznego (fir == far infrared, daleka podczerwień) dla zewnętrznie podłączonych obrazowników termicznych:

• MLX90621 — matryca IR 16 × 4

• MLX90640 — matryca IR 32 × 24

• MLX90641 — matryca IR 16 × 12

• AMG8833 — matryca IR 8 × 8

Podłącz moduł do magistrali I²C płytki i odczytuj ramki za pomocą 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())

Sterownik fir komunikuje się z sensorem wyłącznie przez I²C 2 — podłącz moduł do P4 (SCL) i P5 (SDA).

Pomiar czasu

time

Moduł time obejmuje blokujące opóźnienia, monotoniczne tiki oraz pomiar upływającego czasu:

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)

Wirtualne liczniki czasu

machine.Timer planuje okresowe lub jednorazowe wywołania zwrotne bez zajmowania sprzętowego slotu licznika czasu. Przekaż -1 jako id, aby użyć wirtualnego (programowego) licznika czasu:

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

Wartości okresu podawane są w milisekundach. Wywołaj deinit(), aby zatrzymać i zwolnić slot.

Zegar czasu rzeczywistego

machine.RTC utrzymuje czas zegarowy pomiędzy resetami:

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 resetuje płytkę, jeśli aplikacja się zawiesi. Po uruchomieniu nie można go zatrzymać ani przekonfigurować — karm go okresowo wewnątrz swojej głównej pętli:

from machine import WDT

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

Informacje o rozruchu i czasie wykonania

Okno bootloadera USB

Przy każdym włączeniu zasilania kamera uruchamia krótki bootloader (kilka sekund), który pozwala OpenMV IDE zaktualizować oprogramowanie układowe bez konieczności ręcznego wchodzenia przez użytkownika w tryb DFU. Po wygaśnięciu tego okna bootloader przekazuje sterowanie do boot.py, a następnie do main.py.

Działający skrypt może na żądanie ponownie wejść do bootloadera, wywołując machine.bootloader()

import machine

machine.bootloader()

System plików i kolejność rozruchu

Oprogramowanie układowe H7 Plus montuje przy rozruchu maksymalnie trzy systemy plików:

• Wewnętrzna pamięć flash — zawsze montowana w /flash. Domyślnie przechowuje main.py i README.txt; tworzona przy pierwszym rozruchu.

• Karta microSD — jeśli karta jest włożona, montowana jest w /sdcard.

• ROMFS — system plików tylko do odczytu, mapowany w pamięci, dostępny w /rom, używany do dostarczania dużych zasobów danych (np. modeli AI) korzystających z dostępu bez kopiowania (zero‑copy). Montowany automatycznie przez MicroPython przy starcie, zanim uruchomiony zostanie jakikolwiek kod Python użytkownika.

Po zamontowaniu katalog roboczy ustawiany jest na /sdcard, gdy karta jest obecna, w przeciwnym razie na /flash. Interpreter uruchamia następnie skrypty z tego katalogu:

• boot.py jest wykonywany przy każdym miękkim resecie (zimny rozruch, Ctrl‑D z REPL lub gdy działający skrypt zakończy działanie).

• main.py jest wykonywany tylko przy zimnym rozruchu, bezpośrednio po boot.py. Kolejne miękkie resety ponownie uruchamiają boot.py, ale przechodzą prosto do REPL — aby ponownie uruchomić main.py, musisz w pełni zresetować płytkę.

Umieszczenie boot.py lub main.py na karcie SD nadpisuje kopię w pamięci flash bez jej naruszania — oba pliki są wyszukiwane w katalogu rozruchowym (/sdcard, gdy karta jest zamontowana, w przeciwnym razie /flash).

Domyślny main.py dostarczany na świeżo wgranej płytce po prostu miga niebieskim kanałem użytkowej diody RGB LED jako sygnał życia (dwa krótkie błyski, krótka przerwa), dzięki czemu można rozpoznać, że oprogramowanie układowe uruchomiło się poprawnie bez podłączonego hosta.

sys.path jest rozszerzany tak, aby obejmował wszystkie trzy systemy plików oraz ich podkatalogi lib/, dzięki czemu importowalne moduły mogą znajdować się w /flash/lib, /sdcard/lib lub /rom/lib.

Aby zmusić system do ignorowania włożonej karty SD (na przykład by uruchomić main.py z pamięci flash mimo obecności karty), utwórz pusty plik o nazwie SKIPSD w katalogu głównym /flash.

Po podłączeniu przez USB rozruchowy system plików (/sdcard, jeśli karta jest obecna, w przeciwnym razie /flash) jest również wykrywany na hoście jako napęd pamięci masowej USB, co pozwala edytować boot.py, main.py oraz dowolne inne pliki bezpośrednio. Wysuń napęd przed zresetowaniem kamery, aby host opróżnił buforowane zapisy.

Informacja

Ponieważ system operacyjny traktuje napęd jako pasywne urządzenie blokowe, pliki utworzone lub zmodyfikowane przez kod działający na OpenMV Cam nie pojawią się, dopóki host ponownie nie zamontuje napędu. Jeśli zarówno system operacyjny, jak i OpenMV Cam zapisują w tym samym systemie plików jednocześnie, system operacyjny wygra i nadpisze zmiany wprowadzone przez kamerę. Używaj karty SD do zapisu wszelkich danych przez skrypt i montuj ją ponownie przed odczytem tych plików z hosta.

Informacja

Czerwony kanał użytkowej diody RGB LED może na chwilę zaświecić się, gdy host odczytuje z napędu pamięci masowej USB lub na niego zapisuje — jest to sterowany przez oprogramowanie układowe wskaźnik aktywności, a nie usterka.

Rozmiary pamięci

H7 Plus dostarczany jest z:

• /flash — system plików FAT o rozmiarze 24 MB, do odczytu/zapisu.

• /rom — 8 MB ROMFS tylko do odczytu, mapowany w pamięci, używany do dostarczania skryptów i modeli ML korzystających z dostępu mmap bez kopiowania (zero‑copy).

• /sdcard — pełny rozmiar dowolnej włożonej karty microSD (gdy jest obecna), do odczytu/zapisu.

Wskaźnik twardej awarii (hard‑fault)

Jeśli użytkowa dioda RGB LED szybko przełącza się przez wszystkie kolory — na tyle szybko, że zwykle wygląda to jak migocząca biała dioda LED, a nie wyraźne barwy — oznacza to, że oprogramowanie układowe napotkało nieodwracalną twardą awarię. Wgraj ponownie oprogramowanie układowe, aby przywrócić działanie; jeśli ponowne wgranie nie pomoże, płytka może być fizycznie uszkodzona.

Biblioteki programowe

Pełną listę modułów — w tym informację, które z nich są unikalne dla wersji H7 Plus — znajdziesz w indeksie biblioteki.