OpenMV Cam M7

OpenMV Cam M7 to płytka wizji maszynowej oparta na rdzeniu Cortex‑M7, zbudowana wokół układu STMicroelectronics STM32F765 taktowanego z częstotliwością 216 MHz, wyposażona w 512 KB wewnętrznej pamięci SRAM i 2 MB wewnętrznej pamięci flash. Dołączony sensor OV7725 przechwytuje ramki 640×480 w skali szarości lub 320×240 RGB565 z prędkością do 150 FPS, a 10‑pinowe złącze użytkownika udostępnia urządzenia peryferyjne UART, I²C, SPI, CAN, ADC/DAC oraz PWM.

OpenMV Cam M7

Pełną dokumentację techniczną, zdjęcia i wymiary znajdziesz na stronie produktu OpenMV Cam M7.

Najważniejsze cechy

  • STMicroelectronics STM32F765 Cortex‑M7 taktowany z częstotliwością 216 MHz.

  • 512 KB wewnętrznej pamięci SRAM — brak zewnętrznej pamięci SDRAM.

  • 2 MB wewnętrznej pamięci flash (brak zewnętrznej pamięci flash QSPI).

  • Sensor OV7725 — 640×480 w skali szarości lub 320×240 RGB565 z prędkością do 150 FPS.

  • USB Full‑speed (12 Mb/s) — widoczne dla hosta jako VCP + pamięć masowa USB.

  • Gniazdo microSD — SD do 2 GB, SDHC do 32 GB, SDXC do 2 TB.

  • 10 pinów I/O, tolerujących 5 V z wyjściem 3,3 V, 25 mA na pin (łącznie 120 mA na całym złączu), z obsługą przerwań. P6 nie toleruje 5 V, gdy jest używany w trybie ADC lub DAC.

  • Użytkownikowa dioda RGB oraz dwie diody IR 850 nm dużej mocy zapewniające aktywne oświetlenie przy słabym świetle.

Informacja

M7 nie ma układu zarządzania zasilaniem na płytce: brak złącza akumulatora, brak ładowarki akumulatora, brak ADC do pomiaru napięcia akumulatora, brak diod statusu ładowania / zasilania i brak sprzętowego przycisku zasilania. Zasilaj płytkę z USB lub VIN.

Rozkład wyprowadzeń

Rozkład wyprowadzeń OpenMV Cam M7 OV7725

Opis wyprowadzeń

Nazwa pinu

Funkcja

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

zewrzyj do GND, aby zresetować płytkę

SYN

pole synchronizacji ramki (frame‑sync) — podłączone wyłącznie do sensora kamery

BOOT0

zewrzyj do 3,3 V przy włączeniu zasilania dla DFU / bootloadera ROM

LED_RED

czerwony kanał diody RGB (aktywny stanem niskim)

LED_GREEN

zielony kanał diody RGB (aktywny stanem niskim)

LED_BLUE

niebieski kanał diody RGB (aktywny stanem niskim)

LED_IR

diody IR dużej mocy (oba kanały sterowane wspólnie)

Informacja

Pole SYN na złączu jest podłączone bezpośrednio do linii wyzwalania / ekspozycji sensora kamery — w modelu M7 nie prowadzi ono do MCU. Steruj nim lub odczytuj je zewnętrznie; nie możesz go przełączać z poziomu MicroPython.

Piny zasilania

  • 3.3V — stabilizowana szyna 3,3 V. Do 250 mA dostępne dla nakładek (mniej, jeśli używana jest karta microSD). W przeciwieństwie do nowszych kamer ten pin jest dwukierunkowy — zobacz ostrzeżenie poniżej.

  • VIN — wejście 3,6 – 5 V. Zasila płytkę przez wbudowany stabilizator.

  • GND — wspólna masa.

Informacja

Gdy obecne są jednocześnie USB i VIN, płytkę zasila to źródło, które ma wyższe napięcie — wbudowane diody po prostu wybierają mocniejszą szynę.

Ostrzeżenie

Możesz zasilać M7, podając 3,3 V bezpośrednio na pin 3.3V, jeśli nie chcesz korzystać z wbudowanego stabilizatora. W takim przypadku nie podawaj jednocześnie zasilania VIN ani USB — wsteczne zasilanie stabilizatora przy aktywnym innym źródle może trwale uszkodzić i zniszczyć kamerę.

Wskazówka

Skorzystaj z kalkulatora żywotności akumulatora, aby oszacować, jak długo M7 będzie działać na akumulatorze przy zadanym cyklu pracy aktywnej / głębokiego uśpienia.

Piny odzyskiwania i debugowania

  • RESET — zewrzyj do GND, aby zresetować płytkę. Zwolnienie pozwala MCU uruchomić się normalnie.

  • BOOT0 — zewrzyj do 3,3 V podczas zasilania płytki, aby wejść do bootloadera ROM STM32 (tryb DFU). OpenMV IDE używa tego trybu do ponownego wgrania wbudowanego bootloadera.

Płytka udostępnia złącze debugowania SWD (RST / SWCLK / SWDIO) obok złącza GPIO, zgodne z adapterami ST‑LINK i SEGGER J‑Link.

Wbudowane urządzenia peryferyjne

Diody LED

M7 ma pojedynczą użytkownikową diodę RGB oraz parę diod IR 850 nm dużej mocy:

  • Użytkownikowa dioda RGB — sterowana programowo, udostępniona jako LED_RED, LED_GREEN i LED_BLUE

    from machine import LED

LED("LED_RED").on()
LED("LED_GREEN").on()
LED("LED_BLUE").on()

  • Diody IR — obie diody są sterowane wspólnie przez pin LED_IR. LED_IR jest sprzętowo podłączony jako aktywny stanem wysokim, podczas gdy oprogramowanie układowe traktuje każdą inną wbudowaną diodę jako aktywną stanem niskim, więc używaj low() / high() zamiast on() / off() (które odwróciłyby logikę):

    from machine import LED

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

Sensor kamery

Sensor OV7725 jest sterowany przez moduł csi — sensory kamery

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

W modelu M7 sensor jest przylutowany do płytki — nie znajduje się na wymiennym module.

Karta microSD

Po włożeniu karty jest ona automatycznie montowana w /sdcard i dostępna przez zwykły system plików:

import os

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

Opis magistral

GPIO

Użyj machine.Pin, aby odczytywać lub sterować dowolnym z opisanych na nadruku pinów. Wyjścia są typu 3,3 V CMOS, tolerują 5 V po stronie wejścia i mogą przyjmować/dostarczać do 25 mA na pin (łącznie 120 mA na całym złączu).

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

Każdy pin wejściowy może również wyzwalać przerwanie przy zmianach zbocza:

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

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

UART

Magistrala

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

Magistrala

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

Ten sam sprzęt może być również używany w trybie urządzenia docelowego (slave) przez machine.I2CTarget, aby udostępnić obszar pamięci innemu kontrolerowi I²C:

from machine import I2CTarget

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

SPI

Magistrala

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

Magistrala

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 to jedyny użytkownikowy pin analogowy. Może być używany jako 12‑bitowe wejście ADC lub wyjście DAC.

  • ADC — pełna skala przy 3,3 V na pinie:

    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 — przez pyb.DAC. Wartość 8‑bitowa obejmuje zakres 0–3,3 V:

    from pyb import DAC

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

W trybie ADC lub DAC pin P6 toleruje tylko 3,3 V — nie podawaj na niego 5 V.

PWM

Pin

Licznik czasu / kanał

P4

TIM2 CH3

P5

TIM2 CH4

P6

TIM2 CH1

P7

TIM4 CH1

P8

TIM4 CH2

P9

TIM4 CH3

Informacja

TIM1 jest zarezerwowany przez oprogramowanie układowe do generowania zegara pikseli sensora kamery, więc kanały TIM1, które fizycznie znajdują się na P0/P1/P2, nie mogą być używane do PWM użytkownika bez zakłócenia pracy kamery.

TIM4 jest współdzielony z pyb.Servo — utworzenie instancji serwa rekonfiguruje cały licznik czasu do pracy z częstotliwością 50 Hz, więc nie mieszaj machine.PWM na P7/P8/P9 z pyb.Servo w tym samym skrypcie.

Steruj dowolnym z nich przez machine.PWM

from machine import Pin, PWM

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

Programowe magistrale bit‑bang

machine.SoftI2C i machine.SoftSPI działają na dowolnym GPIO, jeśli potrzebujesz dodatkowej magistrali.

Sensor termiczny (zewnętrzny)

Oprogramowanie układowe zawiera sterownik fir — sterownik sensora termicznego (fir == far infrared, daleka podczerwień) dla zewnętrznie podłączonych kamer termowizyjnych:

  • MLX90621 — macierz IR 16 × 4

  • MLX90640 — macierz IR 32 × 24

  • MLX90641 — macierz IR 16 × 12

  • AMG8833 — macierz IR 8 × 8

Podłącz moduł do magistrali I²C płytki i odczytuj ramki za pomocą 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())

Sterownik fir komunikuje się z sensorem wyłącznie przez I²C 2 — podłącz moduł do P4 (SCL) i P5 (SDA).

Pomiar czasu

time

Moduł time obejmuje blokujące opóźnienia, monotoniczne takty oraz pomiar upływającego czasu:

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)

Wirtualne liczniki czasu

machine.Timer planuje okresowe lub jednorazowe wywołania zwrotne bez zajmowania sprzętowego slotu licznika czasu. Przekaż -1 jako id, aby użyć wirtualnego (programowego) licznika czasu:

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

Wartości okresu podawane są w milisekundach. Wywołaj deinit(), aby zatrzymać i zwolnić slot.

Zegar czasu rzeczywistego

machine.RTC utrzymuje czas zegarowy między resetami:

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 resetuje płytkę, jeśli aplikacja się zawiesi. Po uruchomieniu nie można go zatrzymać ani zrekonfigurować — odświeżaj go okresowo w głównej pętli:

from machine import WDT

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

Informacje o rozruchu i czasie wykonywania

Okno bootloadera USB

Przy każdym włączeniu zasilania kamera uruchamia krótki bootloader (kilka sekund), który pozwala OpenMV IDE zaktualizować oprogramowanie układowe bez konieczności wchodzenia przez użytkownika w tryb DFU. Po upływie tego okna bootloader przekazuje sterowanie do boot.py, a następnie main.py.

Działający skrypt może ponownie wejść do bootloadera na żądanie, wywołując machine.bootloader()

import machine

machine.bootloader()

System plików i kolejność rozruchu

Oprogramowanie układowe M7 montuje przy rozruchu do trzech systemów plików:

  • Wewnętrzna pamięć flash — zawsze montowana w /flash. Domyślnie przechowuje main.py i README.txt; tworzona przy pierwszym rozruchu.

  • Karta microSD — jeśli karta jest włożona, jest montowana w /sdcard.

  • ROMFS — tylko do odczytu, mapowany w pamięci system plików w /rom używany do dostarczania dużych zasobów danych (np. modeli AI), które zyskują na dostępie bez kopiowania. Montowany automatycznie przez MicroPython przy starcie, przed uruchomieniem jakiegokolwiek kodu Python użytkownika.

Po zamontowaniu katalog roboczy jest ustawiany na /sdcard, gdy karta jest obecna, w przeciwnym razie na /flash. Interpreter uruchamia następnie skrypty z tego katalogu:

  • boot.py jest wykonywany przy każdym miękkim resecie (zimny rozruch, Ctrl‑D z REPL lub za każdym razem, gdy działający skrypt zakończy działanie).

  • main.py jest wykonywany tylko przy zimnym rozruchu, bezpośrednio po boot.py. Kolejne miękkie resety ponownie uruchamiają boot.py, ale przechodzą prosto do REPL — aby ponownie uruchomić main.py, musisz w pełni zresetować płytkę.

Umieszczenie boot.py lub main.py na karcie SD nadpisuje kopię w pamięci flash bez jej naruszania — oba pliki są wyszukiwane w katalogu rozruchowym (/sdcard, gdy karta jest zamontowana, w przeciwnym razie /flash).

Domyślny main.py dostarczany na świeżo wgranej płytce po prostu miga niebieskim kanałem użytkownikowej diody RGB jako sygnał życia (dwa krótkie impulsy, krótka przerwa), dzięki czemu możesz stwierdzić, że oprogramowanie układowe uruchomiło się poprawnie, bez podłączonego hosta.

sys.path jest rozszerzany o wszystkie trzy systemy plików i ich podkatalogi lib/, dzięki czemu importowalne moduły mogą znajdować się w /flash/lib, /sdcard/lib lub /rom/lib.

Aby wymusić zignorowanie przez system włożonej karty SD (na przykład w celu uruchomienia main.py z pamięci flash nawet przy obecnej karcie), utwórz pusty plik o nazwie SKIPSD w katalogu głównym /flash.

Po podłączeniu przez USB rozruchowy system plików (/sdcard, jeśli karta jest obecna, w przeciwnym razie /flash) jest również wykrywany przez hosta jako napęd pamięci masowej USB, co pozwala bezpośrednio edytować boot.py, main.py i wszelkie inne pliki. Wysuń napęd przed zresetowaniem kamery, aby host opróżnił buforowane zapisy.

Informacja

Ponieważ system operacyjny traktuje napęd jako pasywne urządzenie blokowe, pliki utworzone lub zmodyfikowane przez kod działający na OpenMV Cam nie pojawią się, dopóki host ponownie nie zamontuje napędu. Jeśli zarówno system operacyjny, jak i OpenMV Cam zapisują ten sam system plików w tym samym czasie, system operacyjny wygra i nadpisze zmiany wprowadzone przez kamerę. Używaj karty SD dla wszelkich danych, które skrypt zapisuje, i montuj ją ponownie przed odczytem tych plików z hosta.

Informacja

Czerwony kanał użytkownikowej diody RGB może na chwilę się zaświecić, gdy host odczytuje z napędu pamięci masowej USB lub na niego zapisuje — jest to sterowany przez oprogramowanie układowe wskaźnik aktywności, a nie błąd.

Rozmiary pamięci

M7 jest dostarczany z:

  • /flash — system plików FAT o pojemności 96 KB, do odczytu/zapisu.

  • /rom — mapowany w pamięci ROMFS o pojemności 256 KB, tylko do odczytu.

  • /sdcard — pełny rozmiar włożonej karty microSD (gdy jest obecna), do odczytu/zapisu.

Wskaźnik krytycznego błędu (hard‑fault)

Jeśli użytkownikowa dioda RGB szybko przełącza się przez wszystkie kolory — na tyle szybko, że zwykle wygląda jak migocząca biała dioda zamiast wyraźnych barw — oznacza to, że oprogramowanie układowe napotkało nieodwracalny krytyczny błąd (hard fault). Wgraj ponownie oprogramowanie układowe, aby przywrócić działanie; jeśli ponowne wgranie nie pomoże, płytka może być fizycznie uszkodzona.

Biblioteki programowe

Pełną listę modułów — w tym informację, które z nich są unikalne dla wersji M7 — znajdziesz w indeksie bibliotek.