OpenMV Cam H7 Plus

OpenMV Cam H7 Plus combină procesorul STMicroelectronics STM32H743 (Cortex‑M7 @ 480 MHz) cu 32 MB de SDRAM extern, 32 MB de memorie flash QSPI, un codec JPEG hardware și modulul de cameră OV5640 de 5MP montat pe un suport detașabil. Memoria suplimentară este potrivită pentru capturi la rezoluție înaltă și tampoane de imagine mari.

OpenMV Cam H7 Plus

Pentru fișa tehnică completă, fotografii și dimensiuni, consultați pagina de produs OpenMV Cam H7 Plus.

Puncte forte

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

  • Codec JPEG hardware (encoder/decoder).

  • 32 MB SDRAM extern (32 de biți @ 100 MHz, 400 MB/s) plus 1 MB SRAM intern.

  • 2 MB memorie flash internă + 32 MB memorie flash QSPI externă (citire ~100 MB/s).

  • Senzor OV5640 de 5MP cu rolling‑shutter.

  • USB full‑speed (12 Mb/s) — apare ca VCP + dispozitiv de stocare în masă USB pentru gazdă.

  • Soclu microSD — SD până la 2 GB, SDHC până la 32 GB, SDXC până la 2 TB.

  • Conector pentru baterie LiPo (fără încărcător integrat — alimentați cu o celulă încărcată sau de la VIN/USB).

  • 10 pini de I/O, tolerante la 5 V cu ieșire de 3,3 V, 25 mA per pin (120 mA în total pe întreg conectorul), capabile de întrerupere. P6 nu este tolerant la 5 V când este folosit în mod ADC sau DAC.

  • LED RGB pentru utilizator și două LED-uri IR de mare putere la 850 nm pentru iluminare activă în viziune cu lumină scăzută.

Notă

H7 Plus nu are cip de gestionare a alimentării integrat: nu există încărcător de baterie, ADC pentru tensiunea bateriei, LED-uri de stare a încărcării/alimentării și nici buton hardware de alimentare. Conectați o baterie LiPo deja încărcată la conectorul JST sau alimentați placa de la USB / VIN.

Schema pinilor

Schema pinilor OpenMV Cam H7 Plus OV5640

Referință pini

Numele pinului

Funcție

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

I/O digital

RESET

conectați la GND pentru a reseta placa

SYN

pad de sincronizare a cadrelor — conectat doar la senzorul camerei

BOOT0

conectați la 3,3 V la pornire pentru DFU / bootloader ROM

LED_RED

canalul roșu al LED-ului RGB (activ pe nivel jos)

LED_GREEN

canalul verde al LED-ului RGB (activ pe nivel jos)

LED_BLUE

canalul albastru al LED-ului RGB (activ pe nivel jos)

LED_IR

LED-uri IR de mare putere (ambele canale sunt comandate împreună)

Notă

Pad-ul SYN de pe conector este conectat direct la linia de declanșare / expunere a senzorului camerei — pe H7 Plus nu ajunge la MCU. Comandați-l sau citiți-l extern; nu îl puteți comuta din MicroPython.

Pini de alimentare

  • 3.3V — linia reglată de 3,3 V. Până la 250 mA disponibili pentru shield-uri (mai puțin dacă se folosește cardul microSD). Spre deosebire de camerele mai noi, acest pin este bidirecțional — vedeți avertismentul de mai jos.

  • VIN — intrare de 3,6 – 5 V. Alimentează placa prin regulatorul integrat.

  • GND — masă comună.

Există și un conector LiPo de 3,7 V, dar H7 Plus nu are încărcător de baterie — conectați o celulă deja încărcată sau alimentați de la VIN / USB.

Notă

Când sunt prezente atât USB, cât și VIN/LiPo, intrarea VIN/LiPo are prioritate — comutatorul de alimentare integrat o alege în locul USB pentru a alimenta placa.

Atenționare

Conectorul bateriei și VIN sunt legate împreună pe H7 Plus. Nu conectați o baterie LiPo și nu aplicați VIN în același timp — cele două surse vor intra în conflict și pot deteriora bateria, placa sau ambele.

Atenționare

Puteți alimenta H7 Plus furnizând 3,3 V direct la pinul 3.3V dacă nu doriți să treceți prin regulatorul integrat. În acest caz, nu aplicați simultan și VIN sau alimentare USB — comanda inversă a regulatorului în timp ce o altă sursă este activă poate deteriora permanent și distruge camera.

Sfat

Folosiți estimatorul de durată a bateriei pentru a modela cât timp va funcționa H7 Plus pe baterie pentru un anumit ciclu de funcționare activ / somn profund.

Pini de recuperare și depanare

  • RESET — conectați la GND pentru a reseta placa. Eliberarea îi permite MCU-ului să pornească normal.

  • BOOT0 — conectați la 3,3 V în timp ce alimentați placa pentru a intra în bootloader-ul ROM al STM32 (modul DFU). OpenMV IDE folosește acest mod pentru a reprograma bootloader-ul integrat.

Placa expune un conector de depanare SWD (RST / SWCLK / SWDIO / SWO) lângă conectorul GPIO, compatibil cu adaptoarele ST‑LINK și SEGGER J‑Link.

Notă

Pinul de trasare SWO este partajat cu linia de ceas SPI a conectorului camerei. SWO nu poate fi folosit în același timp cu niciun modul de cameră care comunică cu MCU-ul prin SPI — de exemplu modulul adaptor FLIR® Lepton® — alegeți unul sau altul.

Periferice integrate

LED-uri

H7 Plus are un singur LED RGB pentru utilizator plus o pereche de LED-uri IR de mare putere la 850 nm:

  • LED RGB pentru utilizator — controlabil prin software, expus ca LED_RED, LED_GREEN și LED_BLUE

    from machine import LED

LED("LED_RED").on()
LED("LED_GREEN").on()
LED("LED_BLUE").on()

  • LED-uri IR — ambele LED-uri sunt comandate împreună prin pinul LED_IR. LED_IR este cablat activ pe nivel înalt în hardware, în timp ce firmware-ul tratează toate celelalte LED-uri integrate ca active pe nivel jos, așa că folosiți low() / high() în loc de on() / off() (care ar inversa logica):

    from machine import LED

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

Senzorul camerei

OV5640 este comandat prin modulul csi — senzori de cameră

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 are un compresor JPEG integrat. Setați csi.CSI.pixformat la csi.JPEG și senzorul furnizează cadre comprimate direct camerei prin magistrala camerei, ceea ce face practice capturile la rezoluție înaltă: csi.HD (1280×720), csi.FHD (1920×1080) și întregul format de 5MP csi.WQXGA2 (2592×1944) se transmit toate ca JPEG. Reglați compresia cu csi.CSI.quality (0-100, mai mare = cadre mai mari, mai multe detalii):

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

Senzorul se află pe un modul detașabil — înlocuiți-l cu oricare dintre celelalte module de cameră OpenMV (global shutter, termic, rezoluție mai mare etc.) fără a schimba restul plăcii.

Învățare automată

ml — Învățare automată rulează modele TFLite cuantizate pe Cortex‑M7 cu kernele CMSIS‑NN — suficient de rapid pentru detectoare compacte la câteva cadre pe secundă. Modelele de pe sistemul de fișiere read‑only /rom se încarcă direct din memoria flash fără a fi copiate în RAM. Iată un detector BlazeFace de 128×128 care suprapune pe fiecare cadru fața detectată și cele șase repere ale sale:

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

card microSD

Când este introdus un card, acesta este montat automat la /sdcard și este utilizabil prin sistemul de fișiere obișnuit:

import os

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

Referință magistrale

GPIO

Folosiți machine.Pin pentru a citi sau comanda oricare dintre pinii marcați pe serigrafie. Ieșirile sunt CMOS de 3,3 V, tolerante la 5 V pe partea de intrare și pot absorbi/furniza până la 25 mA per pin (120 mA în total pe întreg conectorul).

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

Orice pin de intrare poate declanșa și o întrerupere la tranzițiile de muchie:

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

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

UART

Magistrală

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

Magistrală

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

Același hardware poate fi folosit și în mod target (slave) prin machine.I2CTarget pentru a expune o regiune de memorie unui alt controler I²C:

from machine import I2CTarget

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

SPI

Magistrală

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)

Magistrală

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 este singurul pin analogic pentru utilizator. Poate fi folosit fie ca intrare ADC pe 12 biți, fie ca ieșire DAC.

  • ADC — scală completă la 3,3 V la pin:

    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 — prin pyb.DAC. Valoarea pe 8 biți acoperă 0–3,3 V:

    from pyb import DAC

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

În mod ADC sau DAC, P6 este tolerant doar la 3,3 V — nu îi furnizați 5 V.

PWM

Pin

Temporizator / canal

P4

TIM2 CH3

P5

TIM2 CH4

P6

TIM2 CH1

P7

TIM4 CH1

P8

TIM4 CH2

Notă

TIM1 este rezervat de firmware pentru a genera ceasul de pixeli al senzorului camerei, așa că canalele TIM1 care sunt fizic pe P0/P1/P2 nu pot fi folosite pentru PWM de către utilizator fără a întrerupe funcționarea camerei.

TIM4 este partajat cu pyb.Servo — instanțierea unui servo reconfigurează întregul temporizator pentru funcționare la 50 Hz, așa că nu amestecați machine.PWM pe P7/P8 cu pyb.Servo în același script.

Comandați oricare dintre ele prin machine.PWM

from machine import Pin, PWM

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

Magistrale software bit‑banged

machine.SoftI2C și machine.SoftSPI funcționează pe orice GPIO dacă aveți nevoie de o magistrală suplimentară.

Senzor termic (extern)

Firmware-ul include driverul fir — driver pentru senzori termici (fir == far infrared) pentru camere termice cablate extern:

  • MLX90621 — matrice IR de 16 × 4

  • MLX90640 — matrice IR de 32 × 24

  • MLX90641 — matrice IR de 16 × 12

  • AMG8833 — matrice IR de 8 × 8

Conectați modulul la magistrala I²C a plăcii și citiți cadre cu 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())

Driverul fir comunică cu senzorul numai prin I²C 2 — conectați modulul la P4 (SCL) și P5 (SDA).

Temporizare

time

Modulul time acoperă întârzierile blocante, ticuri monotone și măsurarea timpului scurs:

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)

Temporizatoare virtuale

machine.Timer programează funcții de retroapelare (callback) periodice sau unice fără a consuma un slot de temporizator hardware. Treceți -1 ca id pentru a folosi un temporizator virtual (software):

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

Valorile perioadei sunt în milisecunde. Apelați deinit() pentru a opri și a elibera slotul.

Ceas în timp real

machine.RTC păstrează ora reală între resetări:

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 resetează placa dacă aplicația se blochează. Odată pornit, nu poate fi oprit sau reconfigurat — alimentați-l periodic în interiorul buclei principale:

from machine import WDT

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

Informații despre pornire și execuție

Fereastra bootloader-ului USB

La fiecare pornire, camera rulează un scurt bootloader (câteva secunde) care permite OpenMV IDE să actualizeze firmware-ul fără ca utilizatorul să fie nevoit să intre în modul DFU. După expirarea ferestrei, bootloader-ul predă controlul către boot.py și apoi main.py.

Un script în execuție poate reintra în bootloader la cerere apelând machine.bootloader()

import machine

machine.bootloader()

Sistemul de fișiere și ordinea de pornire

Firmware-ul H7 Plus montează până la trei sisteme de fișiere la pornire:

  • Memoria flash internă — montată întotdeauna la /flash. Conține implicit main.py și README.txt; creată la prima pornire.

  • card microSD — dacă este introdus un card, acesta este montat la /sdcard.

  • ROMFS — sistem de fișiere read‑only, mapat în memorie, la /rom, folosit pentru a livra resurse de date mari (de exemplu, modele AI) care beneficiază de acces zero‑copy. Montat automat de MicroPython la pornire, înainte de rularea oricărui cod Python al utilizatorului.

După montare, directorul de lucru este setat la /sdcard când cardul este prezent, altfel la /flash. Interpretorul rulează apoi scripturile din acel director:

  • boot.py este executat la fiecare resetare soft (pornire la rece, Ctrl‑D din REPL sau ori de câte ori scriptul în execuție se încheie).

  • main.py este executat doar la pornirea la rece, imediat după boot.py. Resetările soft ulterioare reexecută boot.py, dar trec direct la REPL — pentru a reexecuta main.py trebuie să resetați complet placa.

Plasarea unui boot.py sau main.py pe cardul SD înlocuiește copia din memoria flash fără a o atinge — ambele fișiere sunt căutate în directorul de pornire (/sdcard când cardul este montat, altfel /flash).

Fișierul main.py implicit livrat pe o placă proaspăt programată doar clipește canalul albastru al LED-ului RGB pentru utilizator ca semnal de funcționare (două pulsuri scurte, pauză scurtă), astfel încât să puteți ști că firmware-ul a pornit corect fără ca vreo gazdă să fie conectată.

sys.path este extins pentru a include toate cele trei sisteme de fișiere și subdirectoarele lor lib/, astfel încât modulele importabile pot fi în /flash/lib, /sdcard/lib sau /rom/lib.

Pentru a forța sistemul să ignore un card SD introdus (de exemplu, pentru a rula main.py din memoria flash chiar și cu un card prezent), creați un fișier gol numit SKIPSD în rădăcina /flash.

Când este conectat prin USB, sistemul de fișiere de pornire (/sdcard dacă este prezent un card, altfel /flash) este enumerat și ca unitate de stocare în masă USB pe gazdă, permițându-vă să editați direct boot.py, main.py și orice alte fișiere. Ejectați unitatea înainte de a reseta camera, astfel încât gazda să golească scrierile din cache.

Notă

Deoarece sistemul de operare tratează unitatea ca un dispozitiv bloc pasiv, fișierele create sau modificate de codul care rulează pe OpenMV Cam nu vor apărea până când gazda nu remontează unitatea. Dacă atât sistemul de operare, cât și OpenMV Cam scriu pe același sistem de fișiere în același timp, sistemul de operare va câștiga și va suprascrie modificările făcute de cameră. Folosiți cardul SD pentru orice date pe care scriptul le scrie înapoi și remontați înainte de a citi acele fișiere de pe gazdă.

Notă

Canalul roșu al LED-ului RGB pentru utilizator se poate aprinde scurt în timp ce gazda citește de pe sau scrie pe unitatea de stocare în masă USB — acesta este un indicator de activitate generat de firmware, nu o defecțiune.

Dimensiunile de stocare

H7 Plus este livrat cu:

  • /flash — sistem de fișiere FAT de 24 MB, citire/scriere.

  • /rom — ROMFS read-only mapat în memorie de 8 MB, folosit pentru a livra scripturi și modele ML care beneficiază de acces mmap zero-copy.

  • /sdcard — dimensiunea completă a oricărui card microSD introdus (când este prezent), citire/scriere.

Indicator de eroare gravă (hard fault)

Dacă LED-ul RGB pentru utilizator parcurge rapid toate culorile — suficient de rapid încât tinde să arate ca un LED alb pâlpâind mai degrabă decât ca nuanțe distincte — firmware-ul a întâmpinat o eroare gravă nerecuperabilă. Reprogramați firmware-ul pentru a recupera; dacă reprogramarea nu ajută, placa poate fi deteriorată fizic.

Biblioteci software

Consultați indexul de biblioteci pentru lista completă de module — inclusiv care dintre ele sunt unice pentru versiunea H7 Plus.