OpenMV Cam M7

La OpenMV Cam M7 è una scheda per visione artificiale Cortex‑M7 basata sullo STMicroelectronics STM32F765 a 216 MHz con 512 KB di SRAM interna e 2 MB di flash interna. Il sensore OV7725 in dotazione acquisisce frame 640×480 in scala di grigi oppure 320×240 RGB565 fino a 150 FPS, e il connettore utente a 10 pin espone periferiche UART, I²C, SPI, CAN, ADC/DAC e PWM.

OpenMV Cam M7

Per il datasheet completo, le foto e le dimensioni consulta la pagina prodotto OpenMV Cam M7.

Punti salienti

  • STMicroelectronics STM32F765 Cortex‑M7 a 216 MHz.

  • 512 KB di SRAM interna — nessuna SDRAM esterna.

  • 2 MB di flash interna (nessuna flash QSPI esterna).

  • Sensore OV7725 — 640×480 in scala di grigi oppure 320×240 RGB565 fino a 150 FPS.

  • USB Full‑speed (12 Mb/s) — appare come VCP + memoria di massa USB sull’host.

  • Slot microSD — SD fino a 2 GB, SDHC fino a 32 GB, SDXC fino a 2 TB.

  • 10 pin di I/O, 5 V tolerant con uscita a 3,3 V, 25 mA per pin (120 mA totali sul connettore), in grado di gestire interrupt. P6 non è 5 V tolerant quando usato in modalità ADC o DAC.

  • LED RGB utente e due LED IR 850 nm ad alta potenza per l’illuminazione attiva nella visione in condizioni di scarsa luminosità.

Nota

La M7 non dispone di un chip di gestione dell’alimentazione a bordo: non ci sono connettore per batteria, caricabatteria, ADC per la tensione della batteria, LED di stato carica / alimentazione, né pulsante di accensione hardware. Alimenta la scheda tramite USB o VIN.

Pinout

Pinout OpenMV Cam M7 OV7725

Riferimento pin

Nome pin

Funzione

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

collega a GND per resettare la scheda

SYN

pad di frame‑sync — cablato solo al sensore della camera

BOOT0

collega a 3,3 V all’accensione per il bootloader DFU / ROM

LED_RED

canale rosso del LED RGB (attivo basso)

LED_GREEN

canale verde del LED RGB (attivo basso)

LED_BLUE

canale blu del LED RGB (attivo basso)

LED_IR

LED IR ad alta potenza (entrambi i canali pilotati insieme)

Nota

Il pad SYN sul connettore è collegato direttamente alla linea di trigger / esposizione del sensore della camera — sulla M7 non è instradato al MCU. Pilotalo o leggilo esternamente; non puoi commutarlo da MicroPython.

Pin di alimentazione

  • 3.3V — linea regolata a 3,3 V. Fino a 250 mA disponibili per gli shield (meno se la scheda microSD è in uso). A differenza delle camere più recenti questo pin è bidirezionale — vedi l’avviso più sotto.

  • VIN — ingresso 3,6 – 5 V. Alimenta la scheda attraverso il regolatore a bordo.

  • GND — massa comune.

Nota

Quando sono presenti sia USB che VIN, alimenta la scheda quella con la tensione più alta — i diodi a bordo selezionano semplicemente la linea più forte.

Avvertimento

Puoi alimentare la M7 fornendo 3,3 V direttamente al pin 3.3V se non vuoi passare attraverso il regolatore a bordo. In tal caso, non applicare contemporaneamente anche VIN o l’alimentazione USB — il back‑driving del regolatore mentre è attiva un’altra alimentazione può danneggiare e distruggere permanentemente la camera.

Suggerimento

Usa lo stimatore della durata della batteria per modellare quanto a lungo la M7 funzionerà a batteria per un dato duty cycle attivo / deep-sleep.

Pin di ripristino e debug

  • RESET — collega a GND per resettare la scheda. Rilasciandolo il MCU si avvia normalmente.

  • BOOT0 — collega a 3,3 V mentre alimenti la scheda per entrare nel bootloader ROM dell’STM32 (modalità DFU). OpenMV IDE usa questa modalità per riprogrammare il bootloader a bordo.

La scheda espone un connettore di debug SWD (RST / SWCLK / SWDIO) accanto al connettore GPIO, compatibile con gli adattatori ST‑LINK e SEGGER J‑Link.

Periferiche a bordo

LED

La M7 ha un singolo LED RGB utente più una coppia di LED IR 850 nm ad alta potenza:

  • LED RGB utente — controllabile via software, esposto come LED_RED, LED_GREEN e LED_BLUE

    from machine import LED

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

  • LED IR — entrambi i LED sono pilotati insieme attraverso il pin LED_IR. LED_IR è cablato attivo alto in hardware mentre il firmware tratta ogni altro LED a bordo come attivo basso, quindi usa low() / high() invece di on() / off() (che invertirebbero il senso):

    from machine import LED

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

Sensore della camera

L’OV7725 è pilotato attraverso il modulo csi — sensori camera

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

Sulla M7 il sensore è saldato alla scheda — non si trova su un modulo intercambiabile.

Scheda microSD

Quando viene inserita una scheda, viene montata automaticamente su /sdcard ed è utilizzabile attraverso il normale file system:

import os

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

Riferimento bus

GPIO

Usa machine.Pin per leggere o pilotare uno qualsiasi dei pin serigrafati. Le uscite sono CMOS a 3,3 V, 5 V tolerant sul lato ingresso, e possono assorbire/erogare fino a 25 mA per pin (120 mA totali sull’intero connettore).

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

Qualsiasi pin di ingresso può anche generare un interrupt sulle transizioni di fronte:

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

Lo stesso hardware può essere usato anche in modalità target (slave) attraverso machine.I2CTarget per esporre una regione di memoria a un altro controller I²C:

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 e DAC

P6 è l’unico pin analogico utente. Può essere usato come ingresso ADC a 12 bit oppure come uscita DAC.

  • ADC — fondo scala a 3,3 V al 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 — attraverso pyb.DAC. Il valore a 8 bit copre 0–3,3 V:

    from pyb import DAC

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

In modalità ADC o DAC P6 è solo 3,3 V tolerant — non fornirgli 5 V.

PWM

Pin

Timer / canale

P4

TIM2 CH3

P5

TIM2 CH4

P6

TIM2 CH1

P7

TIM4 CH1

P8

TIM4 CH2

P9

TIM4 CH3

Nota

TIM1 è riservato dal firmware per generare il pixel clock del sensore della camera, quindi i canali TIM1 fisicamente presenti su P0/P1/P2 non possono essere usati per il PWM utente senza compromettere la camera.

TIM4 è condiviso con pyb.Servo — istanziare un servo riconfigura l’intero timer per il funzionamento a 50 Hz, quindi non mescolare machine.PWM su P7/P8/P9 con pyb.Servo nello stesso script.

Pilota uno qualsiasi di essi tramite machine.PWM

from machine import Pin, PWM

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

Bus software bit‑banged

machine.SoftI2C e machine.SoftSPI funzionano su qualsiasi GPIO se hai bisogno di un bus aggiuntivo.

Sensore termico (esterno)

Il firmware include il driver fir — driver del sensore termico (fir == far infrared) per imager termici cablati esternamente:

  • MLX90621 — array IR 16 × 4

  • MLX90640 — array IR 32 × 24

  • MLX90641 — array IR 16 × 12

  • AMG8833 — array IR 8 × 8

Cabla il modulo al bus I²C della scheda e leggi i frame con 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())

Il driver fir comunica con il sensore solo tramite I²C 2 — cabla il modulo a P4 (SCL) e P5 (SDA).

Temporizzazione

time

Il modulo time copre i ritardi bloccanti, i tick monotoni e la misurazione del tempo trascorso:

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)

Timer virtuali

machine.Timer programma callback periodici o one‑shot senza occupare uno slot di timer hardware. Passa -1 come id per usare un timer virtuale (software):

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

I valori di periodo sono in millisecondi. Chiama deinit() per fermare e rilasciare lo slot.

Real‑time clock

machine.RTC mantiene l’orario di parete attraverso i reset:

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 resetta la scheda se l’applicazione si blocca. Una volta avviato non può essere fermato o riconfigurato — alimentalo periodicamente all’interno del tuo loop principale:

from machine import WDT

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

Informazioni di boot e runtime

Finestra del bootloader USB

A ogni accensione la camera esegue un breve bootloader (alcuni secondi) che consente a OpenMV IDE di aggiornare il firmware senza che l’utente debba entrare in modalità DFU. Allo scadere della finestra il bootloader passa il controllo a boot.py e quindi a main.py.

Uno script in esecuzione può rientrare nel bootloader su richiesta chiamando machine.bootloader()

import machine

machine.bootloader()

Filesystem e ordine di boot

Il firmware della M7 monta fino a tre filesystem al boot:

  • Flash interna — sempre montata su /flash. Contiene per impostazione predefinita main.py e README.txt; creata al primissimo boot.

  • Scheda microSD — se è inserita una scheda, viene montata su /sdcard.

  • ROMFS — filesystem di sola lettura, mappato in memoria, su /rom usato per distribuire grandi asset di dati (ad esempio modelli AI) che beneficiano dell’accesso zero‑copy. Montato automaticamente da MicroPython all’avvio, prima dell’esecuzione di qualsiasi codice Python utente.

Dopo il montaggio, la directory di lavoro è impostata su /sdcard quando la scheda è presente, altrimenti su /flash. L’interprete esegue quindi gli script da quella directory:

  • boot.py viene eseguito a ogni soft reset (cold boot, Ctrl‑D dal REPL, o ogni volta che lo script in esecuzione termina).

  • main.py viene eseguito solo al cold boot, subito dopo boot.py. I soft reset successivi rieseguono boot.py ma passano direttamente al REPL — per rieseguire main.py devi resettare completamente la scheda.

Inserendo un boot.py o un main.py sulla scheda SD si sovrascrive la copia in flash senza toccarla — entrambi i file vengono cercati nella directory di boot (/sdcard quando la scheda è montata, altrimenti /flash).

Il main.py predefinito fornito su una scheda appena programmata si limita a far lampeggiare il canale blu del LED RGB utente come battito cardiaco (due brevi impulsi, breve pausa), così puoi capire che il firmware si è avviato correttamente senza alcun host collegato.

sys.path viene esteso per includere tutti e tre i filesystem e le loro sottodirectory lib/, così i moduli importabili possono risiedere in /flash/lib, /sdcard/lib o /rom/lib.

Per forzare il sistema a ignorare una scheda SD inserita (ad esempio per eseguire il main.py in flash anche con una scheda presente), crea un file vuoto chiamato SKIPSD nella radice di /flash.

Quando è connessa via USB, il filesystem di boot (/sdcard se è presente una scheda, altrimenti /flash) viene enumerato anche come unità di memoria di massa USB sull’host, permettendoti di modificare boot.py, main.py e qualsiasi altro file direttamente. Espelli l’unità prima di resettare la camera così l’host scarica le sue scritture memorizzate in cache.

Nota

Poiché il sistema operativo tratta l’unità come un dispositivo a blocchi passivo, i file creati o modificati dal codice in esecuzione sulla OpenMV Cam non compariranno finché l’host non rimonta l’unità. Se sia il sistema operativo sia la OpenMV Cam scrivono sullo stesso filesystem nello stesso momento, il sistema operativo vincerà e sovrascriverà le modifiche fatte dalla camera. Usa la scheda SD per qualsiasi dato che lo script riscrive, e rimonta prima di leggere quei file dall’host.

Nota

Il canale rosso del LED RGB utente potrebbe accendersi brevemente mentre l’host legge o scrive sull’unità di memoria di massa USB — è un indicatore di attività gestito dal firmware, non un guasto.

Dimensioni di archiviazione

La M7 viene fornita con:

  • /flash — filesystem FAT da 96 KB, lettura/scrittura.

  • /rom — ROMFS di sola lettura mappato in memoria da 256 KB.

  • /sdcard — dimensione completa della scheda microSD inserita (quando presente), lettura/scrittura.

Indicatore di hard‑fault

Se il LED RGB utente sta ciclando rapidamente attraverso tutti i colori — abbastanza velocemente da sembrare un LED bianco scintillante piuttosto che tonalità distinte — il firmware ha incontrato un hard fault irrecuperabile. Riprogramma il firmware per recuperare; se la riprogrammazione non aiuta, la scheda potrebbe essere fisicamente danneggiata.

Librerie software

Consulta l”indice delle librerie per l’elenco completo dei moduli — inclusi quelli esclusivi della build M7.