Arduino Giga R1 WiFi

Az Arduino Giga R1 WiFi egy 101 × 53 mm-es, Mega-formátumú kártya, amelyet az STMicroelectronics STM32H747XI köré építettek — ez egy kétmagos SoC, amely egy 480 MHz-es Cortex‑M7 magot kombinál egy 240 MHz-es Cortex‑M4 maggal. Az OpenMV firmware teljes egészében az M7 magon fut. A Giga a szabványos Arduino Mega tüskesor-elrendezést egy 22 lábú Arducam kamera flex csatlakozóval, egy MIPI‑DSI csatlakozóval az Arduino Giga Display Shield számára, valamint egy 3,5 mm-es sztereó audio jackkel egészíti ki.

A teljes adatlapért, fényképekért és méretekért lásd az Arduino Giga R1 WiFi termékoldalt.

Kiemelt jellemzők

• STMicroelectronics STM32H747XI kétmagos Cortex‑M7 (480 MHz) + Cortex‑M4 (240 MHz). Az OpenMV firmware csak az M7 magon fut; az M4 mag az openamp modulon keresztül érhető el a processzorok közötti kommunikációhoz.

• 8 MB külső SDRAM, valamint 2 MB belső flash memória és 16 MB külső QSPI flash memória.

• Hardveres JPEG kódoló/dekódoló.

• 22 lábú, Arducam-kompatibilis kamera flex csatlakozó (J6) — illesztőprogram-támogatás az OV5640 (5MP), OV7670, GC2145, HM01B0 és HM0360 érzékelőmodulokhoz.

• MIPI‑DSI kijelzőcsatlakozó (J5) az Arduino Giga Display Shield számára (480×800 kapacitív érintőpanel), valamint egy LTDC RGB kijelzőmotor a fejlettebb hordozókártyákhoz.

• 3,5 mm-es audio jack sztereó vonalkimenettel és mikrofonbemenettel.

• Wi‑Fi b/g/n (2,4 GHz) + Bluetooth LE 5.1 a Murata 1DX (CYW4343W) modulon keresztül — a mellékelt antennához egy beépített U.FL csatlakozóval kapcsolódik.

• USB‑C (full‑speed) tápellátáshoz / soros kommunikációhoz / programozáshoz.

• Felhasználói I/O a Mega-stílusú tüskesorokon — D0–D75 (digitális), A0–A11 (analóg), DAC0/DAC1 (DAC kimenetek), CAN_RX/CAN_TX (FDCAN2), valamint a belső soron lévő SDA1/SCL1 I²C pár. A kártya elülső oldalán egy különálló 6 lábú SPI1 tüskesor vezeti ki a CIPO/COPI/SCK jeleket (D89/D90/D91).

• JTAG / SWD a felső oldali debug tüskesoron kivezetve a fejlett hibakereséshez.

Lábkiosztás

Láb referencia

Az Arduino Mega-stílusú tüskesorok 76 digitális lábat (D0–D75), 12 analóg lábat (A0–A11), két DAC kimenetet (DAC0/DAC1), egy másodlagos I²C párt (SDA1/SCL1) és egy FDCAN2 párt (CAN_RX/CAN_TX) tesznek elérhetővé. A kártya elülső oldalán egy különálló 6 lábú SPI1 tüskesor vezeti ki a CIPO/COPI/SCK jeleket (D89/D90/D91).

Láb neve	Referencia	Funkció
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 (kamera fő órajel — 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 (kijelző I²C)
D64	3.3 V	TIM5 CH1 (kamera DCMI D1)
D65	3.3 V	TIM12 CH2 (kamera DCMI D0)
D66	3.3 V	GPIO (kamera reset — lefoglalva, amikor a kamera aktív)
D67	3.3 V	GPIO (kamera power‑down — lefoglalva, amikor a kamera aktív)
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 mikrofon adat)
D74	3.3 V	GPIO (kijelző háttérvilágítás — a Giga Display Shield foglalja le)
D75	3.3 V	SPI2 SCK (Display Shield DFSDM mikrofon órajel)
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 mikrofonbemenet)
A8	3.3 V	ADC3 IN0 (csak analóg)
A9	3.3 V	ADC3 IN1 (csak analóg)
A10	3.3 V	ADC12 IN1 (csak analóg)
A11	3.3 V	ADC12 IN0 (csak analóg)
DAC0 / A12 / D84	3.3 V	DAC1 OUT1 / ADC12 IN18 (audio jack vonalkimenet L)
DAC1 / A13 / D85	3.3 V	DAC1 OUT2 / TIM2 CH1 / SPI1 SCK / ADC12 IN19 (audio jack vonalkimenet R)
D89	3.3 V	SPI1 MISO (CIPO az elülső SPI tüskesoron)
D90	3.3 V	SPI1 MOSI (COPI az elülső SPI tüskesoron)
D91	3.3 V	SPI1 SCK (SCK az elülső SPI tüskesoron)
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 (kijelző érintés / kamera vezérlő busz)
SCL1 / D101	3.3 V	I2C4 SCL (kijelző érintés / kamera vezérlő busz)
RESET	3.3 V	nyomd meg a kártyán lévő RESET gombot vagy húzd GND-re a visszaállításhoz
LED_RED	3.3 V	RGB LED piros csatorna (aktív alacsony szinten)
LED_GREEN	3.3 V	RGB LED zöld csatorna (aktív alacsony szinten)
LED_BLUE	3.3 V	RGB LED kék csatorna (aktív alacsony szinten)

Megjegyzés

Az A8–A11 csak analóg kontaktusok az STM32H747 _C lábain — nincs GPIO funkciójuk, és csak az ADC-n keresztül olvashatók.

Tápláb

Mega tüskesor lábai:

• VIN — 6–32 V bemenet. A kártyát a beépített buck szabályozón keresztül táplálja.

• +5V — 5 V-os tápsín, amelyet az USB egy diódán keresztül vagy a beépített buck szabályozó táplál.

• +3V3 — fő 3,3 V-os tápsín.

• IOREF — a kártya I/O feszültségét tükrözi (3,3 V).

• AREF — analóg feszültségreferencia az ADC lábakhoz. Alapértelmezetten 3,3 V; más referencia használatához hajtsd meg kívülről.

• OFF — húzd GND-re a +3,3 V-os tápsín kikapcsolásához és a rendszer leállításához.

• VRTC — 3,0 V-os gombelem-bemenet (max. 3,3 V), amely a kártya többi részének kikapcsolt állapotában is működésben tartja a chipbe épített RTC-t.

• GND — közös föld.

A Giga R1 az alábbi útvonalak bármelyikén keresztül táplálható:

• USB‑C — 5 V-ot biztosít a beépített buck szabályozónak.

• VIN láb — hajts rá közvetlenül egy stabilizált 6–32 V-os tápforrást.

Javaslat

Használd az akkumulátor-élettartam becslőt annak modellezéséhez, hogy egy adott aktív / mélyalvási munkaciklus mellett mennyi ideig fog működni a Giga R1 akkumulátorról.

Helyreállítási és debug lábak

• RESET — egyszerre egy kivezetett láb a tápellátás tüskesorán és egy nyomógomb a kártya tetején, amelyek a SoC NRST vonalához kapcsolódnak. A visszaállításhoz húzd GND-re vagy nyomd meg a gombot.

A Giga R1 az Arduino szabványos dupla koppintásos reset módszerét használja az Arduino rendszerbetöltőjének elindításához. Nyomd meg gyorsan kétszer a RESET gombot — a kártya újra felsorolja magát az USB-n DFU eszközként, és az OpenMV IDE új firmware-képet tölthet rá.

Ha a rendszerbetöltő teljesen hiányzik, tartsd lenyomva a BOOT0 gombot, miközben megnyomod a RESET-et, hogy a SoC-t a ROM rendszerbetöltő módba kényszerítsd.

Az STM32 SWD jelei a kártya elülső oldalán lévő 10 lábú, 1,27 mm-es Cortex Debug tüskesoron vannak kivezetve. Csatlakoztasd őket egy SEGGER J‑Link, ST‑Link vagy bármely szabványos ARM JTAG/SWD szondán keresztül. Minden debug jel 3,3 V referenciájú.

Beépített perifériák

LED-ek

A Giga R1 egyetlen felhasználói RGB LED-del rendelkezik, amely szoftveresen vezérelhető a machine.LED segítségével:

from machine import LED

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

A kártyán lévő külön tápellátás LED akkor világít, amikor a +3,3 V-os tápsín aktív, és nem vezérelhető a felhasználó által.

Kamera csatlakozó (J6)

A J6 egy 22 lábú, Arducam-kompatibilis kamera flex csatlakozó. Csatlakoztasd a támogatott érzékelőmodulok bármelyikét, és a firmware automatikusan felismeri őket a csi — kameraérzékelők modulon keresztül:

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

Támogatott érzékelők:

• OV5640 — 5 MP színes, akár QSXGA (2592 × 1944).

• OV7670 — 0,3 MP színes, akár VGA (640 × 480).

• GC2145 — 2 MP színes, akár UXGA (1600 × 1200).

• HM01B0 — 320 × 320 monokróm.

• HM0360 — VGA (640 × 480) monokróm.

Figyelem

Amíg a kamera inicializálva van, az alábbi Mega tüskesor lábakat a firmware lefoglalja, és nem használhatók:

Láb	Indok
D54–D65	DCMI adat- + szinkronjelek a kamera flex csatlakozón
D57	TIM1 CH3 — kamera fő órajel
D66	Kamera reset GPIO
D67	Kamera power‑down GPIO
SDA1 / SCL1	I²C 4 — a kamerával megosztva; a busz használható, de kerüld az érzékelő I²C címét

Gépi tanulás

A ml — Gépi tanulás kvantált TFLite modelleket futtat a Cortex‑M7-en CMSIS‑NN kernelekkel — elég gyorsan ahhoz, hogy kompakt detektorokat néhány képkocka/másodperc sebességgel futtasson. A csak olvasható /rom fájlrendszeren lévő modellek közvetlenül a flash memóriából töltődnek be, RAM-ba másolás nélkül. Íme egy 128×128-as BlazeFace detektor, amely minden képkockára rávetíti az észlelt arcot és annak hat jellegzetes pontját:

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 mag

A Cortex‑M4 mag az openamp modulon keresztül érhető el a processzorok közötti kommunikációhoz. Az OpenMV firmware csak az M7-en fut; az M4-nek nincs saját MicroPython futtatókörnyezete, így a használata azt jelenti, hogy külön C firmware-képet kell építeni, és azt a fájlrendszerből betölteni az openamp.RemoteProc segítségével. Egy előre lefordított, virtuális UART végpontot megvalósító példa firmware elérhető az openamp_vuart tárolóban — kövesd a README-jét a vuart.elf felépítéséhez:

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)

A gyakorlatban ezt a támogatást inkább az openamp interfész bemutatójaként érdemes kezelni, semmint működő kétmagos platformként — az M4 nem állítható vissza az M7-től függetlenül, így az M4 leállítása a teljes rendszer újraindítását kényszeríti ki.

Kijelző (J5)

A J5 egy MIPI‑DSI csatlakozó az Arduino Giga Display Shield számára — ez egy 480 × 800-as kapacitív érintőpanel, amelyet az ST7701 panel-illesztő és a GT911 érintésvezérlő köré építettek. Mindkét illesztőprogram beágyazva érkezik a firmware-rel. Használd a display — kijelzőmeghajtó modult a képkocka-pufferek megjelenítéséhez és a gt911.GT911 osztályt az érintésbemenethez.

Az alábbi példa a kamera képét egy álló tájolású 800 × 480-as kijelzőablakba tükrözi, és minden érintési kontaktust egy színes körrel vetít rá:

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

Figyelem

A Giga Display Shield ugyanazt az I²C 4 buszt (SDA1/SCL1) használja, mint a kamera, a D74 lábat az LCD háttérvilágítás engedélyezéséhez, a D70/D71 lábakat a GT911 érintés IRQ és reset jelekhez, valamint a D68/D69 lábakat a DSI panel TE és RESET jeleihez.

Mikrofon (Display Shield)

Az Arduino Giga Display Shield egy digitális mikrofont hordoz, amely az STM32H747 DFSDM perifériájához van kötve (mikrofon órajel a D75-ön, mikrofon adat a D73-on). A mikrofon a audio — Audio modul modulon keresztül rögzíthető. Minden puffer előjeles 16 bites PCM bytearray formában érkezik, készen arra, hogy DSP-hez a ulab/numpy modulba kerüljön:

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)

Az Arduino Giga Display Shield egy Bosch BMI270 6 tengelyes IMU-t (3D gyorsulásmérő + 3D giroszkóp) hordoz ugyanazon az I²C 4 buszon, a 0x68 címen. Az olvasásához használd a közösségi micropython_bmi270 illesztőprogramot:

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)

A teljes regiszter-leképezés a BMI270 adatlapban található.

RGB LED (Display Shield)

Az Arduino Giga Display Shield egy beépített RGB LED-et hordoz, amelyet egy ISSI IS31FL3197 3 csatornás LED-illesztő hajt meg ugyanazon az I²C 4 buszon. Az illesztő AD lába GND-re van kötve, így a 0x50 I²C címen helyezkedik el. A LED vezérléséhez használd a közösségi IS31FL3197 illesztőprogramot:

from machine import I2C
from is31fl3197 import IS31FL3197

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

A teljes regiszter-leképezés az IS31FL3197 adatlapban található.

Wi‑Fi

A beépített Murata 1DX (CYW4343W) a network — hálózati konfiguráció modulon keresztül érhető el állomás (station) interfészként. Csatlakoztasd a mellékelt antennát a beépített U.FL csatlakozóhoz, mielőtt elindítanád a rádiót:

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

Ugyanaz a Murata 1DX a Bluetooth LE 5.1-et is elérhetővé teszi. Az asyncio-barát BLE-hez használd az aioble — Aszinkron BLE modult — például hirdesd magad perifériaként, és várj, amíg egy központi (central) csatlakozik:

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

Busz referencia

GPIO

Használd a machine.Pin osztályt a feliratozott lábak bármelyikének olvasásához vagy meghajtásához. A kimenetek 3,3 V CMOS szintűek, és lábanként akár 20 mA-t nyelhetnek el/szolgáltathatnak (a teljes tüskesoron összesen 140 mA-t).

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

Bármely bemeneti láb megszakítást is kiválthat él-átmenetekkor:

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

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

UART

Busz	TX	RX	Arduino név
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

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

A 2-es busz (D20/D21, a feliratozott SCL/SDA) az alapértelmezett Arduino Wire busz. A 4-es busz (SCL1/SDA1) a kamerával és a Giga Display Shield GT911 érintésvezérlőjével van megosztva — az ezen a buszon lévő felhasználói eszközöknek kerülniük kell a következő címeket (7 bites):

• 0x3C — OV5640 / GC2145

• 0x24 — HM01B0 / HM0360

• 0x21 — OV7670

• 0x5D — GT911 érintésvezérlő (Giga Display Shield)

Ugyanaz a hardver cél (slave) módban is használható a machine.I2CTarget segítségével, hogy egy memóriaterületet tegyen elérhetővé egy másik I²C vezérlő számára:

from machine import I2CTarget

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

SPI

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

Az SPI1 egy dedikált 6 lábú tüskesoron van kivezetve a kártya elülső oldalán. Az SPI5 a D11/D12/D13 lábakon lévő feliratozott COPI/CIPO/SCK címkéken van kivezetve.

Megjegyzés

Az elülső 6 lábú SPI1 tüskesor (J7) lábkiosztása:

Láb	Jel
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)

Busz	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

A Giga R1 tizenkét 12 bites ADC csatornát tesz elérhetővé az A0–A11 lábakon, mindegyik 3,3 V referenciájú — a read_u16 0–65535 értéket ad vissza a láb 0–3,3 V tartományában. Az A8–A11 csak analóg _C kontaktusok, GPIO periféria nélkül:

from machine import ADC
import time

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

Megjegyzés

Az A7 a 3,5 mm-es TRRS audio jack mikrofonbemenetéhez is csatlakozik — amikor egy headset van bedugva, az ADC("A7") közvetlenül az analóg mikrofonjelet olvassa.

DAC

Két 12 bites DAC csatorna érhető el a DAC0 és a DAC1 lábakon a pyb.DAC osztályon keresztül. Mindkettő a 3,5 mm-es TRRS audio jackhez van kötve a bal és jobb vonalkimeneti csatornaként:

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

Láb	Időzítő / csatorna
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

Hajtsd meg bármelyiket a machine.PWM segítségével:

from machine import Pin, PWM

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

Figyelem

A TIM1 a kamera fő órajeléhez van fenntartva, amikor a kamera a csi — kameraérzékelők modulon keresztül van inicializálva. Azok a lábak, amelyek egyetlen PWM funkciója a TIM1-en van — D1, D10, D11, D12 — nem hajthatók meg PWM-mel, amíg a kamera aktív. A többi felsorolt láb mindegyikének van TIM1-től eltérő alternatívája.

Megjegyzés

Több láb is megoszt időzítő-csatornákat:

• A TIM2 CH4 a D2 és a D20 lábon van.

• A TIM2 CH1 a D83/A7 és a D85/A13 lábon van.

• A TIM3 CH1 a D7, a D56 és a D68 lábon van.

• A TIM3 CH2 a D5 és a D15 lábon van.

• A TIM4 CH2 a D0 és a D6 lábon van.

• A TIM5 CH1 a D64 és a D83/A7 lábon van.

• A TIM5 CH4 a D2 és a D69 lábon van.

• A TIM8 CH1 a D4, a D54 és a D68 lábon van.

• A TIM8 CH1N a D5, a D16, a D57 és a D85/A13 lábon van.

• A TIM8 CH2 a D11, a D15, a D37 és a D59 lábon van.

• A TIM8 CH2N a D12, a D38, a D61 és a D78/A2 lábon van.

• A TIM8 CH3 a D48 és a D58 lábon van.

• A TIM8 CH3N a D10, a D46 és a D79/A3 lábon van.

• A TIM15 CH1 a D3 és a D51 lábon van.

• A TIM15 CH2 a D2 és a D40 lábon van.

Időzítő-csatornánként egyetlen fogyasztót válassz.

Szoftveresen bitbillegtetett buszok

A machine.SoftI2C és a machine.SoftSPI bármely GPIO-n működik, ha extra buszra van szükséged.

Hőérzékelő (kártyán kívüli)

A firmware tartalmazza a fir — hőérzékelő-meghajtó (fir == far infrared, távoli infravörös) illesztőprogramot a kívülről bekötött hőkamerákhoz:

• MLX90621 — 16 × 4 IR mátrix

• MLX90640 — 32 × 24 IR mátrix

• MLX90641 — 16 × 12 IR mátrix

• AMG8833 — 8 × 8 IR mátrix

Kösd a modult a kártya I²C buszára, és olvasd be a képkockákat a fir.init() + fir.snapshot() segítségével:

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

A fir illesztőprogram csak az I²C 1 buszon kommunikál az érzékelővel — kösd a modult a D8 (SCL) és a D9 (SDA) lábakra.

Időzítés

time

A time modul lefedi a blokkoló késleltetéseket, a monoton ütemeket és az eltelt idő mérését:

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)

Virtuális időzítők

A machine.Timer periodikus vagy egyszeri visszahívásokat ütemez anélkül, hogy egy hardveres időzítő-helyet foglalna el. Add meg a -1 értéket azonosítóként egy virtuális (szoftveres) időzítő használatához:

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

A periódusértékek ezredmásodpercben értendők. Hívd meg a deinit() metódust a leállításhoz és a hely felszabadításához.

Valós idejű óra

A machine.RTC a visszaállítások között — és teljes kikapcsoláson át is, ha gombelem van a VRTC lábhoz csatlakoztatva — megőrzi a valós idejű órát:

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

A machine.WDT visszaállítja a kártyát, ha az alkalmazás lefagy. Az elindítása után nem állítható le és nem konfigurálható újra — etesd rendszeresen a fő ciklusodon belül:

from machine import WDT

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

Indítási és futásidejű információk

Firmware-frissítés (DFU)

A Giga R1 az Arduino szabványos dupla koppintásos reset módszerét használja az Arduino rendszerbetöltőjének elindításához. Nyomd meg gyorsan kétszer a RESET gombot — a kártya újra felsorolja magát az USB-n DFU eszközként, és az OpenMV IDE új firmware-képet tölthet rá. Ha a rendszerbetöltő teljesen hiányzik, tartsd lenyomva a BOOT0 gombot, miközben megnyomod a RESET-et, hogy a SoC-t a ROM rendszerbetöltő módba kényszerítsd.

Egy futó szkript igény szerint újra beléphet a rendszerbetöltőbe a machine.bootloader() meghívásával:

import machine

machine.bootloader()

Fájlrendszer és indítási sorrend

A Giga R1 firmware indításkor legfeljebb két fájlrendszert csatol:

• Belső flash memória — mindig a /flash alá csatolva. Alapértelmezetten a main.py és a README.txt fájlokat tartalmazza; a legelső indításkor jön létre.

• ROMFS — csak olvasható, memóriába leképezett fájlrendszer a /rom alatt, amelyet a MicroPython indításkor automatikusan csatol.

A csatolás után a munkakönyvtár a /flash lesz. Az értelmező ezután ebből a könyvtárból futtatja a szkripteket:

• A boot.py minden szoftveres visszaállításkor lefut (hideg indítás, Ctrl‑D a REPL-ből, vagy valahányszor a futó szkript visszatér).

• A main.py csak hideg indításkor fut le, közvetlenül a boot.py után. A későbbi szoftveres visszaállítások újrafuttatják a boot.py-t, de egyenesen a REPL-be lépnek — a main.py újrafuttatásához teljesen vissza kell állítanod a kártyát.

Egy frissen flashelt kártyán szállított alapértelmezett main.py csak a felhasználói RGB LED kék csatornáját villogtatja szívverésként (két rövid impulzus, rövid szünet), így gazdagép csatlakoztatása nélkül is megállapíthatod, hogy a firmware tisztán elindult.

A sys.path kibővül, hogy mindkét fájlrendszert és azok lib/ alkönyvtárait tartalmazza, így az importálható modulok a /flash/lib vagy a /rom/lib alatt helyezkedhetnek el.

USB-n keresztül csatlakoztatva a /flash USB háttértár-meghajtóként is megjelenik a gazdagépen, lehetővé téve a boot.py, a main.py és bármely más fájl közvetlen szerkesztését. Vesd ki a meghajtót, mielőtt visszaállítanád a kártyát, hogy a gazdagép kiírja a gyorsítótárazott írásait.

Megjegyzés

Mivel az operációs rendszer a meghajtót passzív blokkeszközként kezeli, a kamerán futó kód által létrehozott vagy módosított fájlok addig nem jelennek meg, amíg a gazdagép újra nem csatolja a meghajtót. Ha az operációs rendszer és a kamera egyszerre ír ugyanarra a fájlrendszerre, az operációs rendszer nyer, és felülírja a kamera által végzett módosításokat.

Megjegyzés

A felhasználói RGB LED piros csatornája röviden felvillanhat, miközben a gazdagép az USB háttértár-meghajtóról olvas vagy arra ír — ez egy firmware által vezérelt tevékenységjelző, nem hiba.

Tárolási méretek

A Giga R1 a következőkkel érkezik:

• /flash — 11 MB FAT fájlrendszer, írható/olvasható.

• /rom — 4 MB csak olvasható, memóriába leképezett ROMFS, amelyet olyan szkriptek és ML modellek szállítására használnak, amelyek profitálnak a másolásmentes mmap hozzáférésből.

Hardver-hiba jelző

Ha a felhasználói RGB LED gyorsan végigvált az összes színen — olyan gyorsan, hogy az inkább csillogó fehér LED-nek tűnik, mint különálló árnyalatoknak —, akkor a firmware helyrehozhatatlan hardver-hibába (hard fault) ütközött. A helyreállításhoz flasheld újra a firmware-t; ha az újraflashelés nem segít, a kártya fizikailag sérült lehet.

Szoftverkönyvtárak

A modulok teljes listájáért — beleértve azt is, hogy melyek egyediek a Giga R1 buildhez — lásd a könyvtárindexet.