Arduino Giga R1 WiFi¶

ה‑Arduino Giga R1 WiFi הוא לוח בגודל 101 × 53 מ“מ בפורמט Mega, הבנוי סביב ה‑STMicroelectronics STM32H747XI — שבב SoC דו‑ליבתי המשלב Cortex‑M7 ב‑480 MHz עם Cortex‑M4 ב‑240 MHz. קושחת OpenMV רצה כולה על ליבת ה‑M7. ה‑Giga מוסיף מחבר גמיש למצלמת Arducam בן 22 פינים, מחבר MIPI‑DSI עבור ה‑Arduino Giga Display Shield, ושקע אודיו סטריאו 3.5 מ“מ למבנה הסטנדרטי של מחברי ה‑Arduino Mega.

ל‑datasheet המלא, תמונות ומידות ראו את דף המוצר של Arduino Giga R1 WiFi.

עיקרים¶

STMicroelectronics STM32H747XI דו‑ליבתי Cortex‑M7 (480 MHz) + Cortex‑M4 (240 MHz). קושחת OpenMV רצה על ליבת ה‑M7 בלבד; ליבת ה‑M4 נחשפת דרך openamp לתקשורת בין‑מעבדים.
8 MB של SDRAM חיצוני בתוספת 2 MB של flash פנימי ו‑16 MB של QSPI flash חיצוני.
מקודד/מפענח JPEG חומרתי.
מחבר גמיש למצלמה תואם Arducam בן 22 פינים (J6) — תמיכת מנהל התקן עבור מודולי החיישנים OV5640 (5MP), OV7670, GC2145, HM01B0 ו‑HM0360.
מחבר תצוגה MIPI‑DSI (J5) עבור ה‑Arduino Giga Display Shield (פאנל מגע קיבולי 480×800) בתוספת מנוע תצוגה LTDC RGB עבור לוחות נשיאה מתקדמים.
שקע אודיו 3.5 מ“מ עם יציאת line‑out סטריאו וכניסת מיקרופון.
Wi‑Fi b/g/n (2.4 GHz) + Bluetooth LE 5.1 באמצעות מודול ה‑Murata 1DX (CYW4343W) — מתחבר לאנטנה המצורפת דרך מחבר U.FL על הלוח.
USB‑C (full‑speed) להזנת מתח / טורי / תכנות.
קלט/פלט משתמש על מחברי סגנון ה‑Mega — D0–D75 (דיגיטלי), A0–A11 (אנלוגי), DAC0/DAC1 (יציאות DAC), CAN_RX/CAN_TX (FDCAN2), וזוג ה‑I²C SDA1/SCL1 בשורה הפנימית. מחבר SPI1 נפרד בן 6 פינים בחזית הלוח מוציא את CIPO/COPI/SCK (D89/D90/D91).
JTAG / SWD מוצא במחבר ה‑debug בצד העליון עבור debug מתקדם.

מיפוי פינים¶

מדריך פינים¶

מחברי סגנון ה‑Arduino Mega חושפים 76 פינים דיגיטליים (D0–D75), 12 פינים אנלוגיים (A0–A11), שתי יציאות DAC (DAC0/DAC1), זוג I²C משני (SDA1/SCL1), וזוג FDCAN2 (CAN_RX/CAN_TX). מחבר SPI1 נפרד בן 6 פינים בחזית הלוח מוציא את CIPO/COPI/SCK (D89/D90/D91).

שם פין	ייחוס	פונקציה
D0	3.3 V	USART1 RX (Serial1) / TIM4 CH2
D1	3.3 V	USART1 TX (Serial1) / TIM1 CH2
D2	3.3 V	TIM2 CH4 / TIM5 CH4 / USART2 RX
D3	3.3 V	TIM2 CH3 / TIM5 CH3 / USART2 TX
D4	3.3 V	TIM8 CH1 / UART8 TX
D5	3.3 V	TIM3 CH2 / SPI1 MOSI / SPI6 MOSI
D6	3.3 V	TIM4 CH2
D7	3.3 V	TIM3 CH1 / SPI1 MISO / SPI3 MISO / SPI6 MISO
D8	3.3 V	TIM4 CH3 / I2C1 SCL / I2C4 SCL / UART4 RX
D9	3.3 V	TIM4 CH4 / I2C1 SDA / I2C4 SDA / UART4 TX
D10	3.3 V	TIM1 CH1 / TIM8 CH3N
D11	3.3 V	TIM8 CH2 / SPI5 MOSI
D12	3.3 V	TIM8 CH2N / SPI5 MISO
D13	3.3 V	TIM12 CH1 / SPI5 SCK
D14	3.3 V	USART6 TX (Serial2) / SPI6 MOSI
D15	3.3 V	USART6 RX (Serial2) / TIM3 CH2 / TIM8 CH2
D16	3.3 V	UART4 TX (Serial3) / TIM8 CH1N
D17	3.3 V	UART4 RX (Serial3)
D18	3.3 V	USART2 TX (Serial4)
D19	3.3 V	USART2 RX (Serial4) / SPI3 MOSI
D20	3.3 V	I2C2 SDA / TIM2 CH4 / USART3 RX
D21	3.3 V	I2C2 SCL
D22	3.3 V	GPIO
D23	3.3 V	GPIO / SPI6 SCK
D24	3.3 V	GPIO / SPI6 MISO
D25	3.3 V	GPIO
D26	3.3 V	GPIO
D27	3.3 V	GPIO
D28	3.3 V	GPIO
D29	3.3 V	GPIO
D30	3.3 V	GPIO
D31	3.3 V	GPIO
D32	3.3 V	GPIO
D33	3.3 V	GPIO
D34	3.3 V	GPIO
D35	3.3 V	GPIO
D36	3.3 V	GPIO
D37	3.3 V	TIM8 CH2
D38	3.3 V	TIM8 CH2N
D39	3.3 V	GPIO
D40	3.3 V	TIM15 CH2 / SPI4 MOSI
D41	3.3 V	GPIO
D42	3.3 V	GPIO
D43	3.3 V	GPIO
D44	3.3 V	GPIO
D45	3.3 V	GPIO
D46	3.3 V	TIM8 CH3N
D47	3.3 V	SPI3 MOSI
D48	3.3 V	TIM8 CH3 / SPI5 SCK
D49	3.3 V	GPIO
D50	3.3 V	GPIO
D51	3.3 V	TIM15 CH1 / SPI4 MISO
D52	3.3 V	GPIO
D53	3.3 V	GPIO
D54	3.3 V	TIM8 CH1 (camera DCMI VSYNC)
D55	3.3 V	I2C3 SDA (camera DCMI HSYNC)
D56	3.3 V	TIM3 CH1 / TIM13 CH1 (camera DCMI PXCLK)
D57	3.3 V	TIM8 CH1N / UART8 RX (camera master clock — TIM1 CH3)
D58	3.3 V	TIM8 CH3 (camera DCMI D7)
D59	3.3 V	TIM8 CH2 (camera DCMI D6)
D60	3.3 V	GPIO (camera DCMI D5)
D61	3.3 V	TIM8 CH2N / UART4 RX (camera DCMI D4)
D62	3.3 V	SPI1 SCK (camera DCMI D3)
D63	3.3 V	TIM5 CH2 / I2C4 SCL (display I²C)
D64	3.3 V	TIM5 CH1 (camera DCMI D1)
D65	3.3 V	TIM12 CH2 (camera DCMI D0)
D66	3.3 V	GPIO (camera reset — claimed when camera is active)
D67	3.3 V	GPIO (camera power‑down — claimed when camera is active)
D68	3.3 V	TIM3 CH1 / TIM8 CH1 / USART6 TX (Display Shield DSI RESET)
D69	3.3 V	TIM5 CH4 (Display Shield DSI TE)
D70	3.3 V	SPI2 SCK
D71	3.3 V	TIM8 CH4 / SPI2 MISO
D72	3.3 V	SPI2 MOSI
D73	3.3 V	ADC123 IN11 (Display Shield DFSDM mic data)
D74	3.3 V	GPIO (display backlight — claimed by the Giga Display Shield)
D75	3.3 V	SPI2 SCK (Display Shield DFSDM mic clock)
A0 / D76	3.3 V	ADC12 IN4
A1 / D77	3.3 V	ADC12 IN8
A2 / D78	3.3 V	ADC12 IN9 / TIM3 CH3 / TIM8 CH2N
A3 / D79	3.3 V	ADC12 IN5 / TIM3 CH4 / TIM8 CH3N
A4 / D80	3.3 V	ADC12 IN13 / SPI2 MOSI
A5 / D81	3.3 V	ADC123 IN12 / SPI2 MISO
A6 / D82	3.3 V	ADC123 IN10
A7 / D83	3.3 V	ADC1 IN16 / TIM2 CH1 / TIM5 CH1 (audio jack mic input)
A8	3.3 V	ADC3 IN0 (analog only)
A9	3.3 V	ADC3 IN1 (analog only)
A10	3.3 V	ADC12 IN1 (analog only)
A11	3.3 V	ADC12 IN0 (analog only)
DAC0 / A12 / D84	3.3 V	DAC1 OUT1 / ADC12 IN18 (audio jack line‑out L)
DAC1 / A13 / D85	3.3 V	DAC1 OUT2 / TIM2 CH1 / SPI1 SCK / ADC12 IN19 (audio jack line‑out R)
D89	3.3 V	SPI1 MISO (`CIPO` on the front SPI header)
D90	3.3 V	SPI1 MOSI (`COPI` on the front SPI header)
D91	3.3 V	SPI1 SCK (`SCK` on the front SPI header)
CAN_RX / D93	3.3 V	FDCAN2 RX / TIM3 CH2 / UART5 RX
CAN_TX / D94	3.3 V	FDCAN2 TX / SPI2 SCK / UART5 TX
SDA1 / D102	3.3 V	I2C4 SDA (display touch / camera control bus)
SCL1 / D101	3.3 V	I2C4 SCL (display touch / camera control bus)
RESET	3.3 V	לחצו על כפתור ה‑RESET שעל הלוח או משכו ל‑GND כדי לאפס
LED_RED	3.3 V	ערוץ אדום של נורית RGB (active low)
LED_GREEN	3.3 V	ערוץ ירוק של נורית RGB (active low)
LED_BLUE	3.3 V	ערוץ כחול של נורית RGB (active low)

הערה

A8–A11 הם רפידות אנלוגיות בלבד על פיני ה‑_C של ה‑STM32H747 — אין להם פונקציית GPIO וניתן לקרוא אותם רק דרך ה‑ADC.

פיני מתח¶

פיני מחבר ה‑Mega:

VIN — כניסת 6–32 V. מזינה את הלוח דרך מווסת ה‑buck שעל הלוח.
+5V — מסילת 5 V המוזנת מ‑USB דרך דיודה או מווסת ה‑buck שעל הלוח.
+3V3 — מסילת 3.3 V הראשית.
IOREF — משקפת את מתח הקלט/פלט של הלוח (3.3 V).
AREF — ייחוס מתח אנלוגי עבור פיני ה‑ADC. ברירת המחדל היא 3.3 V; הזינו חיצונית כדי להשתמש בייחוס אחר.
OFF — משכו ל‑GND כדי לכבות את מסילת ה‑+3.3 V ולהשבית את המערכת.
VRTC — כניסת סוללת מטבע 3.0 V (3.3 V מקסימום) ששומרת על ה‑RTC שבשבב פעיל בזמן ששאר הלוח כבוי.
GND — הארקה משותפת.

ניתן להזין את ה‑Giga R1 דרך כל אחד מהמסלולים הבאים:

USB‑C — מספק 5 V למווסת ה‑buck שעל הלוח.
פין VIN — הזינו ספק מוסדר של 6–32 V ישירות.

טיפ

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

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

RESET — גם פין חשוף על מחבר המתח וגם מתג רגעי בחלק העליון של הלוח, מחוברים לקו ה‑NRST של ה‑SoC. משכו ל‑GND או לחצו על הכפתור כדי לאפס.

אם ה‑bootloader חסר לחלוטין, החזיקו את כפתור ה‑BOOT0 בזמן הלחיצה על RESET כדי לאלץ את ה‑SoC למצב ROM bootloader.

אותות ה‑SWD של ה‑STM32 מוצאים ב‑מחבר Cortex Debug בן 10 פינים בצעד 1.27 מ“מ בחזית הלוח. חברו אותם דרך SEGGER J‑Link, ST‑Link, או כל גשש JTAG/SWD סטנדרטי של ARM. כל אותות ה‑debug הם בייחוס 3.3 V.

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

נוריות LED¶

ל‑Giga R1 יש נורית RGB יחידה למשתמש, הניתנת לשליטה תוכנתית דרך machine.LED

from machine import LED

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

נורית power נפרדת על הלוח נדלקת בכל פעם שמסילת ה‑+3.3 V פעילה ואינה ניתנת לשליטה על ידי המשתמש.

מחבר מצלמה (J6)¶

J6 הוא מחבר גמיש למצלמה תואם Arducam בן 22 פינים. חברו כל אחד ממודולי החיישנים הנתמכים והקושחה מזהה אותם אוטומטית דרך מודול ה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 — 5 MP צבע, עד QSXGA (2592 × 1944).
OV7670 — 0.3 MP צבע, עד VGA (640 × 480).
GC2145 — 2 MP צבע, עד UXGA (1600 × 1200).
HM01B0 — מונוכרום 320 × 320.
HM0360 — מונוכרום VGA (640 × 480).

אזהרה

בזמן שהמצלמה מאותחלת, פיני מחבר ה‑Mega הבאים נתפסים על ידי הקושחה ואינם ניתנים לשימוש:

פין	סיבה
`D54`–`D65`	אותות נתונים + סנכרון של DCMI על המחבר הגמיש של המצלמה
`D57`	TIM1 CH3 — שעון אב של המצלמה
`D66`	GPIO של reset המצלמה
`D67`	GPIO של power‑down המצלמה
`SDA1` / `SCL1`	I²C 4 — משותף עם המצלמה; האפיק שמיש אך הימנעו מכתובת ה‑I²C של החיישן

למידת מכונה¶

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

    for r, score, keypoints in model.predict([img]):
        ml.utils.draw_predictions(img, [r], ("face",), ((0, 0, 255),), format=None)
        ml.utils.draw_keypoints(img, keypoints, color=(255, 0, 0))

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

ליבת M4¶

ליבת ה‑Cortex‑M4 נחשפת דרך openamp לתקשורת בין‑מעבדים. קושחת OpenMV רצה על ה‑M7 בלבד; ל‑M4 אין סביבת ריצה משלו של MicroPython, כך ששימוש בו מחייב בניית תמונת קושחה נפרדת ב‑C וטעינתה ממערכת הקבצים דרך openamp.RemoteProc. קושחת דוגמה בנויה מראש המממשת נקודת קצה של UART וירטואלי זמינה במאגר openamp_vuart — עקבו אחר ה‑README שלו כדי לבנות את vuart.elf

import openamp
import time

def ept_recv_callback(src_addr, data):
    print("Received:", data.decode())

ept = openamp.Endpoint("vuart-channel", callback=ept_recv_callback)

rproc = openamp.RemoteProc("vuart.elf")
rproc.start()

count = 0
while True:
    if ept.is_ready():
        ept.send("Hello World %d!" % count, timeout=1000)
        count += 1
    time.sleep_ms(1000)

בפועל מוטב להתייחס לתמיכה זו כהדגמה של ממשק ה‑openamp ולא כפלטפורמה דו‑ליבתית פעילה — לא ניתן לאפס את ה‑M4 בנפרד מה‑M7, כך שעצירת ה‑M4 מאלצת אתחול מלא של המערכת.

תצוגה (J5)¶

J5 הוא מחבר MIPI‑DSI עבור ה‑Arduino Giga Display Shield — פאנל מגע קיבולי 480 × 800 הבנוי סביב מנהל הפאנל ST7701 ובקר המגע GT911. שני מנהלי ההתקן מסופקים מוקפאים עם הקושחה. השתמשו בdisplay — מנהל התקן תצוגה כדי לדחוף framebuffers ובgt911.GT911 עבור קלט מגע.

הדוגמה שלהלן משקפת את המצלמה לחלון תצוגה לאורך בגודל 800 × 480 ומכסה כל מגע כמעגל צבעוני:

import csi
import time
import image
import display
from gt911 import GT911
from machine import I2C

IMG_OFFSET = 80
touch_detected = False
points_colors = ((255, 0, 0), (0, 255, 0), (0, 0, 255),
                 (0, 255, 255), (255, 255, 0))

csi0 = csi.CSI()
csi0.reset()
csi0.pixformat(csi.RGB565)
csi0.framesize(csi.VGA)

lcd = display.DSIDisplay(
    framesize=display.FWVGA,
    portrait=True,
    refresh=60,
    controller=display.ST7701(),
)

# Pass pin names (not Pin objects) so the driver can flip
# the reset pin's direction during start-up.
touch = GT911(
    I2C(4, freq=400_000),
    reset_pin="D71",
    irq_pin="D70",
    touch_points=5,
    refresh_rate=240,
    reverse_x=True,
    touch_callback=lambda pin: globals().update(touch_detected=True),
)

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

    if touch_detected:
        n, points = touch.read_points()
        for i in range(n):
            img.draw_circle(
                (points[i][0] - IMG_OFFSET,
                 points[i][1],
                 points[i][2] * 3),
                color=points_colors[points[i][3]],
                thickness=2,
            )
        touch_detected = False

    lcd.write(img, y=IMG_OFFSET, hint=image.TRANSPOSE | image.VFLIP)
    print(clock.fps())

אזהרה

ה‑Giga Display Shield משתמש באותו אפיק I²C 4 (SDA1/SCL1) כמו המצלמה, ב‑D74 להפעלת תאורת הרקע של ה‑LCD, ב‑D70/D71 עבור ה‑IRQ וה‑reset של מגע ה‑GT911, וב‑D68/D69 עבור אותות ה‑TE וה‑RESET של פאנל ה‑DSI.

מיקרופון (Display Shield)¶

ה‑Arduino Giga Display Shield נושא מיקרופון דיגיטלי המחובר להתקן ההיקפי DFSDM של ה‑STM32H747 (שעון מיקרופון על D75, נתוני מיקרופון על D73). המיקרופון נקלט דרך audio — מודול אודיו. כל חוצץ (buffer) מגיע כ‑PCM bytearray של 16 ביט עם סימן, מוכן להזנה לulab/numpy לעיבוד אותות:

import audio
from ulab import numpy as np

def loudness(pcmbuf):
    samples = np.array(np.frombuffer(pcmbuf, dtype=np.int16), dtype=np.float)
    rms = np.sqrt(np.mean(samples ** 2))
    if rms > 10000:
        print("Loud!", int(rms))

audio.init(channels=1, frequency=16000, gain_db=24)
audio.start_streaming(loudness)

while True:
    pass

IMU (Display Shield)¶

ה‑Arduino Giga Display Shield נושא IMU בעל 6 צירים מסוג Bosch BMI270 (מד תאוצה תלת‑ממדי + ג’ירוסקופ תלת‑ממדי) על אותו אפיק I²C 4 בכתובת 0x68. השתמשו במנהל ההתקן הקהילתי micropython_bmi270 כדי לקרוא אותו:

import time
from machine import I2C
from micropython_bmi270 import bmi270

sensor = bmi270.BMI270(I2C(4, freq=400_000))
sensor.load_config_file()

while True:
    ax, ay, az = sensor.acceleration   # m/s²
    gx, gy, gz = sensor.gyro
    print(ax, ay, az, gx, gy, gz)
    time.sleep_ms(100)

מפת האוגרים המלאה נמצאת ב‑datasheet של BMI270.

נורית RGB (Display Shield)¶

ה‑Arduino Giga Display Shield נושא נורית RGB על הלוח המונעת על ידי מנהל נוריות תלת‑ערוצי ISSI IS31FL3197 על אותו אפיק I²C 4. פין ה‑AD של המנהל מחובר ל‑GND, כך שהוא יושב בכתובת I²C 0x50. השתמשו במנהל ההתקן הקהילתי IS31FL3197 כדי לשלוט בנורית:

from machine import I2C
from is31fl3197 import IS31FL3197

led = IS31FL3197(I2C(4, freq=400_000))
led.set_color(255, 0, 0)   # full red

מפת האוגרים המלאה נמצאת ב‑datasheet של IS31FL3197.

Wi‑Fi¶

ה‑Murata 1DX (CYW4343W) שעל הלוח נחשף דרך network — הגדרת רשת כממשק תחנה. חברו את האנטנה המצורפת ל‑מחבר U.FL שעל הלוח לפני הפעלת הרדיו:

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¶

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

import asyncio
import aioble

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

asyncio.run(run())

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

GPIO¶

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

from machine import Pin

out = Pin("D2", Pin.OUT)
out.on()
out.off()
out.value(1)

inp = Pin("D3", Pin.IN, Pin.PULL_UP)
print(inp.value())

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

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

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

UART¶

אפיק	TX	RX	שם Arduino
UART1	D1	D0	Serial1
UART6	D14	D15	Serial2
UART4	D16	D17	Serial3
UART2	D18	D19	Serial4

from machine import UART

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

I²C¶

אפיק	SCL	SDA
I2C2	D21	D20
I2C1	D8	D9
I2C4	SCL1	SDA1

from machine import I2C

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

אפיק 2 (D20/D21, ה‑SCL/SDA המסומנים בהדפס המשי) הוא אפיק ה‑Wire של Arduino כברירת מחדל. אפיק 4 (SCL1/SDA1) משותף עם המצלמה ועם בקר המגע GT911 של ה‑Giga Display Shield — התקני משתמש על אפיק זה חייבים להימנע מהכתובות הבאות (7 ביט):

0x3C — OV5640 / GC2145
0x24 — HM01B0 / HM0360
0x21 — OV7670
0x5D — בקר המגע GT911 (Giga Display Shield)

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

from machine import I2CTarget

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

SPI¶

אפיק	MOSI	MISO	SCK
SPI1	D90	D89	D91
SPI5	D11	D12	D13

SPI1 מוצא על מחבר ייעודי בן 6 פינים בחזית הלוח. SPI5 מוצא על תוויות ה‑COPI/CIPO/SCK המסומנות בהדפס המשי על D11/D12/D13.

הערה

מיפוי הפינים של מחבר ה‑SPI1 הקדמי בן 6 הפינים (J7):

פין	אות
1	`D89` (CIPO)
2	+5V
3	`D91` (SCK)
4	`D90` (COPI)
5	NRST
6	GND

from machine import SPI
from machine import Pin

spi = SPI(5, baudrate=10_000_000)
cs = Pin("D10", 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	D94	D93

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¶

ה‑Giga R1 חושף שנים‑עשר ערוצי ADC של 12 ביט על A0–A11, כולם בייחוס 3.3 V — read_u16 מחזיר 0–65535 על פני 0–3.3 V בפין. A8–A11 הם רפידות _C אנלוגיות בלבד ללא התקן GPIO היקפי:

from machine import ADC
import time

adc = ADC("A0")
while True:
    voltage = adc.read_u16() * 3.3 / 65535
    print(voltage)
    time.sleep_ms(100)

הערה

A7 מחובר גם ל‑כניסת המיקרופון בשקע האודיו TRRS 3.5 מ“מ — כשאוזניות מחוברות, ADC("A7") קורא את אות המיקרופון האנלוגי ישירות.

DAC¶

שני ערוצי DAC של 12 ביט מוצאים על DAC0 ו‑DAC1 דרך pyb.DAC. שניהם מחוברים לשקע האודיו TRRS 3.5 מ“מ כערוצי ה‑line‑out השמאלי והימני:

from pyb import DAC

left  = DAC("DAC0")
right = DAC("DAC1")

left.write(int(0.5 * 255))    # 8‑bit, ~1.65 V
right.write(int(0.5 * 255))

PWM¶

פין	טיימר / ערוץ
D0	TIM4 CH2 / TIM17 CH1N
D1	TIM1 CH2
D2	TIM2 CH4 / TIM5 CH4 / TIM15 CH2
D3	TIM2 CH3 / TIM5 CH3 / TIM15 CH1
D4	TIM1 CH3N / TIM8 CH1
D5	TIM1 CH1N / TIM3 CH2 / TIM8 CH1N / TIM14 CH1
D6	TIM4 CH2
D7	TIM3 CH1
D8	TIM4 CH3 / TIM16 CH1
D9	TIM4 CH4 / TIM17 CH1
D10	TIM1 CH1 / TIM8 CH3N
D11	TIM1 CH2N / TIM8 CH2
D12	TIM1 CH2 / TIM8 CH2N
D13	TIM12 CH1
D15	TIM3 CH2 / TIM8 CH2
D16	TIM8 CH1N
D20	TIM2 CH4
D37	TIM8 CH2
D38	TIM8 CH2N
D40	TIM15 CH2
D46	TIM8 CH3N
D48	TIM1 CH1N / TIM8 CH3
D51	TIM15 CH1
D54	TIM8 CH1
D56	TIM3 CH1 / TIM13 CH1
D57	TIM1 CH3 / TIM8 CH1N
D58	TIM8 CH3
D59	TIM8 CH2
D61	TIM8 CH2N
D63	TIM5 CH2
D64	TIM5 CH1
D65	TIM12 CH2
D68	TIM3 CH1 / TIM8 CH1
D69	TIM5 CH4
D71	TIM8 CH4
D78 / A2	TIM1 CH2N / TIM3 CH3 / TIM8 CH2N
D79 / A3	TIM1 CH3N / TIM3 CH4 / TIM8 CH3N
D83 / A7	TIM2 CH1 / TIM5 CH1
D85 / A13	TIM2 CH1 / TIM8 CH1N

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

from machine import Pin, PWM

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

אזהרה

TIM1 שמור עבור שעון אב של המצלמה כשהמצלמה מאותחלת דרך csi — חיישני מצלמה. פינים שפונקציית ה‑PWM היחידה שלהם היא על TIM1 — D1, D10, D11, D12 — אינם ניתנים להנעת PWM בזמן שהמצלמה פעילה. שאר הפינים המפורטים כולם בעלי חלופות שאינן TIM1.

הערה

מספר פינים חולקים ערוצי טיימר:

TIM2 CH4 נמצא על D2 וגם על D20.
TIM2 CH1 נמצא על D83/A7 וגם על D85/A13.
TIM3 CH1 נמצא על D7, D56, וגם על D68.
TIM3 CH2 נמצא על D5 וגם על D15.
TIM4 CH2 נמצא על D0 וגם על D6.
TIM5 CH1 נמצא על D64 וגם על D83/A7.
TIM5 CH4 נמצא על D2 וגם על D69.
TIM8 CH1 נמצא על D4, D54, וגם על D68.
TIM8 CH1N נמצא על D5, D16, D57, וגם על D85/A13.
TIM8 CH2 נמצא על D11, D15, D37, וגם על D59.
TIM8 CH2N נמצא על D12, D38, D61, וגם על D78/A2.
TIM8 CH3 נמצא על D48 וגם על D58.
TIM8 CH3N נמצא על D10, D46, וגם על D79/A3.
TIM15 CH1 נמצא על D3 וגם על D51.
TIM15 CH2 נמצא על D2 וגם על D40.

בחרו צרכן אחד לכל ערוץ טיימר.

אפיקים תוכנתיים בשיטת 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 1 — חברו את המודול ל‑D8 (SCL) ול‑D9 (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 כמזהה כדי להשתמש בטיימר וירטואלי (תוכנתי):

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

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

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

עדכון קושחה (DFU)¶

ה‑Giga R1 משתמש ב‑double‑tap reset הסטנדרטי של Arduino כדי להיכנס ל‑bootloader של Arduino. לחצו במהירות על כפתור ה‑RESET פעמיים — הלוח מתמספר מחדש דרך USB כהתקן DFU ו‑OpenMV IDE יכול לצרוב תמונת קושחה חדשה. אם ה‑bootloader חסר לחלוטין, החזיקו את כפתור ה‑BOOT0 בזמן הלחיצה על RESET כדי לאלץ את ה‑SoC למצב ROM bootloader.

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

import machine

machine.bootloader()

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

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

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

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

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

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

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

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

הערה

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

הערה

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

גדלי אחסון¶

ה‑Giga R1 מסופק עם:

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

מחוון hard‑fault¶

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

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

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