OpenMV Cam M7¶

Az OpenMV Cam M7 egy Cortex‑M7 alapú gépi látás kártya, amelyet a STMicroelectronics STM32F765 köré építettek, 216 MHz órajellel, 512 KB belső SRAM-mal és 2 MB belső flash memóriával. A mellékelt OV7725 érzékelő 640×480 szürkeárnyalatos vagy 320×240 RGB565 képkockákat rögzít akár 150 FPS sebességgel, a 10 lábú felhasználói tűsor pedig UART, I²C, SPI, CAN, ADC/DAC és PWM perifériákat tesz elérhetővé.

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

Kiemelt jellemzők¶

STMicroelectronics STM32F765 Cortex‑M7, 216 MHz.
512 KB belső SRAM — nincs külső SDRAM.
2 MB belső flash memória (nincs külső QSPI flash).
OV7725 érzékelő — 640×480 szürkeárnyalatos vagy 320×240 RGB565 akár 150 FPS sebességgel.
Full‑speed USB (12 Mb/s) — a gazdagép felé VCP + USB tárolóeszközként jelenik meg.
microSD foglalat — SD akár 2 GB, SDHC akár 32 GB, SDXC akár 2 TB.
10 I/O láb, 5 V toleráns 3,3 V kimenettel, lábanként 25 mA (összesen 120 mA a tűsoron), megszakítás-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 melletti látáshoz.

Megjegyzés

Az M7 nem rendelkezik fedélzeti energiagazdálkodási chippel: nincs akkumulátor-csatlakozó, nincs akkumulátortöltő, nincs akkumulátor-feszültség ADC, nincsenek töltés / tápállapot LED-ek, és nincs hardveres tápkapcsoló. A kártyát USB-ről vagy VIN-en keresztül tápláld.

Lábkiosztás¶

Lábkiosztási referencia¶

Láb neve	Funkció
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	GND-re húzva alaphelyzetbe állítja a kártyát
SYN	képkocka-szinkronizáló pad — kizárólag a kamera érzékelőjéhez kötve
BOOT0	bekapcsoláskor 3,3 V-ra húzva DFU / ROM rendszerbetöltőhöz
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)

Megjegyzés

A tűsoron lévő SYN pad közvetlenül a kamera érzékelőjének trigger / expozíció vonalához csatlakozik — az M7-en nem vezet a MCU-hoz. Külsőleg vezéreld vagy olvasd ki; MicroPythonból nem kapcsolgatható.

Tápláb-kiosztás¶

3.3V — szabályozott 3,3 V-os sín. A bővítőkártyák számára akár 250 mA áll rendelkezésre (kevesebb, ha a microSD kártya használatban van). Az újabb kameráktól eltérően 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 is 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 M7-et táplálhatod úgy, hogy 3,3 V-ot vezetsz közvetlenül a 3.3V lábra, ha nem akarsz a fedélzeti szabályozón keresztül menni. Ebben az esetben ne kapcsolj egyidejűleg VIN vagy USB tápellátást is — a szabályozó visszafelé táplálása, miközben egy másik tápforrás aktív, tartósan károsíthatja és tönkreteheti a kamerát.

Javaslat

Használd az akkumulátor-élettartam becslőt annak modellezéséhez, hogy az M7 mennyi ideig fog működni egy akkumulátorról adott aktív / mélyalvási kitöltési tényező mellett.

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

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

A kártya a GPIO tűsor mellett egy SWD hibakereső tűsort (RST / SWCLK / SWDIO) is elérhetővé tesz, amely kompatibilis az ST‑LINK és SEGGER J‑Link adapterekkel.

Fedélzeti perifériák¶

LED-ek¶

Az M7 egyetlen felhasználói RGB LED-del, valamint egy pár nagy teljesítményű 850 nm-es IR LED-del rendelkezik:

Felhasználói RGB LED — szoftveresen vezérelhető, 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 van vezérelve a LED_IR lábon keresztül. A LED_IR hardveresen aktív magas, miközben a firmware minden más fedélzeti LED-et aktív alacsonyként kezel, ezért a low() / high() metódusokat használd a on() / off() helyett (amelyek megfordítanák az értelmezést):
```
from machine import LED

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

Kamera érzékelő¶

Az OV7725 a csi — kameraérzékelők modulon keresztül vezérelhető:

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 M7-en a kártyára van forrasztva — nem cserélhető modulon helyezkedik el.

microSD kártya¶

Ha egy kártyát behelyeznek, automatikusan a /sdcard helyre csatolódik, és a szokásos fájlrendszeren keresztül használható:

import os

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

Busz-referencia¶

GPIO¶

Használd a machine.Pin osztályt bármely szitanyomott láb olvasásához vagy vezérléséhez. A kimenetek 3,3 V CMOS-ok, a bemeneti oldalon 5 V toleránsak, és lábanként akár 25 mA-t képesek nyelni/forrásolni (összesen 120 mA az egész tűsoron).

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ármely bemeneti láb megszakítást is kiválthat él-átmenetekné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
UART1	P1	P0
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
I2C4	P7	P8

from machine import I2C

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

Ugyanaz a hardver céleszköz (slave) módban is használható a machine.I2CTarget osztályon keresztül, 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 3,3 V-on a lábon:

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 osztályon keresztül. 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 tápláld 5 V-tal.

PWM¶

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

Megjegyzés

A TIM1-et a firmware fenntartja a kamera érzékelőjének képpont-órajelének előállításához, ezért a fizikailag a P0/P1/P2 lábakon lévő TIM1 csatornák nem használhatók felhasználói PWM-hez a kamera működésének 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 keverd a machine.PWM használatát a P7/P8/P9 lábakon a pyb.Servo használatával ugyanabban a szkriptben.

Bármelyiküket vezérelheted a machine.PWM osztályon keresztül:

from machine import Pin, PWM

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

Szoftveresen bitelt (bit‑banged) buszok¶

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

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

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 tömb
MLX90640 — 32 × 24 IR tömb
MLX90641 — 16 × 12 IR tömb
AMG8833 — 8 × 8 IR tömb

Kösd a modult a kártya I²C buszára, és olvasd a képkockákat a fir.init() + fir.snapshot() hívásokkal:

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 buszon keresztül kommunikál az érzékelővel — kösd 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 tikkeket é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 hardveres időzítő-slot lefoglalása nélkül. Add át a -1 értéket 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 milliszekundumban vannak megadva. Hívd meg a deinit() metódust a leállításhoz és a slot felszabadításához.

Valós idejű óra¶

A machine.RTC megtartja a falióra szerinti időt az alaphelyzetbe állítások között:

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 alaphelyzetbe állítja a kártyát, ha az alkalmazás lefagy. Miután elindítottad, nem állítható le és nem konfigurálható újra — táplálnod kell periodikusan a fő ciklusodon belül:

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 egy rövid rendszerbetöltőt futtat (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 M7 firmware induláskor akár három fájlrendszert csatol:

Belső flash — mindig a /flash helyre csatolva. Alapértelmezetten 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ártyát behelyeznek, a /sdcard helyre csatolódik.
ROMFS — csak olvasható, memóriába leképezett fájlrendszer a /rom helyen, amelyet nagy adatállományok (pl. AI modellek) szállítására használnak, amelyek profitálnak a másolás nélküli hozzáférésből. A MicroPython automatikusan csatolja induláskor, bármely felhasználói Python futása előtt.

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

A boot.py minden szoftveres alaphelyzetbe állí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 alaphelyzetbe állítások újra lefuttatják a boot.py-t, de egyből a REPL-re ugranak — a main.py újrafuttatásához teljesen alaphelyzetbe kell állítanod a kártyát.

Egy boot.py vagy main.py SD kártyára helyezése felülírja a flashben 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).

Egy frissen flashelt kártyán szállított alapértelmezett main.py csak villogtatja a felhasználói RGB LED kék csatornáját szívverésként (két rövid impulzus, rövid szünet), így megállapíthatod, hogy a firmware tisztán elindult, anélkül hogy bármilyen gazdagép csatlakozna.

A sys.path ki van bővítve, hogy mind a három fájlrendszert és azok lib/ alkönyvtárait tartalmazza, így az importálható modulok lehetnek a /flash/lib, /sdcard/lib vagy /rom/lib helyeken.

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

USB-n keresztül csatlakoztatva az indítási fájlrendszer (/sdcard, ha kártya van jelen, egyébként /flash) USB tárolóeszközké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. Vedd ki (eject) a meghajtót a kamera alaphelyzetbe állítása előtt, hogy a gazdagép kiírja a gyorsítótárazott írásait.

Megjegyzés

Mivel az operációs rendszer passzív blokkeszközként kezeli a meghajtót, az OpenMV Cam-en 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égzett módosításokat. Használd az SD kártyát bármilyen adathoz, amelyet a szkript visszaír, és csatold újra, mielőtt ezeket a fájlokat a gazdagépről olvasnád.

Megjegyzés

A felhasználói RGB LED piros csatornája röviden felvillanhat, miközben a gazdagép az USB tárolómeghajtóról olvas vagy oda ír — ez egy firmware által vezérelt aktivitásjelző, nem hiba.

Tárolóméretek¶

Az M7 a következőkkel kerül szállításra:

/flash — 96 KB FAT fájlrendszer, írható/olvasható.
/rom — 256 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égigfut az összes színen — elég gyorsan ahhoz, hogy inkább villódzó fehér LED-nek tűnjön, mint különálló árnyalatoknak —, akkor a firmware helyrehozhatatlan hard fault hibába ütközött. A helyreállításhoz flasheld újra a firmware-t; ha az újraflashelés nem segít, lehet, hogy a kártya fizikailag megsérült.

Szoftverkönyvtárak¶

A modulok teljes listájáért lásd a könyvtárindexet — beleértve azt is, hogy melyek egyediek az M7 build esetében.