OpenMV Cam M7¶

OpenMV Cam M7 este o placă de viziune artificială bazată pe Cortex‑M7, construită în jurul unui STMicroelectronics STM32F765 la 216 MHz, cu 512 KB de SRAM intern și 2 MB de memorie flash internă. Senzorul OV7725 inclus captează cadre în tonuri de gri la 640×480 sau RGB565 la 320×240, cu până la 150 FPS, iar conectorul de utilizator cu 10 pini expune perifericele UART, I²C, SPI, CAN, ADC/DAC și PWM.

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

Repere principale¶

STMicroelectronics STM32F765 Cortex‑M7 la 216 MHz.
512 KB de SRAM intern — fără SDRAM extern.
2 MB de memorie flash internă (fără memorie flash QSPI externă).
Senzor OV7725 — tonuri de gri la 640×480 sau RGB565 la 320×240, cu până la 150 FPS.
USB full‑speed (12 Mb/s) — apare pentru gazdă ca VCP + dispozitiv de stocare în masă USB.
Soclu microSD — SD până la 2 GB, SDHC până la 32 GB, SDXC până la 2 TB.
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), capabili de întreruperi. P6 nu este tolerant la 5 V atunci când este utilizat în modul ADC sau DAC.
Un LED RGB de utilizator și două LED-uri IR de mare putere la 850 nm pentru iluminare activă în viziunea pe lumină scăzută.

Notă

M7 nu are cip de gestionare a alimentării la bord: nu are conector de baterie, nici încărcător de baterie, nici ADC pentru tensiunea bateriei, nici LED-uri de încărcare / stare a alimentării și nici buton hardware de pornire. Alimentați placa prin USB sau VIN.

Configurația pinilor¶

Referință pini¶

Nume pin	Funcție
P0	UART1 RX / SPI2 MOSI
P1	UART1 TX / SPI2 MISO
P2	SPI2 SCK / CAN2 TX
P3	SPI2 NSS (CS) / CAN2 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 bootloaderul DFU / 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 acționate împreună)

Notă

Pad-ul SYN de pe conector este conectat direct la linia de declanșare / expunere a senzorului camerei — pe M7 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ă este folosit 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 de la bord.
GND — masa comună.

Notă

Când sunt prezente atât USB-ul, cât și VIN-ul, placa este alimentată de cea cu tensiunea mai mare — diodele de la bord aleg pur și simplu magistrala mai puternică.

Atenționare

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

Sfat

Folosiți estimatorul duratei de viață a bateriei pentru a modela cât timp va funcționa M7 cu o 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 lui permite MCU-ului să pornească normal.
BOOT0 — conectați la 3,3 V în timp ce alimentați placa pentru a intra în bootloaderul ROM al STM32 (modul DFU). OpenMV IDE folosește acest mod pentru a reflasha bootloaderul de la bord.

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

Periferice la bord¶

LED-uri¶

M7 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 conectat hardware activ pe nivel înalt, în timp ce firmware-ul tratează orice alt LED de la bord ca activ 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¶

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

Pe M7 senzorul este lipit pe placă — nu se află pe un modul interschimbabil.

Card microSD¶

Atunci când un card este introdus, 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 acționa oricare dintre pinii serigrafiați. 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, de asemenea, declanșa 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 modul ț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¶

Magistrală	TX	RX
CAN2	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 — scală 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 modul 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
P9	TIM4 CH3

Notă

TIM1 este rezervat de firmware pentru a genera ceasul de pixeli al senzorului camerei, așa că canalele 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 amestecaț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 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 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

Conectați modulul la magistrala I²C a plăcii și citiți cadrele 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 — conectați modulul la P4 (SCL) și P5 (SDA).

Temporizare¶

time¶

Modulul time acoperă întârzierile blocante, ticurile 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 în milisecunde. Apelați deinit() pentru a opri și 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 bootloaderului 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, bootloaderul 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 M7 montează până la trei sisteme de fișiere la pornire:

Memoria flash internă — montată întotdeauna la /flash. Conține în mod implicit main.py și README.txt; este creată la prima pornire.
Card microSD — dacă un card este introdus, acesta este montat la /sdcard.
ROMFS — sistem de fișiere doar pentru citire, mapat în memorie, la /rom, folosit pentru a livra resurse mari de date (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, 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 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, altfel /flash).

Fișierul main.py implicit livrat pe o placă proaspăt flashată doar clipește canalul albastru al LED-ului RGB de utilizator pe post de bătaie de inimă (două impulsuri scurte, pauză scurtă), astfel încât să puteți ști că firmware-ul a pornit corect fără a fi atașată vreo gazdă.

sys.path este extins pentru a include toate cele trei sisteme de fișiere și subdirectoarele lor lib/, astfel încât modulele importabile pot exista î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ă un card este prezent, altfel /flash) se enumeră, de asemenea, ca o 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 pe 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 în 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 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 gestionat de firmware, nu o defecțiune.

Dimensiunile de stocare¶

M7 este livrat cu:

/flash — sistem de fișiere FAT de 96 KB, citire/scriere.
/rom — ROMFS mapat în memorie, doar pentru citire, de 256 KB.
/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 de utilizator parcurge rapid toate culorile — suficient de rapid încât tinde să arate ca un LED alb pâlpâitor mai degrabă decât ca nuanțe distincte — firmware-ul a întâmpinat o eroare gravă irecuperabilă. Reflashați firmware-ul pentru a recupera; dacă reflasharea nu ajută, placa poate fi deteriorată fizic.

Biblioteci software¶

Consultați indexul bibliotecii pentru lista completă a modulelor — inclusiv cele care sunt specifice versiunii pentru M7.