OpenMV Cam H7¶

OpenMV Cam H7 este o placă de viziune artificială Cortex‑M7 construită în jurul microcontrolerului STMicroelectronics STM32H743 la 480 MHz, cu 1 MB de SRAM intern, 2 MB de memorie flash internă și un codec JPEG hardware. Placa este livrată în două revizii de senzor — versiunea H7 cu senzorul OV7725 și versiunea H7 R2 cu senzorul ON Semi MT9M114 — însă firmware-ul, configurația pinilor și API-ul Python sunt identice.

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

Puncte importante¶

STMicroelectronics STM32H743 Cortex‑M7 la 480 MHz (1027 DMIPS).
Codec JPEG hardware (encoder/decoder).
1 MB de SRAM intern — fără SDRAM extern.
2 MB de memorie flash internă (fără memorie flash QSPI externă).
Senzor OV7725 (sau MT9M114 pe versiunea H7 R2).
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 întregul conector), capabile de întrerupere. P6 nu este tolerant la 5 V atunci când este folosit în mod ADC sau DAC.
LED RGB de utilizator și două LED-uri IR de mare putere la 850 nm pentru iluminare activă în condiții de lumină slabă.

Notă

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

Configurația pinilor¶

Referință pini¶

Nume pin	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	TIM4 CH3
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 acționate împreună)

Notă

Pad-ul SYN de pe conector este conectat direct la linia de declanșare / expunere a senzorului camerei — pe versiunea H7 acesta nu este rutat către MCU. Acționați-l sau citiți-l extern; nu îl puteți comuta din MicroPython.

Pini de alimentare¶

3.3V — magistrala 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 — consultați avertismentul de mai jos.
VIN — intrare de 3,6 – 5 V. Alimentează placa prin regulatorul integrat.
GND — masă comună.

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

Notă

Atunci 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

Pe versiunea H7, conectorul bateriei și VIN sunt legate împreună. 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 versiunea H7 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 alimentare VIN sau USB — alimentarea inversă a regulatorului în timp ce o altă sursă este activă poate deteriora și distruge definitiv camera.

Sfat

Folosiți estimatorul de durată a bateriei pentru a modela cât timp va funcționa versiunea H7 cu o baterie, pentru un anumit ciclu de funcționare activă / repaus profund.

Pini de recuperare și depanare¶

RESET — conectați la GND pentru a reseta placa. Eliberarea lui permite MCU-ului să pornească normal.
BOOT0 — conectați la 3,3 V în timpul alimentării plăcii 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) lângă conectorul GPIO, compatibil cu adaptoarele ST‑LINK și SEGGER J‑Link.

Periferice integrate¶

LED-uri¶

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

LED RGB de 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 acționate î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¶

Senzorul OV7725 (sau MT9M114 pe versiunea H7 R2) este acționat 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()

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

Card microSD¶

Atunci când este introdus un card, acesta este montat automat la /sdcard și poate fi utilizat 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 a acționa oricare dintre pinii marcați pe placă. 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 întregul conector).

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, de asemenea, 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 utilizat și în mod țintă (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 de utilizator. Poate fi folosit fie ca intrare ADC pe 12 biți, fie ca ieșire DAC.

ADC — scala completă la 3,3 V pe 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 aplicați 5 V.

PWM¶

Pin	Temporizator / canal
P4	TIM2 CH3
P5	TIM2 CH4
P6	TIM2 CH1
P7	TIM4 CH1
P8	TIM4 CH2
P9	TIM4 CH3

Notă

TIM1 este rezervat de firmware pentru a genera ceasul de pixeli al senzorului camerei, așa că acele canale TIM1 care se află fizic pe P0/P1/P2 nu pot fi folosite pentru PWM de 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 combinați machine.PWM pe P7/P8/P9 cu pyb.Servo în același script.

Acționați oricare dintre ele prin machine.PWM

from machine import Pin, PWM

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

Magistrale emulate prin software (bit‑banged)¶

machine.SoftI2C și machine.SoftSPI funcționează pe orice pin 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 camerele 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

Cablaț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 doar prin I²C 2 — cablați modulul la P4 (SCL) și P5 (SDA).

Temporizare¶

time¶

Modulul time acoperă întârzierile blocante, tick-urile 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. Transmiteț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 exprimate î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 bootloader scurt (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 cedează 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 montează la pornire până la trei sisteme de fișiere:

Memoria flash internă — montată întotdeauna la /flash. Conține implicit main.py și README.txt; este 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 fără copiere. Montat automat de MicroPython la pornire, înainte de rularea oricărui cod Python al utilizatorului.

După montare, directorul de lucru este setat la /sdcard atunci când cardul este prezent, în caz contrar 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 revine).
main.py este executat doar la pornirea la rece, imediat după boot.py. Resetările soft ulterioare rulează din nou boot.py, dar trec direct la REPL — pentru a rula din nou main.py trebuie să resetați complet placa.

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

Fișierul main.py implicit livrat pe o placă tocmai programată doar clipește canalul albastru al LED-ului RGB de utilizator ca un puls de stare (două impulsuri scurte, o scurtă pauză), astfel încât să puteți observa că firmware-ul a pornit corect fără nicio gazdă 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 plasate în /flash/lib, /sdcard/lib sau /rom/lib.

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

Atunci când este conectat prin USB, sistemul de fișiere de pornire (/sdcard dacă este prezent un card, altfel /flash) se enumeră, de asemenea, 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. Scoateți unitatea înainte de a reseta camera, astfel încât gazda să golească scrierile din memoria cache.

Notă

Deoarece sistemul de operare tratează unitatea ca pe un dispozitiv de 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 în același sistem de fișiere în același timp, sistemul de operare va avea câștig de cauză ș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 de 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.

Dimensiuni de stocare¶

Versiunea H7 este livrată cu:

/flash — sistem de fișiere FAT de 128 KB, read/write.
/rom — ROMFS read‑only mapat în memorie de 128 KB.
/sdcard — dimensiunea completă a oricărui card microSD introdus (când este prezent), read/write.

Indicator de eroare gravă (hard‑fault)¶

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

Biblioteci software¶

Consultați indexul bibliotecii pentru lista completă de module — inclusiv cele care sunt specifice doar versiunii H7.