Arduino Giga R1 WiFi¶

Arduino Giga R1 WiFi to płytka w formacie Mega o wymiarach 101 × 53 mm, zbudowana wokół układu STMicroelectronics STM32H747XI — dwurdzeniowego SoC łączącego rdzeń Cortex‑M7 taktowany 480 MHz z rdzeniem Cortex‑M4 taktowanym 240 MHz. Oprogramowanie układowe OpenMV działa w całości na rdzeniu M7. Giga dodaje do standardowego układu złączy Arduino Mega 22‑pinowe elastyczne złącze kamery Arducam, złącze MIPI‑DSI dla Arduino Giga Display Shield oraz gniazdo audio stereo 3,5 mm.

Pełną kartę katalogową, zdjęcia i wymiary znajdziesz na stronie produktu Arduino Giga R1 WiFi.

Najważniejsze cechy¶

STMicroelectronics STM32H747XI dwurdzeniowy Cortex‑M7 (480 MHz) + Cortex‑M4 (240 MHz). Oprogramowanie układowe OpenMV działa wyłącznie na rdzeniu M7; rdzeń M4 jest udostępniany poprzez openamp do komunikacji międzyprocesorowej.
8 MB zewnętrznej pamięci SDRAM oraz 2 MB wewnętrznej pamięci flash i 16 MB zewnętrznej pamięci QSPI flash.
Sprzętowy enkoder/dekoder JPEG.
22‑pinowe elastyczne złącze kamery zgodne z Arducam (J6) — sterowniki obsługują moduły sensorów OV5640 (5MP), OV7670, GC2145, HM01B0 oraz HM0360.
Złącze wyświetlacza MIPI‑DSI (J5) dla Arduino Giga Display Shield (panel dotykowy pojemnościowy 480×800) oraz silnik wyświetlacza RGB LTDC dla zaawansowanych płytek nośnych.
Gniazdo audio 3,5 mm z wyjściem liniowym stereo i wejściem mikrofonowym.
Wi‑Fi b/g/n (2,4 GHz) + Bluetooth LE 5.1 poprzez moduł Murata 1DX (CYW4343W) — łączy się z dostarczoną anteną przez wbudowane złącze U.FL.
USB‑C (full‑speed) do zasilania / komunikacji szeregowej / programowania.
Wejścia/wyjścia użytkownika na złączach w stylu Mega — D0–D75 (cyfrowe), A0–A11 (analogowe), DAC0/DAC1 (wyjścia DAC), CAN_RX/CAN_TX (FDCAN2) oraz para I²C SDA1/SCL1 w wewnętrznym rzędzie. Osobne 6‑pinowe złącze SPI1 z przodu płytki wyprowadza CIPO/COPI/SCK (D89/D90/D91).
JTAG / SWD wyprowadzone na złączu debugowania po górnej stronie płytki, do zaawansowanego debugowania.

Rozkład wyprowadzeń¶

Wykaz wyprowadzeń¶

Złącza w stylu Arduino Mega udostępniają 76 pinów cyfrowych (D0–D75), 12 pinów analogowych (A0–A11), dwa wyjścia DAC (DAC0/DAC1), drugą parę I²C (SDA1/SCL1) oraz parę FDCAN2 (CAN_RX/CAN_TX). Osobne 6‑pinowe złącze SPI1 z przodu płytki wyprowadza CIPO/COPI/SCK (D89/D90/D91).

Nazwa pinu	Odniesienie	Funkcja
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 (kamera DCMI VSYNC)
D55	3.3 V	I2C3 SDA (kamera DCMI HSYNC)
D56	3.3 V	TIM3 CH1 / TIM13 CH1 (kamera DCMI PXCLK)
D57	3.3 V	TIM8 CH1N / UART8 RX (zegar główny kamery — TIM1 CH3)
D58	3.3 V	TIM8 CH3 (kamera DCMI D7)
D59	3.3 V	TIM8 CH2 (kamera DCMI D6)
D60	3.3 V	GPIO (kamera DCMI D5)
D61	3.3 V	TIM8 CH2N / UART4 RX (kamera DCMI D4)
D62	3.3 V	SPI1 SCK (kamera DCMI D3)
D63	3.3 V	TIM5 CH2 / I2C4 SCL (I²C wyświetlacza)
D64	3.3 V	TIM5 CH1 (kamera DCMI D1)
D65	3.3 V	TIM12 CH2 (kamera DCMI D0)
D66	3.3 V	GPIO (reset kamery — zajęty, gdy kamera jest aktywna)
D67	3.3 V	GPIO (wyłączenie zasilania kamery — zajęty, gdy kamera jest aktywna)
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 (dane mikrofonu DFSDM Display Shield)
D74	3.3 V	GPIO (podświetlenie wyświetlacza — zajęty przez Giga Display Shield)
D75	3.3 V	SPI2 SCK (zegar mikrofonu DFSDM Display Shield)
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 (wejście mikrofonu gniazda audio)
A8	3.3 V	ADC3 IN0 (tylko analogowe)
A9	3.3 V	ADC3 IN1 (tylko analogowe)
A10	3.3 V	ADC12 IN1 (tylko analogowe)
A11	3.3 V	ADC12 IN0 (tylko analogowe)
DAC0 / A12 / D84	3.3 V	DAC1 OUT1 / ADC12 IN18 (wyjście liniowe gniazda audio L)
DAC1 / A13 / D85	3.3 V	DAC1 OUT2 / TIM2 CH1 / SPI1 SCK / ADC12 IN19 (wyjście liniowe gniazda audio R)
D89	3.3 V	SPI1 MISO (`CIPO` na przednim złączu SPI)
D90	3.3 V	SPI1 MOSI (`COPI` na przednim złączu SPI)
D91	3.3 V	SPI1 SCK (`SCK` na przednim złączu SPI)
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 (magistrala dotyku wyświetlacza / sterowania kamerą)
SCL1 / D101	3.3 V	I2C4 SCL (magistrala dotyku wyświetlacza / sterowania kamerą)
RESET	3.3 V	naciśnij wbudowany przycisk RESET lub zewrzyj do GND, aby zresetować
LED_RED	3.3 V	czerwony kanał diody RGB LED (aktywny stanem niskim)
LED_GREEN	3.3 V	zielony kanał diody RGB LED (aktywny stanem niskim)
LED_BLUE	3.3 V	niebieski kanał diody RGB LED (aktywny stanem niskim)

Informacja

A8–A11 to pola wyłącznie analogowe na pinach _C układu STM32H747 — nie mają funkcji GPIO i można je odczytać tylko przez ADC.

Piny zasilania¶

Piny złącza Mega:

VIN — wejście 6–32 V. Zasila płytkę przez wbudowaną przetwornicę step‑down.
+5V — szyna 5 V zasilana z USB przez diodę lub wbudowaną przetwornicę step‑down.
+3V3 — główna szyna 3,3 V.
IOREF — odzwierciedla napięcie wejść/wyjść płytki (3,3 V).
AREF — analogowe napięcie odniesienia dla pinów ADC. Domyślnie 3,3 V; podaj napięcie zewnętrznie, aby użyć innego odniesienia.
OFF — zewrzyj do GND, aby wyłączyć szynę +3,3 V i wyłączyć system.
VRTC — wejście baterii pastylkowej 3,0 V (maks. 3,3 V), które utrzymuje działanie wbudowanego RTC, gdy reszta płytki jest wyłączona.
GND — wspólna masa.

Giga R1 można zasilać dowolną z tych dróg:

USB‑C — dostarcza 5 V do wbudowanej przetwornicy step‑down.
Pin VIN — podaj bezpośrednio stabilizowane napięcie 6–32 V.

Wskazówka

Użyj kalkulatora żywotności baterii, aby oszacować, jak długo Giga R1 będzie działać na baterii przy zadanym cyklu pracy aktywnej / głębokiego uśpienia.

Piny odzyskiwania i debugowania¶

RESET — zarówno wyprowadzony pin na złączu zasilania, jak i chwilowy przełącznik na górze płytki, połączone z linią NRST układu SoC. Zewrzyj do GND lub naciśnij przycisk, aby zresetować.

Jeśli bootloader całkowicie brakuje, przytrzymaj przycisk BOOT0 podczas naciskania RESET, aby wymusić wejście układu SoC w tryb bootloadera ROM.

Sygnały SWD układu STM32 są wyprowadzone na 10‑pinowym złączu Cortex Debug o rastrze 1,27 mm z przodu płytki. Podłącz je przez SEGGER J‑Link, ST‑Link lub dowolną standardową sondę ARM JTAG/SWD. Wszystkie sygnały debugowania mają odniesienie 3,3 V.

Wbudowane urządzenia peryferyjne¶

LEDs¶

Giga R1 ma jedną użytkową diodę RGB LED, sterowaną programowo przez machine.LED

from machine import LED

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

Osobna dioda zasilania na płytce świeci się zawsze, gdy szyna +3,3 V jest aktywna, i nie jest sterowana przez użytkownika.

Złącze kamery (J6)¶

J6 to 22‑pinowe elastyczne złącze kamery zgodne z Arducam. Podłącz dowolny z obsługiwanych modułów sensorów, a oprogramowanie układowe automatycznie je wykryje przez moduł csi — sensory kamery

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

Obsługiwane sensory:

OV5640 — 5 MP kolor, do QSXGA (2592 × 1944).
OV7670 — 0,3 MP kolor, do VGA (640 × 480).
GC2145 — 2 MP kolor, do UXGA (1600 × 1200).
HM01B0 — 320 × 320 monochromatyczny.
HM0360 — VGA (640 × 480) monochromatyczny.

Ostrzeżenie

Gdy kamera jest zainicjalizowana, następujące piny złącza Mega są zajęte przez oprogramowanie układowe i nie mogą być używane:

Pin	Powód
`D54`–`D65`	sygnały danych i synchronizacji DCMI na elastycznym złączu kamery
`D57`	TIM1 CH3 — zegar główny kamery
`D66`	GPIO resetu kamery
`D67`	GPIO wyłączenia zasilania kamery
`SDA1` / `SCL1`	I²C 4 — współdzielona z kamerą; magistrala jest używalna, ale unikaj adresu I²C sensora

Uczenie maszynowe¶

ml — Uczenie maszynowe uruchamia skwantyzowane modele TFLite na rdzeniu Cortex‑M7 z jądrami CMSIS‑NN — wystarczająco szybko dla kompaktowych detektorów przy kilku ramkach na sekundę. Modele w systemie plików tylko do odczytu /rom ładują się bezpośrednio z pamięci flash, bez kopiowania do RAM. Oto detektor BlazeFace 128×128 nakładający wykrytą twarz i jej sześć punktów charakterystycznych na każdą ramkę:

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

Rdzeń M4¶

Rdzeń Cortex‑M4 jest udostępniany przez openamp do komunikacji międzyprocesorowej. Oprogramowanie układowe OpenMV działa wyłącznie na M7; M4 nie ma własnego środowiska uruchomieniowego MicroPython, więc jego użycie oznacza zbudowanie osobnego obrazu oprogramowania układowego w C i wczytanie go z systemu plików przez openamp.RemoteProc. Gotowe przykładowe oprogramowanie układowe implementujące wirtualny punkt końcowy UART jest dostępne w repozytorium openamp_vuart — postępuj zgodnie z jego plikiem README, aby zbudować 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)

W praktyce tę obsługę najlepiej traktować jako demonstrację interfejsu openamp, a nie działającą platformę dwurdzeniową — M4 nie można zresetować niezależnie od M7, więc zatrzymanie M4 wymusza pełny restart systemu.

Wyświetlacz (J5)¶

J5 to złącze MIPI‑DSI dla Arduino Giga Display Shield — pojemnościowego panelu dotykowego 480 × 800 zbudowanego wokół sterownika panelu ST7701 i kontrolera dotyku GT911. Oba sterowniki są dostarczane wbudowane w oprogramowanie układowe. Użyj display — sterownik wyświetlacza, aby przesyłać bufory ramek, oraz gt911.GT911 do obsługi wejścia dotykowego.

Poniższy przykład odwzorowuje obraz z kamery w pionowym oknie wyświetlacza 800 × 480 i nakłada każdy punkt dotyku jako kolorowe kółko:

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

Ostrzeżenie

Giga Display Shield używa tej samej magistrali I²C 4 (SDA1/SCL1) co kamera, pinu D74 do włączania podświetlenia LCD, pinów D70/D71 dla IRQ i resetu dotyku GT911 oraz pinów D68/D69 dla sygnałów TE i RESET panelu DSI.

Mikrofon (Display Shield)¶

Arduino Giga Display Shield zawiera cyfrowy mikrofon podłączony do urządzenia peryferyjnego DFSDM układu STM32H747 (zegar mikrofonu na D75, dane mikrofonu na D73). Mikrofon jest przechwytywany przez audio — Moduł Audio. Każdy bufor dociera jako 16‑bitowy PCM ze znakiem w postaci bytearray, gotowy do przekazania do ulab/numpy do przetwarzania DSP:

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 zawiera 6‑osiowy IMU Bosch BMI270 (akcelerometr 3D + żyroskop 3D) na tej samej magistrali I²C 4 pod adresem 0x68. Użyj społecznościowego sterownika micropython_bmi270, aby go odczytać:

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)

Pełna mapa rejestrów znajduje się w karcie katalogowej BMI270.

RGB LED (Display Shield)¶

Arduino Giga Display Shield zawiera wbudowaną diodę RGB LED sterowaną 3‑kanałowym sterownikiem LED ISSI IS31FL3197 na tej samej magistrali I²C 4. Pin AD sterownika jest połączony z GND, więc znajduje się pod adresem I²C 0x50. Użyj społecznościowego sterownika IS31FL3197, aby sterować diodą LED:

from machine import I2C
from is31fl3197 import IS31FL3197

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

Pełna mapa rejestrów znajduje się w karcie katalogowej IS31FL3197.

Wi‑Fi¶

Wbudowany moduł Murata 1DX (CYW4343W) jest udostępniany przez network — konfiguracja sieci jako interfejs stacji. Podłącz dostarczoną antenę do wbudowanego złącza U.FL, zanim uruchomisz radio:

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¶

Ten sam moduł Murata 1DX udostępnia również Bluetooth LE 5.1. Użyj aioble — Asynchroniczne BLE do obsługi BLE przyjaznej dla asyncio — na przykład rozgłaszaj jako urządzenie peryferyjne i czekaj na połączenie ze strony centralnej:

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

Wykaz magistral¶

GPIO¶

Użyj machine.Pin, aby odczytać lub sterować dowolnym z opisanych na sitodruku pinów. Wyjścia są typu CMOS 3,3 V i mogą pochłaniać/dostarczać do 20 mA na pin (łącznie 140 mA na całym złączu).

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

Każdy pin wejściowy może również wywołać przerwanie przy zmianach na zboczu:

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

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

UART¶

Bus	TX	RX	Nazwa 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¶

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

Magistrala 2 (D20/D21, opisane na sitodruku SCL/SDA) to domyślna magistrala Arduino Wire. Magistrala 4 (SCL1/SDA1) jest współdzielona z kamerą i kontrolerem dotyku GT911 Giga Display Shield — urządzenia użytkownika na tej magistrali muszą unikać następujących adresów (7‑bitowych):

0x3C — OV5640 / GC2145
0x24 — HM01B0 / HM0360
0x21 — OV7670
0x5D — kontroler dotyku GT911 (Giga Display Shield)

Tego samego sprzętu można też użyć w trybie docelowym (slave) przez machine.I2CTarget, aby udostępnić obszar pamięci innemu kontrolerowi I²C:

from machine import I2CTarget

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

SPI¶

Bus	MOSI	MISO	SCK
SPI1	D90	D89	D91
SPI5	D11	D12	D13

SPI1 jest wyprowadzony na dedykowanym 6‑pinowym złączu z przodu płytki. SPI5 jest wyprowadzony na opisanych na sitodruku etykietach COPI/CIPO/SCK na pinach D11/D12/D13.

Informacja

Rozkład wyprowadzeń przedniego 6‑pinowego złącza SPI1 (J7):

Pin	Signal
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)¶

Bus	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 udostępnia dwanaście 12‑bitowych kanałów ADC na pinach A0–A11, wszystkie z odniesieniem 3,3 V — read_u16 zwraca 0–65535 w zakresie 0–3,3 V na pinie. A8–A11 to wyłącznie analogowe pola _C bez urządzenia peryferyjnego 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)

Informacja

A7 jest także podłączony do wejścia mikrofonowego na gnieździe audio TRRS 3,5 mm — gdy zestaw słuchawkowy jest podłączony, ADC("A7") odczytuje bezpośrednio analogowy sygnał mikrofonu.

DAC¶

Dwa 12‑bitowe kanały DAC są udostępniane na DAC0 i DAC1 przez pyb.DAC. Oba są podłączone do gniazda audio TRRS 3,5 mm jako lewy i prawy kanał wyjścia liniowego

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¶

Pin	Licznik czasu (timer) / kanał
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

Steruj dowolnym z nich przez machine.PWM

from machine import Pin, PWM

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

Ostrzeżenie

TIM1 jest zarezerwowany dla zegara głównego kamery, gdy kamera jest inicjalizowana przez csi — sensory kamery. Piny, których jedyna funkcja PWM jest na TIM1 — D1, D10, D11, D12 — nie mogą być sterowane PWM, gdy kamera jest aktywna. Wszystkie pozostałe wymienione piny mają alternatywy spoza TIM1.

Informacja

Kilka pinów współdzieli kanały licznika czasu (timera):

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

Wybierz jednego odbiorcę na kanał licznika czasu (timera).

Programowe magistrale bit‑bang¶

machine.SoftI2C i machine.SoftSPI działają na dowolnym GPIO, jeśli potrzebujesz dodatkowej magistrali.

Sensor termiczny (zewnętrzny)¶

Oprogramowanie układowe zawiera sterownik fir — sterownik sensora termicznego (fir == far infrared, daleka podczerwień) dla zewnętrznie podłączonych kamer termowizyjnych:

MLX90621 — matryca IR 16 × 4
MLX90640 — matryca IR 32 × 24
MLX90641 — matryca IR 16 × 12
AMG8833 — matryca IR 8 × 8

Podłącz moduł do magistrali I²C płytki i odczytuj ramki za pomocą 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())

Sterownik fir komunikuje się z sensorem tylko przez I²C 1 — podłącz moduł do D8 (SCL) i D9 (SDA).

Pomiar czasu¶

time¶

Moduł time obejmuje blokujące opóźnienia, monotoniczne tiknięcia oraz pomiar upływu czasu:

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)

Wirtualne liczniki czasu¶

machine.Timer planuje okresowe lub jednorazowe wywołania zwrotne bez zajmowania slotu sprzętowego licznika czasu. Przekaż -1 jako id, aby użyć wirtualnego (programowego) licznika czasu:

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

Wartości okresu są podawane w milisekundach. Wywołaj deinit(), aby zatrzymać i zwolnić slot.

Zegar czasu rzeczywistego¶

machine.RTC utrzymuje czas zegarowy pomiędzy resetami — a także przy całkowitym wyłączeniu zasilania, gdy do pinu VRTC podłączona jest bateria pastylkowa:

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 resetuje płytkę, jeśli aplikacja się zawiesi. Po uruchomieniu nie można go zatrzymać ani ponownie skonfigurować — odświeżaj go okresowo wewnątrz głównej pętli:

from machine import WDT

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

Informacje o rozruchu i czasie wykonania¶

Aktualizacja oprogramowania układowego (DFU)¶

Giga R1 używa standardowego dla Arduino podwójnego naciśnięcia resetu, aby wejść do bootloadera Arduino. Szybko naciśnij dwukrotnie przycisk RESET — płytka ponownie wyliczy się przez USB jako urządzenie DFU, a OpenMV IDE może wgrać nowy obraz oprogramowania układowego. Jeśli bootloader całkowicie brakuje, przytrzymaj przycisk BOOT0 podczas naciskania RESET, aby wymusić wejście układu SoC w tryb bootloadera ROM.

Działający skrypt może na żądanie ponownie wejść do bootloadera, wywołując machine.bootloader()

import machine

machine.bootloader()

System plików i kolejność rozruchu¶

Oprogramowanie układowe Giga R1 montuje przy rozruchu do dwóch systemów plików:

Wewnętrzna pamięć flash — zawsze montowana w /flash. Domyślnie przechowuje main.py i README.txt; tworzona przy pierwszym rozruchu.
ROMFS — system plików tylko do odczytu, mapowany w pamięci pod /rom, montowany automatycznie przez MicroPython przy starcie.

Po zamontowaniu katalog roboczy jest ustawiany na /flash. Interpreter uruchamia następnie skrypty z tego katalogu:

boot.py jest wykonywany przy każdym miękkim resecie (zimny rozruch, Ctrl‑D z REPL lub za każdym razem, gdy działający skrypt zwraca sterowanie).
main.py jest wykonywany tylko przy zimnym rozruchu, bezpośrednio po boot.py. Kolejne miękkie resety ponownie uruchamiają boot.py, ale przechodzą prosto do REPL — aby ponownie uruchomić main.py, musisz w pełni zresetować płytkę.

Domyślny main.py dostarczany na świeżo zaprogramowanej płytce po prostu miga niebieskim kanałem użytkowej diody RGB LED jako sygnał życia (dwa krótkie impulsy, krótka przerwa), dzięki czemu możesz stwierdzić, że oprogramowanie układowe uruchomiło się poprawnie, bez podłączonego hosta.

sys.path jest rozszerzany o oba systemy plików oraz ich podkatalogi lib/, dzięki czemu importowalne moduły mogą znajdować się w /flash/lib lub /rom/lib.

Po podłączeniu przez USB /flash wylicza się również jako dysk pamięci masowej USB na hoście, pozwalając edytować bezpośrednio boot.py, main.py i wszelkie inne pliki. Wysuń dysk przed zresetowaniem płytki, aby host zapisał buforowane zmiany.

Informacja

Ponieważ system operacyjny traktuje dysk jako pasywne urządzenie blokowe, pliki utworzone lub zmodyfikowane przez kod działający na kamerze nie pojawią się, dopóki host ponownie nie zamontuje dysku. Jeśli zarówno system operacyjny, jak i kamera zapisują ten sam system plików w tym samym czasie, system operacyjny wygra i nadpisze zmiany dokonane przez kamerę.

Informacja

Czerwony kanał użytkowej diody RGB LED może na chwilę się zaświecić, gdy host odczytuje lub zapisuje dysk pamięci masowej USB — to wskaźnik aktywności sterowany przez oprogramowanie układowe, a nie usterka.

Rozmiary pamięci masowej¶

Giga R1 jest dostarczany z:

/flash — system plików FAT o pojemności 11 MB, do odczytu/zapisu.
/rom — 4 MB systemu plików ROMFS tylko do odczytu, mapowanego w pamięci, używanego do dostarczania skryptów i modeli ML, które korzystają z dostępu mmap bez kopiowania.

Wskaźnik krytycznego błędu (hard fault)¶

Jeśli użytkowa dioda RGB LED szybko przełącza się między wszystkimi kolorami — na tyle szybko, że zwykle wygląda jak migocząca biała dioda LED, a nie odrębne barwy — oprogramowanie układowe napotkało nieodwracalny krytyczny błąd (hard fault). Ponownie wgraj oprogramowanie układowe, aby przywrócić działanie; jeśli to nie pomoże, płytka może być fizycznie uszkodzona.

Biblioteki programowe¶

Pełną listę modułów — w tym te unikalne dla wersji Giga R1 — znajdziesz w indeksie biblioteki.