OpenMV Cam M7¶

ה‑OpenMV Cam M7 הוא לוח ראייה ממוחשבת מבוסס Cortex‑M7 הבנוי סביב STM32F765 של STMicroelectronics בתדר 216 MHz עם 512 KB של SRAM פנימי ו‑2 MB של זיכרון פלאש (flash) פנימי. החיישן OV7725 המצורף לוכד פריימים של 640×480 בגווני אפור או 320×240 ב‑RGB565 בקצב של עד 150 FPS, וכותרת המשתמש בעלת 10 הפינים חושפת התקנים היקפיים מסוג UART, I²C, SPI, CAN, ADC/DAC ו‑PWM.

לדף נתונים מלא, תמונות ומידות ראו את דף המוצר של OpenMV Cam M7.

עיקרי הדברים¶

STM32F765 של STMicroelectronics מסוג Cortex‑M7 בתדר 216 MHz.
512 KB של SRAM פנימי — ללא SDRAM חיצוני.
2 MB של זיכרון פלאש (flash) פנימי (ללא זיכרון פלאש QSPI חיצוני).
חיישן OV7725 — 640×480 בגווני אפור או 320×240 ב‑RGB565 בקצב של עד 150 FPS.
USB במהירות מלאה (12 Mb/s) — מופיע כ‑VCP וכאחסון המוני USB בפני המארח.
שקע microSD — SD עד 2 GB, SDHC עד 32 GB, SDXC עד 2 TB.
10 פיני I/O, סובלניים ל‑5 V עם פלט של 3.3 V, 25 mA לכל פין (120 mA בסך הכל לאורך הכותרת), עם יכולת פסיקה. P6 אינו סובלני ל‑5 V כאשר משתמשים בו במצב ADC או DAC.
נורית RGB LED למשתמש ושתי נוריות IR LED עוצמתיות בתדר 850 ננומטר לתאורה אקטיבית בראייה בתנאי תאורה נמוכה.

הערה

ל‑M7 אין שבב ניהול חשמל על הלוח: אין מחבר סוללה, אין מטען סוללה, אין ADC למתח סוללה, אין נוריות LED למצב טעינה / חשמל, ואין כפתור הפעלה חומרתי. הזינו את הלוח דרך USB או VIN.

מפת פינים¶

סימוכין לפינים¶

שם הפין	פונקציה
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 כדי לאפס את הלוח
SYN	פד סנכרון פריימים — מחווט אך ורק לחיישן המצלמה
BOOT0	משכו ל‑3.3 V בעת ההפעלה עבור DFU / מאתחל (bootloader) ROM
LED_RED	ערוץ אדום של נורית RGB LED (פעיל בנמוך)
LED_GREEN	ערוץ ירוק של נורית RGB LED (פעיל בנמוך)
LED_BLUE	ערוץ כחול של נורית RGB LED (פעיל בנמוך)
LED_IR	נוריות IR LED עוצמתיות (שני הערוצים מונעים יחד)

הערה

פד ה‑SYN שעל הכותרת מחובר ישירות לקו ההדק / החשיפה של חיישן המצלמה — הוא אינו מנותב ל‑MCU ב‑M7. הנֵיעו או קראו אותו חיצונית; לא ניתן לשנות את מצבו מתוך MicroPython.

פיני חשמל¶

3.3V — פס מתח מיוצב של 3.3 V. עד 250 mA זמינים עבור מגנים (פחות אם כרטיס ה‑microSD בשימוש). בניגוד למצלמות החדשות יותר, פין זה דו‑כיווני — ראו את האזהרה למטה.
VIN — כניסת 3.6 – 5 V. מזינה את הלוח דרך הרגולטור שעל הלוח.
GND — הארקה משותפת.

הערה

כאשר גם USB וגם VIN נוכחים, זה שלו המתח הגבוה יותר מזין את הלוח — הדיודות שעל הלוח פשוט בוחרות את הפס החזק יותר.

אזהרה

ניתן להזין את ה‑M7 על ידי הזרמת 3.3 V ישירות אל פין ה‑3.3V אם אינכם רוצים לעבור דרך הרגולטור שעל הלוח. במקרה זה, אל תפעילו גם VIN או חשמל USB באותו הזמן — הזרמה לאחור אל הרגולטור בזמן שמקור חשמל אחר פעיל עלולה לפגוע באופן בלתי הפיך ולהשמיד את המצלמה.

טיפ

השתמשו במעריך חיי הסוללה כדי להעריך כמה זמן ה‑M7 יפעל על סוללה עבור מחזור פעולה נתון של פעילות / שינה עמוקה.

פיני שחזור וניפוי באגים¶

RESET — משכו ל‑GND כדי לאפס את הלוח. שחרורו מאפשר ל‑MCU להתחיל לפעול כרגיל.
BOOT0 — משכו ל‑3.3 V בזמן הזנת הלוח כדי להיכנס למאתחל (bootloader) ה‑ROM של STM32 (מצב DFU). OpenMV IDE משתמש במצב זה כדי לצרוב מחדש את המאתחל (bootloader) שעל הלוח.

הלוח חושף כותרת ניפוי באגים מסוג SWD (RST / SWCLK / SWDIO) ליד כותרת ה‑GPIO, תואמת למתאמי ST‑LINK ו‑SEGGER J‑Link.

התקנים היקפיים על הלוח¶

נוריות LED¶

ל‑M7 יש נורית RGB LED יחידה למשתמש בתוספת זוג נוריות IR LED עוצמתיות בתדר 850 ננומטר:

נורית RGB LED למשתמש — ניתנת לשליטה בתוכנה, חשופה כ‑LED_RED, LED_GREEN ו‑LED_BLUE
```
from machine import LED

LED("LED_RED").on()
LED("LED_GREEN").on()
LED("LED_BLUE").on()
```
נוריות IR LED — שתי הנוריות מונעות יחד דרך פין ה‑LED_IR. LED_IR מחווט פעיל בגבוה בחומרה בעוד שהקושחה מתייחסת לכל נורית LED אחרת שעל הלוח כפעילה בנמוך, ולכן השתמשו בlow() / high() במקום בon() / off() (שהיו הופכים את הכיווניות):
```
from machine import LED

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

חיישן המצלמה¶

ה‑OV7725 מונע דרך המודול csi — חיישני מצלמה

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

החיישן מולחם ללוח ב‑M7 — הוא אינו נמצא על מודול ניתן להחלפה.

כרטיס microSD¶

כאשר כרטיס מוכנס הוא מותקן אוטומטית ב‑/sdcard וניתן להשתמש בו דרך מערכת הקבצים הרגילה:

import os

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

סימוכין לאפיקים¶

GPIO¶

השתמשו בmachine.Pin כדי לקרוא או להניע כל אחד מהפינים המסומנים. הפלטים הם 3.3 V CMOS, סובלניים ל‑5 V בצד הקלט, ויכולים לשאוב/לספק עד 25 mA לכל פין (120 mA בסך הכל לאורך כל הכותרת).

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

כל פין קלט יכול גם להפעיל פסיקה במעברי קצה:

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

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

UART¶

אפיק	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¶

אפיק	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")

ניתן להשתמש באותה חומרה גם במצב יעד (slave) דרך machine.I2CTarget כדי לחשוף אזור זיכרון לבקר I²C אחר:

from machine import I2CTarget

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

SPI¶

אפיק	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¶

אפיק	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 ו‑DAC¶

P6 הוא פין האנלוגי היחיד למשתמש. ניתן להשתמש בו כקלט ADC של 12 ביט או כפלט DAC.

ADC — סקאלה מלאה ב‑3.3 V בפין:

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 — דרך pyb.DAC. הערך של 8 ביט מכסה 0–3.3 V:

from pyb import DAC

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

במצב ADC או DAC פין P6 סובלני ל‑3.3 V בלבד — אל תזינו אותו ב‑5 V.

PWM¶

פין	טיימר / ערוץ
P4	TIM2 CH3
P5	TIM2 CH4
P6	TIM2 CH1
P7	TIM4 CH1
P8	TIM4 CH2
P9	TIM4 CH3

הערה

TIM1 שמור על ידי הקושחה לצורך יצירת שעון הפיקסלים של חיישן המצלמה, ולכן לא ניתן להשתמש בערוצי TIM1 הנמצאים פיזית על P0/P1/P2 עבור PWM של המשתמש מבלי לשבש את המצלמה.

TIM4 משותף עם pyb.Servo — יצירת מופע של סרוו מגדירה מחדש את הטיימר כולו לפעולה ב‑50 Hz, ולכן אל תערבבו machine.PWM על P7/P8/P9 עם pyb.Servo באותו הסקריפט.

הניעו כל אחד מהם דרך machine.PWM

from machine import Pin, PWM

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

אפיקים בשיטת bit‑bang תוכנתית¶

machine.SoftI2C ו‑machine.SoftSPI פועלים על כל GPIO אם דרוש לכם אפיק נוסף.

חיישן תרמי (חיצוני ללוח)¶

הקושחה כוללת את מנהל ההתקן fir — מנהל התקן לחיישן תרמי (fir == far infrared) עבור מצלמות תרמיות המחווטות חיצונית:

MLX90621 — מערך IR של 16 × 4
MLX90640 — מערך IR של 32 × 24
MLX90641 — מערך IR של 16 × 12
AMG8833 — מערך IR של 8 × 8

חווטו את המודול לאפיק ה‑I²C של הלוח וקראו פריימים עם 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 מתקשר עם החיישן רק דרך I²C 2 — חווטו את המודול ל‑P4 (SCL) ול‑P5 (SDA).

תזמון¶

time¶

המודול time מכסה השהיות חוסמות, ספירת ticks מונוטונית, ומדידת זמן שחלף:

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)

טיימרים וירטואליים¶

machine.Timer מתזמן פונקציות callback מחזוריות או חד‑פעמיות מבלי לצרוך משבצת טיימר חומרתי. העבירו -1 כ‑id כדי להשתמש בטיימר וירטואלי (תוכנתי):

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

ערכי המחזור הם במילישניות. קראו לdeinit() כדי לעצור ולשחרר את המשבצת.

שעון זמן אמת¶

machine.RTC שומר על שעון קיר חוצה איפוסים:

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 מאפס את הלוח אם היישום נתקע. ברגע שהופעל לא ניתן לעצור אותו או להגדירו מחדש — האכילו אותו מחזורית בתוך הלולאה הראשית שלכם:

from machine import WDT

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

מידע על אתחול וזמן ריצה¶

חלון מאתחל ה‑USB¶

בכל הפעלה המצלמה מריצה מאתחל (bootloader) קצר (כמה שניות) המאפשר ל‑OpenMV IDE לעדכן את הקושחה מבלי שהמשתמש יצטרך להיכנס למצב DFU. לאחר שהחלון פג, המאתחל מעביר את השליטה ל‑boot.py ולאחר מכן ל‑main.py.

סקריפט פעיל יכול להיכנס מחדש למאתחל לפי דרישה על ידי קריאה לmachine.bootloader()

import machine

machine.bootloader()

מערכת הקבצים וסדר האתחול¶

קושחת ה‑M7 מתקינה עד שלוש מערכות קבצים באתחול:

זיכרון פלאש (flash) פנימי — תמיד מותקן ב‑/flash. מחזיק את main.py ואת README.txt כברירת מחדל; נוצר באתחול הראשון ביותר.
כרטיס microSD — אם כרטיס מוכנס הוא מותקן ב‑/sdcard.
ROMFS — מערכת קבצים לקריאה בלבד הממופית לזיכרון, ב‑/rom, המשמשת לאחסון נכסי נתונים גדולים (למשל מודלים של AI) שנהנים מגישה ללא העתקה. מותקנת אוטומטית על ידי MicroPython בעת ההפעלה, לפני שכל קוד Python של המשתמש רץ.

לאחר ההתקנה, ספריית העבודה נקבעת ל‑/sdcard כאשר הכרטיס נוכח, אחרת ל‑/flash. המפענח מריץ אז סקריפטים מתוך אותה ספרייה:

boot.py מורץ בכל איפוס רך (אתחול קר, Ctrl‑D מתוך ה‑REPL, או בכל פעם שהסקריפט הפעיל מסתיים).
main.py מורץ רק באתחול קר, מיד לאחר boot.py. איפוסים רכים עוקבים מריצים מחדש את boot.py אך עוברים ישירות ל‑REPL — כדי להריץ מחדש את main.py עליכם לאפס את הלוח לחלוטין.

הצבת boot.py או main.py על כרטיס ה‑SD עוקפת את העותק שבזיכרון הפלאש מבלי לגעת בו — שני הקבצים מאותרים בספריית האתחול (/sdcard כאשר הכרטיס מותקן, אחרת /flash).

ה‑main.py שמגיע כברירת מחדל בלוח שזה עתה נצרב פשוט מהבהב את הערוץ הכחול של נורית ה‑RGB LED למשתמש כפעימת לב (שתי פעימות קצרות, מרווח קצר), כך שתוכלו לדעת שהקושחה אותחלה בהצלחה ללא צורך בחיבור מארח כלשהו.

sys.path מורחב לכלול את כל שלוש מערכות הקבצים ואת תת‑הספריות lib/ שלהן, כך שמודולים הניתנים לייבוא יכולים לשבת ב‑/flash/lib, /sdcard/lib או /rom/lib.

כדי לאלץ את המערכת להתעלם מכרטיס SD מוכנס (למשל כדי להריץ את main.py שבזיכרון הפלאש גם כאשר כרטיס נוכח), צרו קובץ ריק בשם SKIPSD בשורש של /flash.

כאשר מחוברים דרך USB, מערכת קבצי האתחול (/sdcard אם כרטיס נוכח, אחרת /flash) גם נספרת ככונן אחסון המוני USB במארח, ומאפשרת לכם לערוך את boot.py, main.py וכל קובץ אחר ישירות. הוציאו את הכונן לפני איפוס המצלמה כדי שהמארח יְרוקֵן את הכתיבות השמורות במטמון שלו.

הערה

מכיוון שמערכת ההפעלה מתייחסת לכונן כהתקן בלוקים פסיבי, קבצים שנוצרו או שונו על ידי קוד הרץ על ה‑OpenMV Cam לא יופיעו עד שהמארח יתקין מחדש את הכונן. אם גם מערכת ההפעלה וגם ה‑OpenMV Cam כותבים לאותה מערכת קבצים באותו הזמן, מערכת ההפעלה תנצח ותדרוס שינויים שנעשו על ידי המצלמה. השתמשו בכרטיס ה‑SD עבור כל נתון שהסקריפט כותב חזרה, והתקינו מחדש לפני קריאת קבצים אלה מהמארח.

הערה

הערוץ האדום של נורית ה‑RGB LED למשתמש עשוי להאיר לרגע בזמן שהמארח קורא או כותב לכונן האחסון ההמוני של ה‑USB — זהו מחוון פעילות מונע‑קושחה, ולא תקלה.

גדלי אחסון¶

ה‑M7 מגיע עם:

/flash — מערכת קבצים FAT בגודל 96 KB, לקריאה/כתיבה.
/rom — ROMFS בגודל 256 KB לקריאה בלבד הממופה לזיכרון.
/sdcard — הגודל המלא של כל כרטיס microSD שמוכנס (כאשר נוכח), לקריאה/כתיבה.

מחוון תקלה חמורה¶

אם נורית ה‑RGB LED למשתמש עוברת במהירות בין כל הצבעים — מהר מספיק עד שזה נוטה להיראות כמו נורית LED לבנה מהבהבת ולא כגוונים נפרדים — הקושחה נתקלה בתקלה חמורה בלתי ניתנת להתאוששות. צרבו מחדש את הקושחה כדי להתאושש; אם צריבה מחדש אינה עוזרת, ייתכן שהלוח ניזוק פיזית.

ספריות תוכנה¶

ראו את אינדקס הספרייה לרשימה המלאה של המודולים — כולל אלה הייחודיים לגרסת ה‑M7.