OpenMV Cam H7 Plus¶

ה-OpenMV Cam H7 Plus משלב את ה-STMicroelectronics STM32H743 (Cortex‑M7 @ 480 MHz) עם 32 MB של SDRAM חיצוני, 32 MB של זיכרון פלאש (flash) מסוג QSPI, מקודד JPEG חומרתי, ומודול המצלמה OV5640 בנפח 5MP על נשא נשלף. הזיכרון הנוסף מתאים היטב ללכידה ברזולוציה גבוהה ולחוצצי תמונה גדולים.

ל-datasheet המלא, לתמונות ולמידות ראו את עמוד המוצר של OpenMV Cam H7 Plus.

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

STMicroelectronics STM32H743 Cortex‑M7 בתדר 480 MHz (1027 DMIPS).
מקודד/מפענח JPEG חומרתי.
32 MB SDRAM חיצוני (32‑bit @ 100 MHz, 400 MB/s) בתוספת 1 MB SRAM פנימי.
2 MB זיכרון פלאש (flash) פנימי + 32 MB זיכרון פלאש (flash) חיצוני מסוג QSPI (קריאה של ~100 MB/s).
חיישן OV5640 בנפח 5MP מסוג rolling‑shutter.
USB במהירות מלאה (12 Mb/s) — מופיע כלפי המארח כ-VCP + התקן אחסון USB.
תושבת microSD — SD עד 2 GB, SDHC עד 32 GB, SDXC עד 2 TB.
מחבר סוללת LiPo (ללא מטען מובנה — חברו תא טעון או הזינו מ-VIN/USB).
10 פינים של I/O, סובלניים ל-5 V עם פלט של 3.3 V, 25 mA לכל פין (120 mA סך הכל על פני המחבר), בעלי יכולת פסיקה. P6 אינו סובלני ל-5 V כאשר משתמשים בו במצב ADC או DAC.
נורית RGB למשתמש ושתי נוריות IR בהספק גבוה בתדר 850 nm לתאורה אקטיבית בראייה בתנאי תאורה נמוכה.

הערה

ל-H7 Plus אין שבב ניהול הספק מובנה: אין מטען סוללה, אין ADC למתח סוללה, אין נוריות מצב טעינה / הספק, ואין כפתור הפעלה חומרתי. חברו LiPo טעון מראש ל-JST של הסוללה או הפעילו את הלוח מ-USB / VIN.

מערך פינים (Pinout)¶

מדריך פינים¶

שם הפין	פונקציה
P0	UART1 RX / SPI2 MOSI
P1	UART1 TX / SPI2 MISO
P2	SPI2 SCK / FDCAN2 TX
P3	SPI2 NSS (CS) / FDCAN2 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	I/O דיגיטלי
RESET	משכו ל-GND כדי לאפס את הלוח
SYN	פד frame‑sync — מחווט אך ורק לחיישן המצלמה
BOOT0	משכו ל-3.3 V בעת ההפעלה עבור DFU / מאתחל (bootloader) ROM
LED_RED	ערוץ אדום של נורית RGB (פעיל בנמוך)
LED_GREEN	ערוץ ירוק של נורית RGB (פעיל בנמוך)
LED_BLUE	ערוץ כחול של נורית RGB (פעיל בנמוך)
LED_IR	נוריות IR בהספק גבוה (שני הערוצים מונעים יחד)

הערה

פד ה-SYN שעל המחבר מחובר ישירות לקו ההדק / החשיפה של חיישן המצלמה — הוא אינו מנותב ל-MCU ב-H7 Plus. הניעו או קראו אותו חיצונית; לא ניתן להחליף את מצבו מ-MicroPython.

פיני הספק¶

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

קיים גם מחבר LiPo של 3.7 V, אך ל-H7 Plus אין מטען סוללה — חברו תא טעון מראש, או הזינו VIN / USB במקום זאת.

הערה

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

אזהרה

מחבר הסוללה ו-VIN מחוברים יחד ב-H7 Plus. אל תחברו LiPo ותפעילו VIN בו זמנית — שני מקורות ההספק יתנגשו זה בזה ועלולים לפגוע בסוללה, בלוח, או בשניהם.

אזהרה

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

טיפ

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

פיני שחזור ו-debug¶

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

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

הערה

פין ה-trace SWO משותף עם קו שעון ה-SPI של מחבר המצלמה. לא ניתן להשתמש ב-SWO בו זמנית עם מודול מצלמה כלשהו שמתקשר עם ה-MCU דרך SPI — לדוגמה FLIR® Lepton® Adapter Module — בחרו באחד מהם.

התקנים היקפיים מובנים¶

נוריות¶

ל-H7 Plus יש נורית RGB יחידה למשתמש בתוספת זוג נוריות IR בהספק גבוה בתדר 850 nm:

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

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

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

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

ה-OV5640 מונע דרך המודול 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()

ל-OV5640 יש דחסן JPEG מובנה. הגדירו את csi.CSI.pixformat ל-csi.JPEG והחיישן מספק פריימים דחוסים ישירות למצלמה דרך אפיק המצלמה, מה שהופך לכידות ברזולוציה גבוהה למעשיות: csi.HD (1280×720), csi.FHD (1920×1080), וה-5MP המלא csi.WQXGA2 (2592×1944) כולם מוזרמים כ-JPEG. כוונו את הדחיסה עם csi.CSI.quality (0-100, גבוה יותר = פריימים גדולים יותר, יותר פירוט):

cam.pixformat(csi.JPEG)
cam.framesize(csi.WQXGA2)
cam.quality(90)

החיישן ממוקם על מודול נשלף — החליפו אותו בכל אחד ממודולי המצלמה האחרים של OpenMV (global shutter, תרמי, רזולוציה גבוהה יותר וכו«) מבלי לשנות את שאר הלוח.

למידת מכונה¶

ml — למידת מכונה מריץ מודלי TFLite מקוונטטים על ה-Cortex‑M7 עם ליבות CMSIS‑NN — מהיר מספיק עבור גלאים קומפקטיים בכמה פריימים לשנייה. מודלים על מערכת הקבצים לקריאה בלבד /rom נטענים ישירות מזיכרון הפלאש (flash) ללא העתקה ל-RAM. הנה גלאי BlazeFace בגודל 128×128 המכסה בשכבת על את הפנים שזוהו ואת ששת ציוני הדרך שלהן בכל פריים:

import csi
import time
import ml
from ml.postprocessing.mediapipe import BlazeFace

# Initialize the sensor.
csi0 = csi.CSI()
csi0.reset()
csi0.pixformat(csi.RGB565)
csi0.framesize(csi.VGA)
csi0.window((400, 400))

# Load built-in face detection model
model = ml.Model("/rom/blazeface_front_128.tflite", postprocess=BlazeFace(threshold=0.4))
print(model)

clock = time.clock()
while True:
    clock.tick()
    img = csi0.snapshot()

    # faces is a list of ((x, y, w, h), score, keypoints) tuples
    for r, score, keypoints in model.predict([img]):
        ml.utils.draw_predictions(img, [r], ("face",), ((0, 0, 255),), format=None)

        # keypoints is a ndarray of shape (6, 2)
        # 0 - right eye (x, y)
        # 1 - left eye (x, y)
        # 2 - nose (x, y)
        # 3 - mouth (x, y)
        # 4 - right ear (x, y)
        # 5 - left ear (x, y)
        ml.utils.draw_keypoints(img, keypoints, color=(255, 0, 0))

    print(clock.fps(), "fps")

כרטיס 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")

ניתן להשתמש באותה חומרה גם במצב target (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 (FDCAN)¶

אפיק	TX	RX
FDCAN2	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‑bit או כפלט 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‑bit מכסה 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

הערה

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

TIM4 משותף עם pyb.Servo — יצירת servo מגדירה מחדש את הטיימר כולו לפעולה ב-50 Hz, ולכן אל תערבבו machine.PWM על P7/P8 עם 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 מכסה השהיות חוסמות, טיקים מונוטוניים, ומדידת זמן שחלף:

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

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

חלון מאתחל (bootloader) USB¶

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

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

import machine

machine.bootloader()

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

קושחת ה-H7 Plus מתקינה עד שלוש מערכות קבצים בעת האתחול:

זיכרון פלאש (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 עוקפת את העותק בזיכרון הפלאש (flash) מבלי לגעת בו — שני הקבצים מאותרים בספריית האתחול (/sdcard כאשר הכרטיס מותקן, אחרת /flash).

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

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

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

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

הערה

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

הערה

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

גדלי אחסון¶

ה-H7 Plus מגיע עם:

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

מחוון hard‑fault¶

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

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

ראו את אינדקס הספרייה לרשימה המלאה של המודולים — כולל אלה הייחודיים לבילד של ה-H7 Plus.