OpenMV Cam RT1062¶

ה‑OpenMV Cam RT1062 הוא לוח ראייה ממוחשבת בעל צריכת חשמל נמוכה המבוסס על ה‑NXP i.MX RT1062 (Cortex‑M7 ב‑600 MHz). הלוח משלב רשת USB‑C במהירות גבוהה, Wi‑Fi/Bluetooth ו‑Ethernet 10/100 יחד עם חיישן OV5640 בן 5MP על נשא נשלף. המצלמה צורכת רק כ‑30 µA מסוללת LiPo במצב שינה עמוקה, מה שהופך אותה למתאימה במיוחד לפרויקטים מבוססי סוללה.

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

עיקרי דברים¶

NXP i.MX RT1062 Cortex‑M7 ב‑600 MHz.
32 MB של SDRAM חיצוני (16‑bit ב‑160 MHz, 320 MB/s) בתוספת 1 MB של SRAM פנימי ו‑16 MB של זיכרון פלאש QSPI (flash) (133 MHz 4‑bit SDR, קריאה ב‑66 MB/s); 4 KB EEPROM ב‑R6+.
חיישן OV5640 בן 5MP בעל תריס מתגלגל (rolling‑shutter).
IMU מובנה (מד תאוצה תלת‑צירי 12‑bit, ‏±2/4/8 g).
USB‑C במהירות גבוהה (480 Mb/s, מגבלת זרם 1.5 A), Ethernet 10/100 Mb/s (תומך PoE באמצעות מגן), Wi‑Fi a/b/g/n + Bluetooth 5.1 (אנטנת שבב או אפשרות U.FL).
שקע microSD — ‏SD עד 2 GB, ‏SDHC עד 32 GB, ‏SDXC עד 2 TB.
מטען LiPo (‏500 mA ב‑R6+, ‏100 mA ב‑R4/R5), ‏RTC עם רפידות לסוללת גיבוי. שינה עמוקה צורכת כ‑30 µA מהסוללה.
14 פיני I/O, כולם פלט 3.3 V / סובלני ל‑3.3 V, ‏4 mA לכל פין, בעלי יכולת פסיקה.
נורית RGB למשתמש, לחצן SW למשתמש, לחצן הפעלה חומרתי (מכונת מצבים לשינה עמוקה / יקיצה), ונורית סטטוס נפרדת לטעינה / USB / מתח VIN.

אזהרה

פיני ה‑I/O של ה‑RT1062 אינם סובלניים ל‑5 V. אל תחברו את ההתקן ישירות ל‑MCU בעל 5 V כמו ה‑Arduino Mega. הזינו את הלוח דרך VIN בלבד.

מערך פינים¶

מדריך פינים¶

שם פין	פונקציה
P0	SPI1 MOSI / PWM2 B3
P1	SPI1 MISO / CAN0 TX
P2	SPI1 SCLK / PWM2 B3
P3	SPI1 SS / CAN0 RX
P4	I2C1 SCL / UART1 TX / PWM1 X2
P5	I2C1 SDA / UART1 RX / PWM1 X3
P6	ADC
P7	PWM2 A0
P8	PWM2 B0
P9	PWM1 A3
P10	PWM1 B3 / ‏I/O לסנכרון פריימים
P11	יקיצה (פעיל נמוך, חברו ל‑GND כדי להעיר)
P12	RESET — משכו ל‑GND כדי לאפס את הלוח (אינו GPIO)
P13	I/O דיגיטלי
P14	I/O דיגיטלי
ON/OFF	רפידת header המשכפלת את לחצן ההפעלה החומרתי (פעיל נמוך)
SW	לחצן משתמש (פעיל נמוך)
ST	נמוך במתח VIN, גבוה במתח USB
CHG	פעיל נמוך; נמוך בזמן שסוללת LiPo מחוברת נטענת
PG	פעיל נמוך; נמוך כאשר מתח VIN או USB קיים
LED_RED	ערוץ אדום של נורית RGB (פעיל נמוך)
LED_GREEN	ערוץ ירוק של נורית RGB (פעיל נמוך)
LED_BLUE	ערוץ כחול של נורית RGB (פעיל נמוך)

הערה

קו סנכרון הפריימים P10 הוא אפיק משותף. הוא מחווט אל ה‑MCU, אל פין ההדק / החשיפה של חיישן המצלמה, ואל ה‑header של המשתמש בו זמנית. הכיוון מוגדר על ידי היישום — ה‑MCU, החיישן, או אות חיצוני יכולים להניע אותו בהתאם לאופן שבו החיישן מוגדר. ודאו שרק מניע אחד פעיל בכל זמן נתון.

הערה

ON/OFF ו‑P11 מתייחסים לפסת ה‑RAW הדלוקה תמיד (לא לפסת ה‑3.3 V הממותגת), כך שהם נשארים פעילים בזמן ששאר הלוח במצב שינה עמוקה / חיסכון בחשמל. שתי הכניסות הן פעילות נמוך.

פינים אלו עוברים דרך מסיטי מתח (level shifters) כדי שיוכלו לפעול על פסת ה‑RAW. אם אתם ממש זקוקים להתנהגות GPIO ישירה ב‑3.3 V ב‑ON/OFF או ב‑P11 (לדוגמה כדי להניע אותם מ‑MCU של 3.3 V מבלי לעבור דרך המסיט), הלוח חושף רפידות מתח עולה (pull‑up) ורפידות גשר 0‑אוהם המאפשרות לעקוף את המסיט. זהו תיקון חומרה מתקדם — רוב המשתמשים צריכים להשאיר זאת כפי שהוא.

הערה

P13 ו‑P14 הם GPIO רגיל כברירת מחדל ללא פונקציה מיוחדת. ניתן לנתב מחדש את הרפידות לאותות אחרים על ידי הלחמה מחדש של גשרי ההלחמה בעלי נגד 0‑אוהם בגב הלוח:

P13 ↔ סטטוס CHG / ‏JTAG TRSTB
P14 ↔ סטטוס ST / ‏JTAG TDI

רוב המשתמשים לא ייגעו בגשרים אלו — השאירו אותם בברירת המחדל של GPIO אלא אם כן אתם זקוקים במפורש לקריאת ניהול חשמל או ל‑JTAG.

פיני חשמל¶

3.3V — פסת 3.3 V מיוצבת. פלט בלבד ב‑RT1062 — אל תזינו חשמל חיצוני לפין זה. עד 1 A זמין למגנים.
VIN — כניסת 5 V. מזינה את הלוח ואת מטען ה‑LiPo המובנה.
RAW — כניסה/פלט, דלוקה תמיד (3.6 V – 5 V). נושאת את כל מקור שפעיל (VIN, ‏USB, או סוללה מחוברת), וניתן להשתמש בה גם ככניסה. עליכם להניע את RAW דרך דיודה בטור בעת הזנת חשמל לתוכה — אחרת זרם יזרום בחזרה אל VIN/USB ויפגע בספק החשמל או בהגנה המובנית.
GND — אדמה משותפת.

הערה

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

הערה

בגב הלוח יש רפידות הלחמה ל‑סוללת גיבוי 3.3 V חיצונית ל‑RTC. חיווט סוללת מטבע לרפידות אלו שומר על ה‑RTC פועל בזמן ששאר הלוח אינו מקבל חשמל.

טיפ

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

פיני Ethernet¶

ה‑RT1062 חושף את זוגות ה‑MDI של ה‑PHY של Ethernet 10/100 Mb/s על רפידות ייעודיות ליד ה‑header של ה‑GPIO. פיני ה‑MDI אינם בטוחים לחיווט ישיר ל‑RJ45 — נדרשים רכיבי מגנטיקה של Ethernet (שנאי בידוד, בין אם מובנה ב‑magjack או על המגן) בהכרח בין ה‑PHY לכבל. מגן ה‑PoE של OpenMV כולל אותם; אם אתם בונים שקע משלכם, השתמשו ב‑RJ45 עם מגנטיקה משולבת או בשנאי חיצוני.

ETH_LED — נורית קישור/פעילות. פעילה נמוך כאשר הקישור פעיל; מהבהבת בעת תעבורה.
ETH_TXP / ETH_TXN — זוג שידור.
ETH_RXP / ETH_RXN — זוג קליטה.

הערה

ה‑header חושף גם ארבע רפידות עם הדפס סילק Reserved. אלו תואמות שטח רכיב לזוגות ה‑Ethernet הגיגה‑בייט שבOpenMV N6 (DC P/N ו‑DD P/N) כך שאותו מגן Ethernet / PoE ניתן לחיבור לכל אחד מהלוחות. ה‑PHY של ה‑RT1062 עושה רק 10/100 Mb/s, ולכן לארבע רפידות אלו אין קישוריות חשמלית — השאירו אותן בלתי מחוברות.

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

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

מורכב header ARM 10‑pin SWD/JTAG ייעודי, תואם למתאמי ST‑LINK ו‑SEGGER J‑Link.

הערה

ה‑RT1062 חושף רק ניפוי באגים SWD דרך מחבר זה כברירת מחדל. ‏JTAG מלא אינו זמין מן המוכן.

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

נוריות¶

ל‑RT1062 שתי נוריות RGB:

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

LED("LED_RED").on()
LED("LED_GREEN").on()
LED("LED_BLUE").on()
```
נורית חשמל — מונעת ישירות על ידי חומרת ניהול החשמל המובנית, ללא שליטה תוכנתית. השתמשו בה כדי לקרוא במבט חטוף מה ספק החשמל עושה.

בזמן פעולה:

ערוץ

משמעות

כחול

VIN מזין את הלוח (כבוי ב‑USB)

ירוק

מתח USB או VIN קיים

אדום

טעינה של סוללת LiPo מחוברת

בשינה עמוקה כל הערוצים כבויים למעט האדום, שעדיין נדלק בזמן שסוללת LiPo נטענת.

ערוץ	משמעות
כחול	VIN מזין את הלוח (כבוי ב‑USB)
ירוק	מתח USB או VIN קיים
אדום	טעינה של סוללת LiPo מחוברת

לחצנים¶

ל‑RT1062 שני לחצנים:

SW — לחצן משתמש לשימוש כללי. ניתן לקריאה מהקוד ככניסת GPIO פעילה נמוך רגילה:
```
from machine import Pin

sw = Pin("SW", Pin.IN)
print(sw.value())
```
לחצן הפעלה — מונע על ידי מכונת מצבים ייעודית של בקר חשמל בלוח ה‑RT1062, כולה בחומרה. הוא אינו חשוף לקוד המשתמש; הבקר מחליט מה לעשות בהתאם למשך הזמן שבו הוא מוחזק:
- החזיקו כ‑5 שניות בזמן שהלוח פועל ← מכונת המצבים עוברת לשינה עמוקה.
- החזיקו כ‑1 שנייה בזמן שהלוח בשינה עמוקה ← מכונת המצבים מפעילה את המערכת בחזרה.
משיכת רפידת ה‑header ON/OFF לנמוך מובילה לאותה תוצאה כמו לחיצה על לחצן ההפעלה המובנה — שימושי לחיווט מתג חיצוני או להנעת הקו ממיקרו‑בקר אחר.

פיני סטטוס חשמל¶

שלוש כניסות סטטוס פעילות נמוך משבב ניהול החשמל המובנה:

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

from machine import Pin

power_ok = not Pin("PG", Pin.IN).value()

חיישן מצלמה¶

ה‑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 (תריס גלובלי, תרמי, רזולוציה גבוהה יותר וכו«) מבלי לשנות את שאר הלוח.

למידת מכונה¶

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

IMU¶

קושחת ה‑RT1062 אינה מחווטת את מד התאוצה המובנה אל המודול imu — חיישן imu. דברו איתו ישירות דרך אפיק ה‑I²C הפנימי במקום — השבב נמצא בכתובת 0x15 ואורז שלושה ערוצי תאוצה חתומים של 12‑bit בתוספת בית טמפרטורה של 8‑bit החל מהאוגר (register) 0x03

import machine
import time

ADDR     = 0x15
DATA_REG = 0x03
LSB_PER_G = 1024.0    # ±2 g range

def s12(hi, lo):
    v = ((hi << 8) | lo) >> 4
    return v - 0x1000 if v & 0x800 else v

bus = machine.I2C(2)
print("Devices on I²C2:", bus.scan())

while True:
    d = bus.readfrom_mem(ADDR, DATA_REG, 7)
    x = s12(d[0], d[1]) / LSB_PER_G
    y = s12(d[2], d[3]) / LSB_PER_G
    z = s12(d[4], d[5]) / LSB_PER_G
    temp_c = d[6] * 0.586 + 25.0
    print("x=%+.2fg  y=%+.2fg  z=%+.2fg  T=%.1f°C" % (x, y, z, temp_c))
    time.sleep_ms(100)

EEPROM¶

לוחות R6 ואילך כוללים EEPROM גנרי של 4 KB מסוג I²C על אותו אפיק פנימי כמו מד התאוצה. (לגרסאות מוקדמות יותר אין אחד — קריאה לקטעי קוד אלו ב‑R4/R5 תיתקל בפסק זמן עקב היעדר ack של I²C.) השתמשו ב‑API התקני machine.I2C ‏readfrom_mem / writeto_mem עם כתובת זיכרון 16‑bit:

import machine
import time

EEPROM_ADDR = 0x50            # default address
PAGE_SIZE   = 32              # bytes per page (both read and write)
EEPROM_SIZE = 4096

bus = machine.I2C(2)

# Dump the entire 4 KB one page at a time
data = bytearray()
for offset in range(0, EEPROM_SIZE, PAGE_SIZE):
    data += bus.readfrom_mem(EEPROM_ADDR, offset, PAGE_SIZE, addrsize=16)
print(len(data), "bytes")

# Write a small payload back at offset 0 (fits in one page)
bus.writeto_mem(EEPROM_ADDR, 0, b"hello, world", addrsize=16)
time.sleep_ms(10)             # ~5 ms write cycle after each page

# Read it back
print(bus.readfrom_mem(EEPROM_ADDR, 0, 12, addrsize=16))

גם קריאות וגם כתיבות חייבות להישאר בתוך עמוד של 32 בתים. פצלו כל העברה גדולה יותר לקריאה אחת לכל עמוד, והוסיפו את ההשהיה של כ‑5 ms למחזור הכתיבה בין כתיבות עוקבות.

Wi‑Fi¶

מודול ממשפחת CYW43 המובנה חשוף דרך network — הגדרת רשת כממשק תחנה. לאחר ההתחברות, ‏ipconfig("addr4") מחזיר את הצמד (ip, netmask)

import network, time

wlan = network.WLAN(network.STA_IF)
wlan.active(True)
wlan.connect("ssid", "password")
while not wlan.isconnected():
    time.sleep(1)
print("Wi‑Fi IP:", wlan.ipconfig("addr4")[0])

Bluetooth¶

אותו מודול אלחוטי חושף גם Bluetooth 5.1. השתמשו ב‑aioble — BLE אסינכרוני ל‑BLE ידידותי ל‑asyncio — לדוגמה, פרסמו כהתקן היקפי והמתינו לבקר מרכזי שיתחבר:

import asyncio
import aioble

async def run():
    while True:
        conn = await aioble.advertise(250_000, name="OpenMV-RT1062")
        print("Connected:", conn.device)
        await conn.disconnected()

asyncio.run(run())

Ethernet¶

כאשר RJ45 (עם מגנטיקה) מחובר לרפידות ה‑MDI, ה‑PHY של 10/100 מופיע כממשק LAN. ‏DHCP פועל אוטומטית ברגע שהקישור עולה:

import network, time

lan = network.LAN()
lan.active(True)
while not lan.isconnected():
    time.sleep(1)
print("Ethernet IP:", lan.ipconfig("addr4")[0])

כרטיס microSD¶

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

import os

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

מדריך אפיקים¶

GPIO¶

השתמשו ב‑machine.Pin כדי לקרוא או להניע כל אחד מהפינים בהדפס הסילק. הפלטים הם 3.3 V CMOS ויכולים לשקוע/לספק עד 4 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	P4	P5

from machine import UART

uart = UART(1, baudrate=115200)
uart.write("hello")
uart.read(5)

I²C¶

אפיק	SCL	SDA
I2C1	P4	P5

from machine import I2C

i2c = I2C(1, freq=400_000)
i2c.scan()
i2c.writeto(0x76, b"hi")

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

from machine import I2CTarget

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

SPI¶

אפיק	MOSI	MISO	SCK	CS
SPI1	P0	P1	P2	P3

from machine import SPI
from machine import Pin

spi = SPI(1, 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
CAN1	P1	P3

הערה

CAN עדיין אינו נתמך בלוח זה בקושחה v5.0.0.

from machine import CAN

can = CAN(1, 500_000)
can.set_filters(None)
can.send(0x123, b"\xDE\xAD\xBE\xEF")
print(can.recv())

ADC¶

פין ה‑ADC היחיד למשתמש הוא P6, שהוא בקנה מידה מלא בכ‑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)

PWM¶

פין	ערוץ FlexPWM
P0	PWM2 B3
P2	PWM2 B3
P4	PWM1 X2
P5	PWM1 X3
P7	PWM2 A0
P8	PWM2 B0
P9	PWM1 A3
P10	PWM1 B3

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

from machine import Pin, PWM

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

אפיקים תוכנתיים מסוג bit‑banged¶

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 4 — חווטו את המודול אל 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 שומר על זמן שעון קיר בין איפוסים, ו‑(עם סוללת הגיבוי האופציונלית של 3.3 V המחווטת לרפידות האחוריות, ראו פיני חשמל) בין הפסקות חשמל מלאות:

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

ה‑RTC פועל גם דרך שינה עמוקה, כך שאתם יכולים להשתמש בו כמקור יקיצה עבור machine.deepsleep().

כלב שמירה¶

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

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

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

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

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

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

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

הערה

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

הערה

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

גדלי אחסון¶

ה‑RT1062 מסופק עם:

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

מחוון תקלה קשה (hard‑fault)¶

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

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

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