OpenMV Cam M4¶

OpenMV Cam M4 este o placă compactă de viziune artificială cu Cortex‑M4, construită în jurul microcontrolerului STMicroelectronics STM32F427 la 180 MHz, cu 256 KB de SRAM intern și 1 MB de memorie flash internă. Senzorul OV7725 inclus captează cadre 320×240 în tonuri de gri sau RGB565, iar conectorul de utilizator cu 9 pini expune perifericele UART, I²C, SPI, CAN, ADC/DAC și PWM.

Notă

OV7725 a fost senzorul standard pe plăcile M4 de producție. Variantele foarte timpurii ale M4 au fost livrate cu OmniVision OV2640 în locul acestuia — același flux de previzualizare QVGA, dar OV2640 poate captura și cadre JPEG de până la UXGA (1600×1200). Ambii senzori sunt controlați prin aceeași API csi — senzori de cameră.

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

Aspecte principale¶

STMicroelectronics STM32F427 Cortex‑M4 la 180 MHz.
256 KB SRAM intern — fără SDRAM extern.
1 MB memorie flash internă (fără memorie flash QSPI externă).
Senzor OV7725 (sau OV2640 pe variantele M4 foarte timpurii) — 320×240 în tonuri de gri pe 8 biți sau RGB565; OV2640 poate captura suplimentar până la UXGA (1600×1200) JPEG.
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.
9 pini I/O, tolerant 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 mod ADC sau DAC.
LED RGB de utilizator și două LED‑uri IR de mare putere la 850 nm pentru iluminare activă în viziunea pe lumină slabă.

Notă

M4 nu are cip de gestionare a alimentării integrat: nu există conector de baterie, încărcător de baterie, ADC pentru tensiunea bateriei, LED‑uri de încărcare / stare a alimentării și nici buton hardware de alimentare. Alimentați placa de la USB sau VIN.

Schema pinilor¶

Referință pini¶

Nume pin	Funcție
P0	SPI2 MOSI
P1	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	TIM4 CH1
P8	TIM4 CH2
RESET	conectați la GND pentru a reseta placa
BOOT0	conectați la 3,3 V la pornire pentru bootloaderul DFU / ROM
SWCLK	ceas ARM SWD (acces depanator)
SWDIO	date ARM SWD (acces depanator)
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ă)

Pini de alimentare¶

3.3V — magistrală 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ă.

Notă

Când sunt prezente atât USB, cât și VIN, alimentarea plăcii este asigurată de cel cu tensiunea mai mare — diodele integrate aleg pur și simplu magistrala mai puternică.

Atenționare

Puteți alimenta M4 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 și VIN sau alimentare USB în același timp — alimentarea inversă a regulatorului în timp ce o altă sursă este activă poate deteriora și distruge definitiv camera.

Sfat

Utilizați estimatorul de durată de viață a bateriei pentru a modela cât timp va funcționa M4 cu o baterie pentru un anumit ciclu de funcționare activ / deep-sleep.

Pini de recuperare și depanare¶

RESET — conectați la GND pentru a reseta placa. Eliberarea lui permite microcontrolerului 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 utilizează acest mod pentru a reflasha bootloaderul integrat.

SWCLK și SWDIO sunt expuse ca pini obișnuiți pe conector (nu un conector SWD dedicat). Conectați RESET, SWCLK, SWDIO, GND și 3,3 V la un adaptor ST‑LINK sau SEGGER J‑Link pentru a depana placa.

Periferice integrate¶

LED‑uri¶

M4 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 activ pe nivel înalt în hardware, în timp ce firmware‑ul tratează orice alt LED integrat ca activ pe nivel jos, așa că utilizaț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
```

Senzor de cameră¶

Senzorul inclus (OV7725 pe plăcile standard, OV2640 pe variantele foarte timpurii) este controlat 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 este lipit de placă pe M4 — nu se află pe un modul interschimbabil.

Notă

Pe plăcile OV7725, pinul FSIN (sincronizare cadre) al senzorului este conectat la microcontroler, dar suportul firmware pentru acesta nu a fost adăugat.

Pe plăcile OV2640, pinii STROBE, FREX (expunere cadru) și EXPST (resetare expunere) ai senzorului sunt conectați la microcontroler, dar suportul firmware pentru aceștia nu a fost adăugat.

Conectoare pentru servomotoare¶

Partea din spate a plăcii are două pad‑uri de lipire pentru conectoare de servomotoare care expun conectorul standard de servomotor cu 3 pini (semnal / VIN / GND) pentru P7 și P8. Pinii de semnal corespund direct canalelor 1 și 2 ale TIM4 (aceleași canale folosite de pyb.Servo), iar pinul V+ de pe fiecare conector este conectat direct la VIN, astfel încât servomotoarele își iau curentul din magistrala de intrare, nu din regulatorul de 3,3 V.

Lipiți o pereche de conectoare cu 3 pini în unghi drept în pad‑uri și conectați două servomotoare pentru hobby pentru a acționa un suport pan‑and‑tilt:

from pyb import Servo

pan  = Servo(1)              # P7 — TIM4 CH1
tilt = Servo(2)              # P8 — TIM4 CH2
pan.angle(0)
tilt.angle(0)

card microSD¶

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¶

Utilizați machine.Pin pentru a citi sau acționa 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 î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 ș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
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

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 utilizat 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 modul 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

Notă

TIM1 este rezervat de firmware pentru a genera ceasul de pixeli al senzorului de cameră, astfel încât canalele TIM1 care se află fizic pe P0/P1/P2 nu pot fi utilizate pentru PWM de utilizator fără a întrerupe funcționarea camerei.

TIM4 este partajat cu pyb.Servo — instanțierea unui servomotor reconfigurează întregul temporizator pentru funcționare la 50 Hz, așa că nu combinați machine.PWM pe P7/P8 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 imagistică termică conectată extern:

MLX90621 — matrice IR 16 × 4
MLX90640 — matrice IR 32 × 24
MLX90641 — matrice IR 16 × 12
AMG8833 — matrice IR 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 doar prin I²C 2 — conectați modulul la P4 (SCL) și P5 (SDA).

Sincronizare¶

time¶

Modulul time acoperă întârzieri 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 periodice sau unice fără a consuma un slot de temporizator hardware. Transmiteți -1 ca id pentru a utiliza 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 de perete î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 M4 montează până la trei sisteme de fișiere la pornire:

Memoria flash internă — întotdeauna montată la /flash. Conține în mod implicit main.py și README.txt; 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, utilizat pentru a livra resurse mari de date (de exemplu, modele AI) care beneficiază de acces zero‑copy. Montat automat de MicroPython la pornire, înainte ca orice cod Python al utilizatorului să ruleze.

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 revine).
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 flashată doar clipește canalul albastru al LED‑ului RGB de utilizator ca semnal de viață (două impulsuri scurte, o pauză scurtă), astfel încât să puteți afla că firmware‑ul a pornit corect fără să aveți 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 main.py din memoria flash chiar și cu un card prezent), creați un fișier gol numit SKIPSD la 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ă ș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. Scoateți unitatea înainte de a reseta camera pentru ca gazda să golească scrierile din cache.

Notă

Deoarece sistemul de operare tratează unitatea ca pe un dispozitiv de blocuri 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ă. Utilizaț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.

Dimensiuni de stocare¶

M4 este livrat cu:

/flash — sistem de fișiere FAT de 32 KB, citire/scriere.
/rom — ROMFS mapat în memorie, doar pentru citire, de 128 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 nuanțe distincte — firmware‑ul a întâmpinat o eroare gravă nerecuperabilă. 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ă de module — inclusiv cele care sunt unice pentru versiunea M4.