OpenMV Cam M7

De OpenMV Cam M7 is een Cortex‑M7 machine vision‑bord opgebouwd rond de STMicroelectronics STM32F765 op 216 MHz met 512 KB intern SRAM en 2 MB intern flashgeheugen. De meegeleverde OV7725-sensor legt 640×480 grijswaarden- of 320×240 RGB565-frames vast tot 150 FPS, en de 10‑pins gebruikersheader stelt UART, I²C, SPI, CAN, ADC/DAC en PWM-randapparaten beschikbaar.

Voor de volledige datasheet, foto’s en afmetingen zie de OpenMV Cam M7-productpagina.

Hoogtepunten

• STMicroelectronics STM32F765 Cortex‑M7 op 216 MHz.

• 512 KB intern SRAM — geen extern SDRAM.

• 2 MB intern flashgeheugen (geen extern QSPI-flashgeheugen).

• OV7725-sensor — 640×480 grijswaarden of 320×240 RGB565 tot 150 FPS.

• Full‑speed USB (12 Mb/s) — verschijnt als VCP + USB-massaopslag bij de host.

• microSD-aansluiting — SD tot 2 GB, SDHC tot 32 GB, SDXC tot 2 TB.

• 10 I/O-pinnen, 5 V-tolerant met 3,3 V-uitgang, 25 mA per pin (120 mA totaal over de header), interrupt-geschikt. P6 is niet 5 V-tolerant wanneer gebruikt in ADC- of DAC-modus.

• Gebruikers-RGB-LED en twee 850 nm IR-LED’s met hoog vermogen voor actieve verlichting bij vision in weinig licht.

Notitie

De M7 heeft geen ingebouwde voedingsbeheerchip: er is geen accuaansluiting, geen acculader, geen ADC voor accuspanning, geen oplaad- / voedingsstatus-LED’s en geen hardwarematige aan/uitknop. Voed het bord via USB of VIN.

Pinout

Pinreferentie

Pinnaam	Functie
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	naar GND trekken om het bord te resetten
SYN	frame‑sync-pad — alleen bedraad naar de camerasensor
BOOT0	naar 3,3 V trekken bij inschakelen voor DFU / ROM-bootloader
LED_RED	rood kanaal van de RGB-LED (actief laag)
LED_GREEN	groen kanaal van de RGB-LED (actief laag)
LED_BLUE	blauw kanaal van de RGB-LED (actief laag)
LED_IR	IR-LED’s met hoog vermogen (beide kanalen samen aangestuurd)

Notitie

De SYN-pad op de header is rechtstreeks verbonden met de trigger- / belichtingslijn van de camerasensor — op de M7 loopt deze niet naar de MCU. Stuur of lees hem extern aan; je kunt hem niet vanuit MicroPython schakelen.

Voedingspinnen

• 3.3V — gereguleerde 3,3 V-rail. Tot 250 mA beschikbaar voor shields (minder als de microSD-kaart in gebruik is). Anders dan bij de nieuwere camera’s is deze pin bidirectioneel — zie de waarschuwing hieronder.

• VIN — 3,6 – 5 V-ingang. Voedt het bord via de ingebouwde regelaar.

• GND — gemeenschappelijke massa.

Notitie

Wanneer zowel USB als VIN aanwezig zijn, voedt degene met de hogere spanning het bord — de ingebouwde diodes kiezen simpelweg de sterkere rail.

Waarschuwing

Je mag de M7 voeden door 3,3 V rechtstreeks op de 3.3V-pin te zetten als je de ingebouwde regelaar wilt omzeilen. Sluit in dat geval niet tegelijkertijd ook VIN- of USB-voeding aan — het terugvoeden van de regelaar terwijl een andere voeding actief is, kan de camera permanent beschadigen en vernielen.

Tip

Gebruik de accuduurschatter om te modelleren hoe lang de M7 op een accu draait bij een gegeven actief- / diepe-slaap-belastingsverhouding.

Herstel- en debugpinnen

• RESET — naar GND trekken om het bord te resetten. Door hem los te laten start de MCU normaal op.

• BOOT0 — naar 3,3 V trekken terwijl het bord wordt gevoed om de STM32 ROM-bootloader (DFU-modus) te starten. OpenMV IDE gebruikt deze modus om de ingebouwde bootloader opnieuw te flashen.

Het bord stelt een SWD-debugheader (RST / SWCLK / SWDIO) beschikbaar naast de GPIO-header, compatibel met ST‑LINK- en SEGGER J‑Link-adapters.

Ingebouwde randapparaten

LED’s

De M7 heeft één gebruikers-RGB-LED plus een paar 850 nm IR-LED’s met hoog vermogen:

• Gebruikers-RGB-LED — softwarematig bestuurbaar, beschikbaar als LED_RED, LED_GREEN en LED_BLUE

  from machine import LED
  
  LED("LED_RED").on()
  LED("LED_GREEN").on()
  LED("LED_BLUE").on()
  

• IR-LED’s — beide LED’s worden samen aangestuurd via de LED_IR-pin. LED_IR is in hardware actief hoog bedraad, terwijl de firmware elke andere ingebouwde LED als actief laag behandelt, dus gebruik low() / high() in plaats van on() / off() (die de logica zouden omkeren):

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

Camerasensor

De OV7725 wordt aangestuurd via de csi — camerasensoren-module:

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

De sensor is op de M7 op het bord gesoldeerd — hij zit niet op een verwisselbare module.

microSD-kaart

Wanneer een kaart is geplaatst, wordt deze automatisch aangekoppeld op /sdcard en is bruikbaar via het reguliere bestandssysteem:

import os

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

Busreferentie

GPIO

Gebruik machine.Pin om een van de op de zeefdruk aangegeven pinnen te lezen of aan te sturen. Uitgangen zijn 3,3 V CMOS, 5 V-tolerant aan de ingangszijde en kunnen tot 25 mA per pin sinken/sourcen (120 mA totaal over de hele header).

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

Elke ingangspin kan ook een interrupt afvuren bij randovergangen:

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

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

UART

Bus	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

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

Dezelfde hardware kan ook in target- (slave-)modus worden gebruikt via machine.I2CTarget om een geheugengebied beschikbaar te stellen aan een andere I²C-controller:

from machine import I2CTarget

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

SPI

Bus	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

Bus	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 en DAC

P6 is de enige analoge gebruikerspin. Hij kan worden gebruikt als 12‑bits ADC-ingang of als DAC-uitgang.

• ADC — volledige schaal bij 3,3 V op de 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 — via pyb.DAC. De 8‑bits waarde dekt 0–3,3 V:

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

In ADC- of DAC-modus is P6 uitsluitend 3,3 V-tolerant — voed hem geen 5 V.

PWM

Pin	Timer / kanaal
P4	TIM2 CH3
P5	TIM2 CH4
P6	TIM2 CH1
P7	TIM4 CH1
P8	TIM4 CH2
P9	TIM4 CH3

Notitie

TIM1 is gereserveerd door de firmware om de pixelklok van de camerasensor te genereren, dus de TIM1-kanalen die fysiek op P0/P1/P2 zitten, kunnen niet voor gebruikers-PWM worden gebruikt zonder de camera te verstoren.

TIM4 wordt gedeeld met pyb.Servo — het instantiëren van een servo herconfigureert de hele timer voor 50 Hz-werking, dus combineer machine.PWM op P7/P8/P9 niet met pyb.Servo in hetzelfde script.

Stuur er een van aan via machine.PWM

from machine import Pin, PWM

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

Softwarematig bit‑banged bussen

machine.SoftI2C en machine.SoftSPI werken op elke GPIO als je een extra bus nodig hebt.

Thermische sensor (extern)

De firmware bevat de fir — thermische sensor-driver (fir == far infrared)-driver voor extern bedrade thermische imagers:

• MLX90621 — 16 × 4 IR-array

• MLX90640 — 32 × 24 IR-array

• MLX90641 — 16 × 12 IR-array

• AMG8833 — 8 × 8 IR-array

Verbind de module met de I²C-bus van het bord en lees frames met 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())

De fir-driver communiceert alleen met de sensor via I²C 2 — verbind de module met P4 (SCL) en P5 (SDA).

Timing

time

De time-module dekt blokkerende vertragingen, monotone ticks en het meten van verstreken tijd:

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)

Virtuele timers

machine.Timer plant periodieke of eenmalige callbacks zonder een hardwaretimerslot te verbruiken. Geef -1 als id op om een virtuele (software)timer te gebruiken:

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

Periodewaarden zijn in milliseconden. Roep deinit() aan om te stoppen en het slot vrij te geven.

Realtimeklok

machine.RTC houdt de kloktijd bij over resets heen:

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 reset het bord als de applicatie vastloopt. Eenmaal gestart kan hij niet worden gestopt of geherconfigureerd — voed hem periodiek binnen je hoofdlus:

from machine import WDT

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

Boot- en runtime-informatie

USB-bootloadervenster

Bij elke inschakeling draait de camera een korte bootloader (enkele seconden) waarmee OpenMV IDE de firmware kan bijwerken zonder dat de gebruiker de DFU-modus hoeft te starten. Nadat het venster verstrijkt, draagt de bootloader over aan boot.py en vervolgens main.py.

Een draaiend script kan op verzoek de bootloader opnieuw starten door machine.bootloader() aan te roepen:

import machine

machine.bootloader()

Bestandssysteem en bootvolgorde

De M7-firmware koppelt bij het opstarten tot drie bestandssystemen aan:

• Intern flashgeheugen — altijd aangekoppeld op /flash. Bevat standaard main.py en README.txt; aangemaakt bij de allereerste boot.

• microSD-kaart — als een kaart is geplaatst, wordt deze aangekoppeld op /sdcard.

• ROMFS — alleen-lezen, in geheugen gemapt bestandssysteem op /rom dat wordt gebruikt om grote data-assets te leveren (bijv. AI-modellen) die baat hebben bij zero‑copy-toegang. Wordt bij het opstarten automatisch door MicroPython aangekoppeld, vóór enige gebruikers-Python draait.

Na het aankoppelen wordt de werkmap ingesteld op /sdcard wanneer de kaart aanwezig is, anders /flash. De interpreter draait dan scripts vanuit die map:

• boot.py wordt uitgevoerd bij elke soft reset (koude boot, Ctrl‑D vanuit de REPL, of telkens wanneer het draaiende script terugkeert).

• main.py wordt alleen bij koude boot uitgevoerd, direct na boot.py. Volgende soft resets draaien boot.py opnieuw maar gaan direct naar de REPL — om main.py opnieuw te draaien moet je het bord volledig resetten.

Het neerzetten van een boot.py of main.py op de SD-kaart overschrijft de kopie in het flashgeheugen zonder deze aan te raken — beide bestanden worden opgezocht in de bootmap (/sdcard wanneer de kaart is aangekoppeld, anders /flash).

De standaard main.py die op een net geflasht bord wordt geleverd, knippert alleen het blauwe kanaal van de gebruikers-RGB-LED als hartslag (twee korte pulsen, korte pauze), zodat je kunt zien dat de firmware netjes is opgestart zonder dat er een host is aangesloten.

sys.path wordt uitgebreid met alle drie de bestandssystemen en hun lib/-submappen, zodat importeerbare modules kunnen staan in /flash/lib, /sdcard/lib of /rom/lib.

Om het systeem te dwingen een geplaatste SD-kaart te negeren (bijvoorbeeld om de main.py in het flashgeheugen te draaien zelfs met een kaart aanwezig), maak je een leeg bestand met de naam SKIPSD in de root van /flash.

Wanneer verbonden via USB, wordt het bootbestandssysteem (/sdcard als een kaart aanwezig is, anders /flash) ook geënumereerd als een USB-massaopslagstation op de host, waarmee je boot.py, main.py en andere bestanden rechtstreeks kunt bewerken. Werp het station uit voordat je de camera reset zodat de host zijn gecachete schrijfbewerkingen wegschrijft.

Notitie

Omdat het besturingssysteem het station als een passief blokapparaat behandelt, verschijnen bestanden die zijn aangemaakt of gewijzigd door code die op de OpenMV Cam draait pas wanneer de host het station opnieuw aankoppelt. Als zowel het besturingssysteem als de OpenMV Cam tegelijkertijd naar hetzelfde bestandssysteem schrijven, wint het besturingssysteem en overschrijft het de wijzigingen van de camera. Gebruik de SD-kaart voor alle data die het script terugschrijft, en koppel opnieuw aan voordat je die bestanden vanaf de host leest.

Notitie

Het rode kanaal van de gebruikers-RGB-LED kan kort oplichten terwijl de host leest van of schrijft naar het USB-massaopslagstation — dit is een door de firmware aangestuurde activiteitsindicator, geen fout.

Opslaggroottes

De M7 wordt geleverd met:

• /flash — 96 KB FAT-bestandssysteem, lezen/schrijven.

• /rom — 256 KB alleen-lezen in geheugen gemapt ROMFS.

• /sdcard — volledige grootte van welke microSD-kaart dan ook is geplaatst (indien aanwezig), lezen/schrijven.

Hard‑fault-indicator

Als de gebruikers-RGB-LED snel door alle kleuren cyclet — snel genoeg dat het eerder op een flikkerende witte LED lijkt dan op afzonderlijke tinten — dan heeft de firmware een onherstelbare hard fault opgelopen. Flash de firmware opnieuw om te herstellen; als opnieuw flashen niet helpt, is het bord mogelijk fysiek beschadigd.

Softwarebibliotheken

Zie de bibliotheekindex voor de volledige lijst met modules — inclusief welke uniek zijn voor de M7-build.