OpenMV Cam M7¶

OpenMV Cam M7 är ett Cortex‑M7-kort för maskinseende byggt kring STMicroelectronics STM32F765 på 216 MHz med 512 KB internt SRAM och 2 MB internt flashminne. Den medföljande OV7725-sensorn fångar 640×480 bildrutor i gråskala eller 320×240 RGB565 vid upp till 150 FPS, och det 10‑poliga användarkontaktstycket exponerar kringutrustning för UART, I²C, SPI, CAN, ADC/DAC och PWM.

Fullständigt datablad, foton och mått finns på produktsidan för OpenMV Cam M7.

Höjdpunkter¶

STMicroelectronics STM32F765 Cortex‑M7 på 216 MHz.
512 KB internt SRAM — inget externt SDRAM.
2 MB internt flashminne (inget externt QSPI-flashminne).
OV7725-sensor — 640×480 gråskala eller 320×240 RGB565 vid upp till 150 FPS.
Full‑speed USB (12 Mb/s) — visas som VCP + USB-masslagring för värddatorn.
microSD-uttag — SD upp till 2 GB, SDHC upp till 32 GB, SDXC upp till 2 TB.
10 I/O-stift, 5 V-toleranta med 3,3 V-utgång, 25 mA per stift (120 mA totalt över kontaktstycket), avbrottskapabla. P6 är inte 5 V-tolerant när det används i ADC- eller DAC-läge.
Användarstyrd RGB-LED och två IR-LED:er på 850 nm med hög effekt för aktiv belysning vid seende i svagt ljus.

Anteckning

M7 har inget inbyggt kraftförsörjningschip: ingen batterikontakt, ingen batteriladdare, ingen ADC för batterispänning, inga laddnings-/strömstatus-LED:er och ingen hårdvaruströmknapp. Driv kortet från USB eller VIN.

Stiftutläggning¶

Stiftreferens¶

Stiftnamn	Funktion
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	dra till GND för att återställa kortet
SYN	bildrute‑synkroniseringspad — kopplad endast till kamerasensorn
BOOT0	dra till 3,3 V vid påslag för DFU / ROM-startladdare
LED_RED	RGB-LED:ens röda kanal (aktiv låg)
LED_GREEN	RGB-LED:ens gröna kanal (aktiv låg)
LED_BLUE	RGB-LED:ens blå kanal (aktiv låg)
LED_IR	IR-LED:er med hög effekt (båda kanalerna drivs tillsammans)

Anteckning

SYN-paddet på kontaktstycket är direkt kopplat till kamerasensorns trigger‑/exponeringslinje — det leder inte till MCU:n på M7. Driv eller läs det externt; du kan inte växla det från MicroPython.

Strömstift¶

3.3V — reglerad 3,3 V-skena. Upp till 250 mA tillgängligt för sköldar (mindre om microSD-kortet används). Till skillnad från de nyare kamerorna är detta stift dubbelriktat — se varningen nedan.
VIN — 3,6–5 V-ingång. Driver kortet genom den inbyggda regulatorn.
GND — gemensam jord.

Anteckning

När både USB och VIN är anslutna driver den med högst spänning kortet — de inbyggda dioderna väljer helt enkelt den starkare skenan.

Varning

Du får driva M7 genom att mata 3,3 V direkt in i 3.3V-stiftet om du inte vill gå genom den inbyggda regulatorn. I så fall, anslut inte även VIN- eller USB-ström samtidigt — att backmata regulatorn medan en annan strömkälla är aktiv kan permanent skada och förstöra kameran.

Tips

Använd batterilivslängdsuppskattaren för att modellera hur länge M7 kommer att köra på ett batteri vid en given arbetscykel mellan aktivt läge och djupsömn.

Återställnings- och felsökningsstift¶

RESET — dra till GND för att återställa kortet. Att släppa det låter MCU:n starta upp normalt.
BOOT0 — dra till 3,3 V medan kortet får ström för att gå in i STM32:s ROM-startladdare (DFU-läge). OpenMV IDE använder detta läge för att flasha om den inbyggda startladdaren.

Kortet exponerar ett SWD-felsökningskontaktstycke (RST / SWCLK / SWDIO) bredvid GPIO-kontaktstycket, kompatibelt med adaptrarna ST‑LINK och SEGGER J‑Link.

Inbyggd kringutrustning¶

LED:er¶

M7 har en enda användarstyrd RGB-LED plus ett par IR-LED:er på 850 nm med hög effekt:

Användarstyrd RGB-LED — programstyrbar, exponerad som LED_RED, LED_GREEN och LED_BLUE

from machine import LED

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

IR-LED:er — båda LED:erna drivs tillsammans genom LED_IR-stiftet. LED_IR är kopplat aktiv hög i hårdvaran medan den fasta programvaran behandlar alla andra inbyggda LED:er som aktiv låga, så använd low() / high() snarare än on() / off() (vilket skulle invertera betydelsen):
```
from machine import LED

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

Kamerasensor¶

OV7725 styrs genom csi — kamerasensorer-modulen:

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

Sensorn är lödd till kortet på M7 — den sitter inte på en utbytbar modul.

microSD-kort¶

När ett kort sätts i monteras det automatiskt på /sdcard och kan användas genom det vanliga filsystemet:

import os

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

Bussreferens¶

GPIO¶

Använd machine.Pin för att läsa eller driva något av de silktryckta stiften. Utgångar är 3,3 V CMOS, 5 V-toleranta på ingångssidan, och kan sänka/driva upp till 25 mA per stift (120 mA totalt över hela kontaktstycket).

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

Vilket ingångsstift som helst kan också utlösa ett avbrott vid kanttransitioner:

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

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

UART¶

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

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

Samma hårdvara kan också användas i målläge (slavläge) genom machine.I2CTarget för att exponera ett minnesområde för en annan I²C-styrenhet:

from machine import I2CTarget

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

SPI¶

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

Buss	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 och DAC¶

P6 är det enda analoga användarstiftet. Det kan användas antingen som en 12‑bitars ADC-ingång eller en DAC-utgång.

ADC — fullskala vid 3,3 V på stiftet:

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 — genom pyb.DAC. Det 8‑bitars värdet täcker 0–3,3 V:

from pyb import DAC

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

I ADC- eller DAC-läge är P6 endast 3,3 V-tolerant — mata det inte med 5 V.

PWM¶

Stift	Timer / kanal
P4	TIM2 CH3
P5	TIM2 CH4
P6	TIM2 CH1
P7	TIM4 CH1
P8	TIM4 CH2
P9	TIM4 CH3

Anteckning

TIM1 är reserverad av den fasta programvaran för att generera kamerasensorns pixelklocka, så de TIM1-kanaler som fysiskt finns på P0/P1/P2 kan inte användas för användar-PWM utan att kameran slutar fungera.

TIM4 delas med pyb.Servo — att instansiera ett servo konfigurerar om hela timern för 50 Hz-drift, så blanda inte machine.PWM på P7/P8/P9 med pyb.Servo i samma skript.

Driv vilket som helst av dem via machine.PWM

from machine import Pin, PWM

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

Programvarustyrda bitbangade bussar¶

machine.SoftI2C och machine.SoftSPI fungerar på vilket GPIO som helst om du behöver en extra buss.

Värmesensor (extern)¶

Den fasta programvaran inkluderar drivrutinen fir — drivrutin för värmesensor (fir == far infrared) för externt kopplade värmekameror:

MLX90621 — 16 × 4 IR-array
MLX90640 — 32 × 24 IR-array
MLX90641 — 16 × 12 IR-array
AMG8833 — 8 × 8 IR-array

Koppla modulen till kortets I²C-buss och läs bildrutor med 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())

fir-drivrutinen kommunicerar med sensorn endast över I²C 2 — koppla modulen till P4 (SCL) och P5 (SDA).

Tidtagning¶

time¶

time-modulen täcker blockerande fördröjningar, monotona tick och mätning av förfluten tid:

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)

Virtuella timrar¶

machine.Timer schemalägger periodiska eller engångsåteranrop utan att förbruka en hårdvarutimerplats. Skicka -1 som id för att använda en virtuell (programvarustyrd) timer:

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

Periodvärden anges i millisekunder. Anropa deinit() för att stoppa och frigöra platsen.

Realtidsklocka¶

machine.RTC håller väggklockstiden över återställningar:

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

Vakthund¶

machine.WDT återställer kortet om applikationen hänger sig. När den väl startats kan den inte stoppas eller omkonfigureras — mata den periodiskt inuti din huvudslinga:

from machine import WDT

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

Start- och körningsinformation¶

USB-startladdarfönster¶

Vid varje påslag kör kameran en kort startladdare (några sekunder) som låter OpenMV IDE uppdatera den fasta programvaran utan att användaren behöver gå in i DFU-läge. När fönstret löper ut lämnar startladdaren över till boot.py och sedan main.py.

Ett körande skript kan gå in i startladdaren igen på begäran genom att anropa machine.bootloader()

import machine

machine.bootloader()

Filsystem och startordning¶

M7:ans fasta programvara monterar upp till tre filsystem vid start:

Internt flashminne — alltid monterat på /flash. Innehåller main.py och README.txt som standard; skapas vid allra första starten.
microSD-kort — om ett kort sätts i monteras det på /sdcard.
ROMFS — skrivskyddat, minnesmappat filsystem på /rom som används för att leverera stora datatillgångar (t.ex. AI-modeller) som gynnas av nollkopieringsåtkomst. Monteras automatiskt av MicroPython vid start, innan någon användar-Python körs.

Efter monteringen sätts arbetskatalogen till /sdcard när kortet finns, annars /flash. Tolken kör sedan skript från den katalogen:

boot.py körs vid varje mjuk återställning (kallstart, Ctrl‑D från REPL, eller närhelst det körande skriptet returnerar).
main.py körs endast vid kallstart, omedelbart efter boot.py. Efterföljande mjuka återställningar kör boot.py på nytt men hoppar direkt till REPL — för att köra main.py igen måste du helt återställa kortet.

Att lägga en boot.py eller main.py på SD-kortet åsidosätter kopian i flashminnet utan att röra den — båda filerna slås upp i startkatalogen (/sdcard när kortet är monterat, annars /flash).

Den standard-main.py som levereras på ett nyflashat kort blinkar bara den blå kanalen på den användarstyrda RGB-LED:en som en hjärtslagssignal (två korta pulser, kort mellanrum), så att du kan se att den fasta programvaran startade rent utan någon värd ansluten.

sys.path utökas till att inkludera alla tre filsystemen och deras lib/-underkataloger, så importerbara moduler kan ligga i /flash/lib, /sdcard/lib eller /rom/lib.

För att tvinga systemet att ignorera ett isatt SD-kort (till exempel för att köra main.py i flashminnet även när ett kort finns), skapa en tom fil med namnet SKIPSD i roten av /flash.

När den är ansluten via USB enumereras även startfilsystemet (/sdcard om ett kort finns, annars /flash) som en USB-masslagringsenhet på värddatorn, så att du kan redigera boot.py, main.py och andra filer direkt. Mata ut enheten innan du återställer kameran så att värddatorn tömmer sina cachade skrivningar.

Anteckning

Eftersom operativsystemet behandlar enheten som en passiv blockenhet kommer filer som skapas eller ändras av kod som körs på OpenMV Cam inte att synas förrän värddatorn monterar om enheten. Om både operativsystemet och OpenMV Cam skriver till samma filsystem samtidigt kommer operativsystemet att vinna och skriva över ändringar som kameran gjort. Använd SD-kortet för all data som skriptet skriver tillbaka, och montera om innan du läser dessa filer från värddatorn.

Anteckning

Den röda kanalen på den användarstyrda RGB-LED:en kan kort lysa upp medan värddatorn läser från eller skriver till USB-masslagringsenheten — detta är en aktivitetsindikator driven av den fasta programvaran, inte ett fel.

Lagringsstorlekar¶

M7 levereras med:

/flash — 96 KB FAT-filsystem, läs/skriv.
/rom — 256 KB skrivskyddat minnesmappat ROMFS.
/sdcard — full storlek på vilket microSD-kort som än sätts i (när det finns), läs/skriv.

Hårdfelsindikator¶

Om den användarstyrda RGB-LED:en snabbt cyklar genom alla färger — tillräckligt snabbt för att det tenderar att se ut som en glittrande vit LED snarare än distinkta nyanser — har den fasta programvaran träffat på ett oåterställbart hårdfel. Flasha om den fasta programvaran för att återställa; om omflashning inte hjälper kan kortet vara fysiskt skadat.

Programvarubibliotek¶

Se biblioteksindexet för den fullständiga listan över moduler — inklusive vilka som är unika för M7-bygget.