OpenMV Cam M4¶

Az OpenMV Cam M4 egy kompakt, Cortex‑M4 alapú gépi látás kártya, amely az STMicroelectronics 180 MHz‑es STM32F427 köré épül, 256 KB belső SRAM‑mal és 1 MB belső flash memóriával. A mellékelt OV7725 érzékelő 320×240‑es szürkeárnyalatos vagy RGB565 képkockákat rögzít, a 9 lábú felhasználói fejléc pedig UART, I²C, SPI, CAN, ADC/DAC és PWM perifériákat tesz elérhetővé.

Megjegyzés

Az OV7725 volt a szabványos érzékelő a sorozatgyártású M4 kártyákon. Az M4 nagyon korai változatai ehelyett OmniVision OV2640‑nel kerültek forgalomba — ugyanaz a QVGA előnézeti folyamat, de az OV2640 akár UXGA (1600×1200) JPEG képkockákat is rögzíthet. Mindkét érzékelőt ugyanazon a csi — kameraérzékelők API‑n keresztül lehet vezérelni.

A teljes adatlapért, fényképekért és méretekért lásd az OpenMV Cam M4 termékoldalt.

Kiemelt jellemzők¶

STMicroelectronics STM32F427 Cortex‑M4, 180 MHz.
256 KB belső SRAM — nincs külső SDRAM.
1 MB belső flash memória (nincs külső QSPI flash memória).
OV7725 érzékelő (vagy OV2640 a nagyon korai M4 változatokon) — 320×240‑es 8 bites szürkeárnyalatos vagy RGB565; az OV2640 ezenfelül akár UXGA (1600×1200) JPEG‑et is rögzíthet.
Full‑speed USB (12 Mb/s) — a gazdagép felé VCP + USB háttértárként jelenik meg.
microSD foglalat — SD akár 2 GB‑ig, SDHC akár 32 GB‑ig, SDXC akár 2 TB‑ig.
9 I/O láb, 5 V toleráns 3,3 V kimenettel, lábanként 25 mA (a fejlécen összesen 120 mA), megszakításra képes. A P6 nem 5 V toleráns, ha ADC vagy DAC módban használják.
Felhasználói RGB LED és két nagy teljesítményű 850 nm‑es IR LED az aktív megvilágításhoz gyenge fényviszonyok közötti látáshoz.

Megjegyzés

Az M4‑nek nincs fedélzeti energiakezelő chipje: nincs akkumulátorcsatlakozó, nincs akkumulátortöltő, nincs akkumulátorfeszültség‑ADC, nincsenek töltést / energiaállapotot jelző LED‑ek, és nincs hardveres bekapcsológomb. A kártyát USB‑ről vagy VIN‑ről táplálja.

Kiosztás¶

Lábkiosztási referencia¶

Láb neve	Funkció
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	GND‑re húzva a kártya újraindul
BOOT0	3,3 V‑ra húzva bekapcsoláskor DFU / ROM rendszerbetöltőhöz
SWCLK	ARM SWD órajel (hibakereső hozzáférés)
SWDIO	ARM SWD adat (hibakereső hozzáférés)
LED_RED	RGB LED piros csatorna (aktív alacsony)
LED_GREEN	RGB LED zöld csatorna (aktív alacsony)
LED_BLUE	RGB LED kék csatorna (aktív alacsony)
LED_IR	nagy teljesítményű IR LED‑ek (mindkét csatorna együtt vezérelve)

Tápláb-kivezetések¶

3.3V — szabályozott 3,3 V‑os sín. Akár 250 mA áll rendelkezésre a shieldek számára (kevesebb, ha a microSD kártya használatban van). Az újabb kamerákkal ellentétben ez a láb kétirányú — lásd az alábbi figyelmeztetést.
VIN — 3,6 – 5 V bemenet. A kártyát a fedélzeti szabályozón keresztül táplálja.
GND — közös föld.

Megjegyzés

Ha az USB és a VIN egyaránt jelen van, mindig a magasabb feszültségű táplálja a kártyát — a fedélzeti diódák egyszerűen az erősebb sínt választják.

Figyelem

Az M4‑et táplálhatja úgy is, hogy 3,3 V‑ot vezet közvetlenül a 3.3V lábra, ha nem szeretne a fedélzeti szabályozón keresztül haladni. Ebben az esetben ne alkalmazzon ezzel egyidejűleg VIN‑ vagy USB‑tápot is — a szabályozó visszafelé hajtása, miközben egy másik tápforrás aktív, tartósan károsíthatja és tönkreteheti a kamerát.

Javaslat

Használja az akkumulátor‑élettartam becslőt annak modellezésére, hogy az M4 mennyi ideig fog egy akkumulátorról üzemelni egy adott aktív / mélyalvás kitöltési tényező mellett.

Helyreállítási és hibakereső lábak¶

RESET — GND‑re húzva újraindítja a kártyát. Elengedve hagyja az MCU‑t normálisan elindulni.
BOOT0 — a kártya tápellátása közben 3,3 V‑ra húzva belép az STM32 ROM rendszerbetöltőbe (DFU mód). Az OpenMV IDE ezt a módot használja a fedélzeti rendszerbetöltő újraflashelésére.

Az SWCLK és az SWDIO közönséges fejléclábakként vannak kivezetve (nem dedikált SWD csatlakozóként). A kártya hibakereséséhez kösse a RESET, SWCLK, SWDIO, GND és 3,3 V lábakat egy ST‑LINK vagy SEGGER J‑Link adapterhez.

Fedélzeti perifériák¶

LED‑ek¶

Az M4‑nek egyetlen felhasználói RGB LED‑je van, valamint egy pár nagy teljesítményű 850 nm‑es IR LED‑je:

Felhasználói RGB LED — szoftveresen vezérelhető, a LED_RED, LED_GREEN és LED_BLUE néven elérhető:
```
from machine import LED

LED("LED_RED").on()
LED("LED_GREEN").on()
LED("LED_BLUE").on()
```
IR LED‑ek — mindkét LED együtt vezérelhető a LED_IR lábon keresztül. A LED_IR hardveresen aktív magas bekötésű, miközben a firmware minden más fedélzeti LED‑et aktív alacsonyként kezel, ezért a low() / high() metódusokat használja a on() / off() helyett (amelyek megfordítanák a logikát):
```
from machine import LED

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

Kameraérzékelő¶

A mellékelt érzékelőt (a szabványos kártyákon OV7725, a nagyon korai változatokon OV2640) a csi — kameraérzékelők modulon keresztül lehet vezérelni:

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

Az érzékelő az M4‑en a kártyára van forrasztva — nem cserélhető modulon található.

Megjegyzés

Az OV7725 kártyákon az érzékelő FSIN (képkocka‑szinkron) lába az MCU‑hoz van kötve, de a firmware‑támogatás hozzáadása ehhez még nem történt meg.

Az OV2640 kártyákon az érzékelő STROBE, FREX (képkocka‑expozíció) és EXPST (expozíció‑visszaállítás) lábai az MCU‑hoz vannak kötve, de a firmware‑támogatás hozzáadása ezekhez még nem történt meg.

Szervó fejlécek¶

A kártya hátoldalán két szervócsatlakozó forrasztási felület található, amelyek a szabványos 3 lábú szervó fejlécet (jel / VIN / GND) vezetik ki a P7 és P8 számára. A jellábak közvetlenül a TIM4 1. és 2. csatornájához vannak rendelve (ugyanazokhoz a csatornákhoz, amelyeket a pyb.Servo használ), és minden fejlécen a V+ láb közvetlenül a VIN‑hez van kötve, így a szervók az áramukat a bemeneti sínből, nem pedig a 3,3 V‑os szabályozóból veszik.

Forrasszon egy pár derékszögű 3 lábú fejlécet a felületekre, és csatlakoztasson két hobbiszervót egy pásztázó‑döntő tartó meghajtásához:

from pyb import Servo

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

microSD kártya¶

Amikor egy kártya be van helyezve, az automatikusan a /sdcard alá kerül csatolásra, és a szokásos fájlrendszeren keresztül használható:

import os

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

Busz-referencia¶

GPIO¶

Használja a machine.Pin osztályt a szitanyomott lábak bármelyikének olvasásához vagy meghajtásához. A kimenetek 3,3 V‑os CMOS‑ok, a bemeneti oldalon 5 V toleránsak, és lábanként akár 25 mA‑t képesek nyelni/forrásként szolgáltatni (a teljes fejlécen összesen 120 mA).

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

Bármelyik bemeneti láb megszakítást is kiválthat éltranzícióknál:

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

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

UART¶

Busz	TX	RX
UART3	P4	P5

from machine import UART

uart = UART(3, baudrate=115200)
uart.write("hello")
uart.read(5)

I²C¶

Busz	SCL	SDA
I2C2	P4	P5

from machine import I2C

i2c = I2C(2, freq=400_000)
i2c.scan()
i2c.writeto(0x76, b"hi")

Ugyanaz a hardver cél (slave) módban is használható a machine.I2CTarget segítségével, hogy egy memóriaterületet tegyen elérhetővé egy másik I²C vezérlő számára:

from machine import I2CTarget

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

SPI¶

Busz	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¶

Busz	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 és DAC¶

A P6 az egyetlen felhasználói analóg láb. Használható akár 12 bites ADC bemenetként, akár DAC kimenetként.

ADC — teljes skála a lábon 3,3 V‑nál:

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 — a pyb.DAC segítségével. A 8 bites érték a 0–3,3 V tartományt fedi le:

from pyb import DAC

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

ADC vagy DAC módban a P6 csak 3,3 V toleráns — ne adjon rá 5 V‑ot.

PWM¶

Láb	Időzítő / csatorna
P4	TIM2 CH3
P5	TIM2 CH4
P6	TIM2 CH1
P7	TIM4 CH1
P8	TIM4 CH2

Megjegyzés

A TIM1 a firmware által fenntartott a kameraérzékelő képpont‑órajelének generálásához, így a P0/P1/P2 lábakon fizikailag jelen lévő TIM1 csatornák nem használhatók felhasználói PWM‑hez a kamera megzavarása nélkül.

A TIM4 megosztott a pyb.Servo osztállyal — egy szervó példányosítása az egész időzítőt 50 Hz‑es működésre konfigurálja át, ezért ne keverje a machine.PWM használatát a P7/P8 lábakon a pyb.Servo használatával ugyanabban a szkriptben.

Bármelyiket meghajthatja a machine.PWM segítségével:

from machine import Pin, PWM

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

Szoftveresen bit‑bangelt buszok¶

A machine.SoftI2C és a machine.SoftSPI bármely GPIO‑n működik, ha extra buszra van szüksége.

Hőérzékelő (a kártyán kívül)¶

A firmware tartalmazza a fir — hőérzékelő-meghajtó (fir == far infrared, távoli infravörös) illesztőprogramot a külsőleg bekötött hőkamerákhoz:

MLX90621 — 16 × 4 IR mátrix
MLX90640 — 32 × 24 IR mátrix
MLX90641 — 16 × 12 IR mátrix
AMG8833 — 8 × 8 IR mátrix

Kösse a modult a kártya I²C buszára, és olvassa be a képkockákat a fir.init() + fir.snapshot() segítségével:

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

A fir illesztőprogram csak az I²C 2‑n keresztül kommunikál az érzékelővel — kösse a modult a P4 (SCL) és P5 (SDA) lábakra.

Időzítés¶

time¶

A time modul lefedi a blokkoló késleltetéseket, a monoton tick‑eket és az eltelt idő mérését:

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)

Virtuális időzítők¶

A machine.Timer periodikus vagy egyszeri visszahívásokat ütemez anélkül, hogy hardveres időzítőhelyet foglalna. Adjon át -1 értéket az id‑ként virtuális (szoftveres) időzítő használatához:

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

A periódusértékek ezredmásodpercben vannak megadva. Hívja meg a deinit() metódust a leállításhoz és a hely felszabadításához.

Valós idejű óra¶

A machine.RTC megőrzi a fali órajel szerinti időt az újraindításokon keresztül:

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¶

A machine.WDT újraindítja a kártyát, ha az alkalmazás lefagy. Az elindítása után nem lehet leállítani vagy újrakonfigurálni — etesse rendszeresen a fő ciklusában:

from machine import WDT

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

Indítási és futásidejű információk¶

USB rendszerbetöltő ablak¶

Minden bekapcsoláskor a kamera lefuttat egy rövid rendszerbetöltőt (néhány másodperc), amely lehetővé teszi az OpenMV IDE számára a firmware frissítését anélkül, hogy a felhasználónak DFU módba kellene lépnie. Az ablak lejárta után a rendszerbetöltő átadja a vezérlést a boot.py‑nak, majd a main.py‑nak.

Egy futó szkript igény szerint újra beléphet a rendszerbetöltőbe a machine.bootloader() meghívásával:

import machine

machine.bootloader()

Fájlrendszer és indítási sorrend¶

Az M4 firmware indításkor akár három fájlrendszert csatol:

Belső flash memória — mindig a /flash alá csatolva. Alapértelmezés szerint a main.py és a README.txt fájlokat tartalmazza; a legelső indításkor jön létre.
microSD kártya — ha egy kártya be van helyezve, az a /sdcard alá kerül csatolásra.
ROMFS — csak olvasható, memóriába leképezett fájlrendszer a /rom alatt, amelyet nagy adatcsomagok (pl. AI modellek) szállítására használnak, amelyek a zéró‑másolásos hozzáférésből profitálnak. A MicroPython indításkor automatikusan csatolja, bármilyen felhasználói Python futása előtt.

A csatolás után a munkakönyvtár a /sdcard lesz, ha a kártya jelen van, egyébként a /flash. Az értelmező ezután ebből a könyvtárból futtatja a szkripteket:

A boot.py minden szoftveres újraindításkor lefut (hidegindítás, Ctrl‑D a REPL‑ből, vagy valahányszor a futó szkript visszatér).
A main.py csak hidegindításkor fut le, közvetlenül a boot.py után. A későbbi szoftveres újraindítások újra lefuttatják a boot.py‑t, de egyenesen a REPL‑re ugranak — a main.py újrafuttatásához teljesen újra kell indítania a kártyát.

Ha egy boot.py vagy main.py fájlt helyez az SD kártyára, az felülírja a flash memóriában lévő példányt anélkül, hogy hozzányúlna — mindkét fájlt az indítási könyvtárban keresi a rendszer (/sdcard, ha a kártya csatolva van, egyébként /flash).

A frissen flashelt kártyán szállított alapértelmezett main.py csak a felhasználói RGB LED kék csatornáját villogtatja szívverésként (két rövid impulzus, rövid szünet), így a gazdagép csatlakoztatása nélkül is láthatja, hogy a firmware tisztán elindult.

A sys.path ki van bővítve mindhárom fájlrendszerrel és azok lib/ alkönyvtáraival, így az importálható modulok a /flash/lib, /sdcard/lib vagy /rom/lib könyvtárakban élhetnek.

Ahhoz, hogy a rendszert egy behelyezett SD kártya figyelmen kívül hagyására kényszerítse (például a flash main.py futtatásához akkor is, ha kártya van jelen), hozzon létre egy SKIPSD nevű üres fájlt a /flash gyökerében.

USB‑n keresztüli csatlakozáskor az indítási fájlrendszer (/sdcard, ha kártya van jelen, egyébként /flash) USB háttértár‑meghajtóként is megjelenik a gazdagépen, lehetővé téve a boot.py, main.py és bármely más fájl közvetlen szerkesztését. A kamera újraindítása előtt válassza le a meghajtót, hogy a gazdagép kiürítse a gyorsítótárazott írásokat.

Megjegyzés

Mivel az operációs rendszer passzív blokkeszközként kezeli a meghajtót, az OpenMV Cam‑on futó kód által létrehozott vagy módosított fájlok nem jelennek meg, amíg a gazdagép újra nem csatolja a meghajtót. Ha az operációs rendszer és az OpenMV Cam egyszerre írja ugyanazt a fájlrendszert, az operációs rendszer győz, és felülírja a kamera által végrehajtott módosításokat. A szkript által visszaírt bármely adathoz használja az SD kártyát, és csatolja újra a meghajtót, mielőtt a gazdagépről olvasná ezeket a fájlokat.

Megjegyzés

A felhasználói RGB LED piros csatornája röviden felvillanhat, miközben a gazdagép az USB háttértár‑meghajtóról olvas vagy arra ír — ez egy firmware‑vezérelt tevékenységjelző, nem hiba.

Tárméretek¶

Az M4 a következőkkel kerül forgalomba:

/flash — 32 KB FAT fájlrendszer, írható/olvasható.
/rom — 128 KB csak olvasható, memóriába leképezett ROMFS.
/sdcard — a behelyezett microSD kártya teljes mérete (ha jelen van), írható/olvasható.

Hard‑fault jelző¶

Ha a felhasználói RGB LED gyorsan végigjárja az összes színt — elég gyorsan ahhoz, hogy inkább csillogó fehér LED‑nek tűnjön, mint különálló árnyalatoknak — akkor a firmware helyreállíthatatlan hard fault hibába ütközött. A helyreállításhoz flashelje újra a firmware‑t; ha az újraflashelés nem segít, a kártya fizikailag is megsérülhetett.

Szoftverkönyvtárak¶

A modulok teljes listájáért lásd a könyvtárindexet — beleértve azt is, hogy melyek egyediek az M4 build számára.