OpenMV Cam H7¶

ה‑OpenMV Cam H7 הוא לוח ראייה ממוחשבת מבוסס Cortex‑M7, הבנוי סביב STMicroelectronics STM32H743 בתדר 480 MHz עם 1 MB של SRAM פנימי, 2 MB של זיכרון פלאש (flash) פנימי, וקודק JPEG חומרתי. הלוח מגיע בשתי גרסאות חיישן — ה‑H7 עם ה‑OV7725 וה‑H7 R2 עם ה‑ON Semi MT9M114 — אך הקושחה, מערך הפינים וממשק ה‑Python של Python זהים.

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

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

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

הערה

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

מערך פינים¶

מדריך פינים¶

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

הערה

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

פיני הספק¶

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

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

הערה

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

אזהרה

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

אזהרה

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

טיפ

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

פיני שחזור וניפוי שגיאות¶

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

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

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

נורות LED¶

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

LED 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 מחווט פעיל ברמה גבוהה בחומרה בעוד שהקושחה מתייחסת לכל נורת 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 (או MT9M114 ב‑H7 R2) מונע דרך מודול ה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()

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

כרטיס 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 (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 ביט או כפלט 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 מכסה השהיות חוסמות, טיקים מונוטוניים, ומדידת זמן שחלף:

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

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

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

זיכרון פלאש (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 המוגדר כברירת מחדל ומגיע על לוח שזה עתה נצרב פשוט מהבהב את הערוץ הכחול של ה‑LED RGB למשתמש כפעימת לב (שני פעימות קצרות, רווח קצר), כך שתוכלו לדעת שהקושחה אותחלה בהצלחה ללא כל מארח מחובר.

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

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

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

הערה

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

הערה

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

גדלי אחסון¶

ה‑H7 מגיע עם:

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

מחוון כשל חמור (Hard‑fault)¶

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

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

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