Arduino Giga R1 WiFi¶

Das Arduino Giga R1 WiFi ist ein 101 × 53 mm großes Board im Mega-Formfaktor, das auf dem STMicroelectronics STM32H747XI aufbaut — einem Dual-Core-SoC, das einen Cortex-M7 mit 480 MHz mit einem Cortex-M4 mit 240 MHz kombiniert. Die OpenMV-Firmware läuft vollständig auf dem M7-Kern. Das Giga ergänzt das Standard-Header-Layout des Arduino Mega um einen 22-poligen Arducam-Kamera-Flachbandstecker, einen MIPI-DSI-Stecker für das Arduino Giga Display Shield sowie eine 3,5-mm-Stereo-Audiobuchse.

Das vollständige Datenblatt sowie Fotos und Abmessungen finden Sie auf der Produktseite des Arduino Giga R1 WiFi.

Highlights¶

STMicroelectronics STM32H747XI mit Dual-Core Cortex-M7 (480 MHz) + Cortex-M4 (240 MHz). Die OpenMV-Firmware läuft ausschließlich auf dem M7-Kern; der M4-Kern wird über openamp für die Interprozessorkommunikation bereitgestellt.
8 MB externes SDRAM sowie 2 MB internes Flash und 16 MB externes QSPI-Flash.
Hardware-JPEG-Encoder/-Decoder.
22-poliger Arducam-kompatibler Kamera-Flachbandstecker (J6) — Treiberunterstützung für die Sensormodule OV5640 (5 MP), OV7670, GC2145, HM01B0 und HM0360.
MIPI-DSI-Displaystecker (J5) für das Arduino Giga Display Shield (480×800 kapazitives Touchpanel) sowie eine LTDC-RGB-Display-Engine für anspruchsvolle Trägerplatinen.
3,5-mm-Audiobuchse mit Stereo-Line-Out und Mikrofoneingang.
Wi-Fi b/g/n (2,4 GHz) + Bluetooth LE 5.1 über das Murata-1DX-Modul (CYW4343W) — mit der mitgelieferten Antenne über einen U.FL-Anschluss auf der Platine verbunden.
USB-C (Full-Speed) für Stromversorgung / seriellen Anschluss / Programmierung.
Benutzer-I/O an den Headern im Mega-Stil — D0–D75 (digital), A0–A11 (analog), DAC0/DAC1 (DAC-Ausgänge), CAN_RX/CAN_TX (FDCAN2) sowie das I²C-Paar SDA1/SCL1 in der inneren Reihe. Ein separater 6-poliger SPI1-Header an der Vorderseite des Boards führt CIPO/COPI/SCK (D89/D90/D91) heraus.
JTAG / SWD für anspruchsvolles Debugging über den Debug-Header auf der Oberseite herausgeführt.

Pinbelegung¶

Pin-Referenz¶

Die Header im Arduino-Mega-Stil stellen 76 digitale Pins (D0–D75), 12 analoge Pins (A0–A11), zwei DAC-Ausgänge (DAC0/DAC1), ein zweites I²C-Paar (SDA1/SCL1) und ein FDCAN2-Paar (CAN_RX/CAN_TX) bereit. Ein separater 6-poliger SPI1-Header an der Vorderseite des Boards führt CIPO/COPI/SCK (D89/D90/D91) heraus.

Pin-Name	Referenz	Funktion
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-Mastertakt — 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 (Display-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 — belegt, wenn die Kamera aktiv ist)
D67	3,3 V	GPIO (Kamera-Power-Down — belegt, wenn die Kamera aktiv ist)
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 Mikrofondaten)
D74	3,3 V	GPIO (Display-Hintergrundbeleuchtung — vom Giga Display Shield belegt)
D75	3,3 V	SPI2 SCK (Display Shield DFSDM Mikrofontakt)
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 (Mikrofoneingang der Audiobuchse)
A8	3,3 V	ADC3 IN0 (nur analog)
A9	3,3 V	ADC3 IN1 (nur analog)
A10	3,3 V	ADC12 IN1 (nur analog)
A11	3,3 V	ADC12 IN0 (nur analog)
DAC0 / A12 / D84	3,3 V	DAC1 OUT1 / ADC12 IN18 (Line-Out L der Audiobuchse)
DAC1 / A13 / D85	3,3 V	DAC1 OUT2 / TIM2 CH1 / SPI1 SCK / ADC12 IN19 (Line-Out R der Audiobuchse)
D89	3,3 V	SPI1 MISO (`CIPO` am vorderen SPI-Header)
D90	3,3 V	SPI1 MOSI (`COPI` am vorderen SPI-Header)
D91	3,3 V	SPI1 SCK (`SCK` am vorderen 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- / Kamera-Steuerbus)
SCL1 / D101	3,3 V	I2C4 SCL (Display-Touch- / Kamera-Steuerbus)
RESET	3,3 V	Drücken Sie die RESET-Taste auf der Platine oder ziehen Sie den Pin auf GND, um zurückzusetzen
LED_RED	3,3 V	Roter Kanal der RGB-LED (Low-aktiv)
LED_GREEN	3,3 V	Grüner Kanal der RGB-LED (Low-aktiv)
LED_BLUE	3,3 V	Blauer Kanal der RGB-LED (Low-aktiv)

Bemerkung

A8–A11 sind rein analoge Pads an den _C-Pins des STM32H747 — sie haben keine GPIO-Funktion und können nur über den ADC ausgelesen werden.

Versorgungspins¶

Pins des Mega-Headers:

VIN — 6–32 V Eingang. Versorgt das Board über den auf der Platine befindlichen Abwärtsregler.
+5V — 5-V-Schiene, gespeist von USB über eine Diode oder den auf der Platine befindlichen Abwärtsregler.
+3V3 — Haupt-3,3-V-Schiene.
IOREF — gibt die I/O-Spannung des Boards wieder (3,3 V).
AREF — analoge Referenzspannung für die ADC-Pins. Standardmäßig 3,3 V; extern ansteuern, um eine andere Referenz zu verwenden.
OFF — auf GND ziehen, um die +3,3-V-Schiene abzuschalten und das System herunterzufahren.
VRTC — 3,0-V-Knopfzelleneingang (max. 3,3 V), der die On-Chip-RTC am Laufen hält, während der Rest des Boards ausgeschaltet ist.
GND — gemeinsame Masse.

Das Giga R1 kann über jeden dieser Pfade mit Strom versorgt werden:

USB-C — liefert 5 V an den auf der Platine befindlichen Abwärtsregler.
VIN-Pin — eine geregelte Versorgung von 6–32 V direkt anlegen.

Tipp

Verwenden Sie den Batterielaufzeit-Schätzer, um zu modellieren, wie lange das Giga R1 bei einem bestimmten Aktiv-/Deep-Sleep-Tastverhältnis mit einer Batterie läuft.

Recovery- und Debug-Pins¶

RESET — sowohl ein herausgeführter Pin am Versorgungs-Header als auch ein Taster auf der Oberseite des Boards, beide mit der NRST-Leitung des SoC verbunden. Auf GND ziehen oder den Taster drücken, um zurückzusetzen.

Falls der Bootloader vollständig fehlt, halten Sie die BOOT0-Taste gedrückt, während Sie RESET drücken, um das SoC in den ROM-Bootloader-Modus zu zwingen.

Die SWD-Signale des STM32 sind am 10-poligen 1,27-mm-Cortex-Debug-Header an der Vorderseite des Boards herausgeführt. Verbinden Sie sie über einen SEGGER J-Link, einen ST-Link oder eine beliebige Standard-ARM-JTAG/SWD-Sonde. Alle Debug-Signale sind auf 3,3 V bezogen.

Integrierte Peripheriegeräte¶

LEDs¶

Das Giga R1 verfügt über eine einzelne Benutzer-RGB-LED, die per Software über machine.LED gesteuert werden kann:

from machine import LED

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

Eine separate Power-LED auf dem Board leuchtet, sobald die +3,3-V-Schiene anliegt, und ist nicht vom Benutzer steuerbar.

Kamerastecker (J6)¶

J6 ist ein 22-poliger Arducam-kompatibler Kamera-Flachbandstecker. Schließen Sie eines der unterstützten Sensormodule an, und die Firmware erkennt es automatisch über das csi — Kamerasensoren-Modul:

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

Unterstützte Sensoren:

OV5640 — 5 MP Farbe, bis zu QSXGA (2592 × 1944).
OV7670 — 0,3 MP Farbe, bis zu VGA (640 × 480).
GC2145 — 2 MP Farbe, bis zu UXGA (1600 × 1200).
HM01B0 — 320 × 320 monochrom.
HM0360 — VGA (640 × 480) monochrom.

Warnung

Während die Kamera initialisiert ist, werden die folgenden Pins des Mega-Headers von der Firmware belegt und können nicht verwendet werden:

Pin	Grund
`D54`–`D65`	DCMI-Daten- + Sync-Signale am Kamera-Flachbandstecker
`D57`	TIM1 CH3 — Kamera-Mastertakt
`D66`	Kamera-Reset-GPIO
`D67`	Kamera-Power-Down-GPIO
`SDA1` / `SCL1`	I²C 4 — wird mit der Kamera geteilt; der Bus ist nutzbar, aber meiden Sie die I²C-Adresse des Sensors

Maschinelles Lernen¶

ml — Maschinelles Lernen führt quantisierte TFLite-Modelle auf dem Cortex-M7 mit CMSIS-NN-Kerneln aus — schnell genug für kompakte Detektoren mit einigen Einzelbildern pro Sekunde. Modelle auf dem schreibgeschützten /rom-Dateisystem werden direkt aus dem Flash geladen, ohne in den RAM kopiert zu werden. Hier ist ein 128×128-BlazeFace-Detektor, der das erkannte Gesicht und seine sechs Landmarken in jedem Einzelbild überlagert:

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-Kern¶

Der Cortex-M4-Kern wird über openamp für die Interprozessorkommunikation bereitgestellt. Die OpenMV-Firmware läuft nur auf dem M7; der M4 verfügt über keine eigene MicroPython-Laufzeitumgebung, sodass seine Nutzung den Bau eines separaten C-Firmware-Images und dessen Laden aus dem Dateisystem über openamp.RemoteProc bedeutet. Vorgefertigte Beispiel-Firmware, die einen virtuellen UART-Endpunkt implementiert, ist im Repository openamp_vuart verfügbar — folgen Sie der README, um vuart.elf zu bauen:

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)

In der Praxis sollte diese Unterstützung eher als Demonstration der openamp-Schnittstelle denn als funktionierende Dual-Core-Plattform betrachtet werden — der M4 kann nicht unabhängig vom M7 zurückgesetzt werden, sodass das Anhalten des M4 einen vollständigen Neustart des Systems erzwingt.

Display (J5)¶

J5 ist ein MIPI-DSI-Stecker für das Arduino Giga Display Shield — ein 480 × 800 kapazitives Touchpanel, aufgebaut um den Panel-Treiber ST7701 und den Touch-Controller GT911. Beide Treiber werden eingefroren mit der Firmware ausgeliefert. Verwenden Sie display — Display-Treiber, um Framebuffer auszugeben, und gt911.GT911 für die Touch-Eingabe.

Das folgende Beispiel spiegelt die Kamera in ein 800 × 480 großes Display-Fenster im Hochformat und überlagert jeden Touch-Kontakt als farbigen Kreis:

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

Warnung

Das Giga Display Shield nutzt denselben I²C 4-Bus (SDA1/SCL1) wie die Kamera, D74 für die Aktivierung der LCD-Hintergrundbeleuchtung, D70/D71 für den GT911-Touch-IRQ und -Reset sowie D68/D69 für die TE- und RESET-Signale des DSI-Panels.

Mikrofon (Display Shield)¶

Das Arduino Giga Display Shield trägt ein digitales Mikrofon, das mit der DFSDM-Peripherie des STM32H747 verdrahtet ist (Mikrofontakt an D75, Mikrofondaten an D73). Das Mikrofon wird über audio — Audio-Modul erfasst. Jeder Puffer kommt als vorzeichenbehaftetes 16-Bit-PCM-bytearray an, bereit zur Einspeisung in ulab/numpy für die DSP-Verarbeitung:

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

Das Arduino Giga Display Shield trägt eine Bosch BMI270 6-Achsen-IMU (3D-Beschleunigungssensor + 3D-Gyroskop) am selben I²C-4-Bus unter der Adresse 0x68. Verwenden Sie den Community-Treiber micropython_bmi270, um sie auszulesen:

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)

Die vollständige Registerübersicht findet sich im BMI270-Datenblatt.

RGB-LED (Display Shield)¶

Das Arduino Giga Display Shield trägt eine integrierte RGB-LED, die von einem ISSI IS31FL3197 3-Kanal-LED-Treiber am selben I²C-4-Bus angesteuert wird. Der AD-Pin des Treibers liegt auf GND, sodass er sich an der I²C-Adresse 0x50 befindet. Verwenden Sie den Community-Treiber IS31FL3197, um die LED zu steuern:

from machine import I2C
from is31fl3197 import IS31FL3197

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

Die vollständige Registerübersicht findet sich im IS31FL3197-Datenblatt.

Wi-Fi¶

Das auf der Platine befindliche Murata 1DX (CYW4343W) wird über network — Netzwerkkonfiguration als Station-Schnittstelle bereitgestellt. Verbinden Sie die mitgelieferte Antenne mit dem U.FL-Anschluss auf der Platine, bevor Sie das Funkmodul in Betrieb nehmen:

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¶

Dasselbe Murata 1DX stellt auch Bluetooth LE 5.1 bereit. Verwenden Sie aioble — Async BLE für asyncio-freundliches BLE — beispielsweise als Peripheriegerät zu werben und auf die Verbindung eines Centrals zu warten:

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

Bus-Referenz¶

GPIO¶

Verwenden Sie machine.Pin, um einen der bedruckten Pins zu lesen oder anzusteuern. Die Ausgänge sind 3,3-V-CMOS und können bis zu 20 mA pro Pin aufnehmen/liefern (140 mA insgesamt über den gesamten Header).

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

Jeder Eingangspin kann auch bei Flankenwechseln einen Interrupt auslösen:

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

Bus 2 (D20/D21, die bedruckten SCL/SDA) ist der standardmäßige Arduino-Wire-Bus. Bus 4 (SCL1/SDA1) wird mit der Kamera und dem GT911-Touch-Controller des Giga Display Shield geteilt — Benutzergeräte an diesem Bus müssen die folgenden Adressen (7-Bit) meiden:

0x3C — OV5640 / GC2145
0x24 — HM01B0 / HM0360
0x21 — OV7670
0x5D — GT911-Touch-Controller (Giga Display Shield)

Dieselbe Hardware kann auch im Target- (Slave-)Modus über machine.I2CTarget verwendet werden, um einem anderen I²C-Controller einen Speicherbereich bereitzustellen:

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 ist an einem dedizierten 6-poligen Header an der Vorderseite des Boards herausgeführt. SPI5 ist an den bedruckten Beschriftungen COPI/CIPO/SCK an D11/D12/D13 herausgeführt.

Bemerkung

Pinbelegung des vorderen 6-poligen SPI1-Headers (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¶

Das Giga R1 stellt zwölf 12-Bit-ADC-Kanäle an A0–A11 bereit, alle auf 3,3 V bezogen — read_u16 liefert 0–65535 über 0–3,3 V am Pin. A8–A11 sind rein analoge _C-Pads ohne GPIO-Peripherie:

from machine import ADC
import time

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

Bemerkung

A7 ist außerdem mit dem Mikrofoneingang der 3,5-mm-TRRS-Audiobuchse verdrahtet — wenn ein Headset eingesteckt ist, liest ADC("A7") das analoge Mikrofonsignal direkt aus.

DAC¶

Zwei 12-Bit-DAC-Kanäle werden an DAC0 und DAC1 über pyb.DAC bereitgestellt. Beide sind als linker und rechter Line-Out-Kanal mit der 3,5-mm-TRRS-Audiobuchse verdrahtet:

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	Timer / Kanal
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

Steuern Sie einen davon über machine.PWM an:

from machine import Pin, PWM

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

Warnung

TIM1 ist für den Kamera-Mastertakt reserviert, wenn die Kamera über csi — Kamerasensoren initialisiert wird. Pins, deren einzige PWM-Funktion auf TIM1 liegt — D1, D10, D11, D12 — können bei aktiver Kamera nicht per PWM angesteuert werden. Alle anderen aufgeführten Pins verfügen über Alternativen, die nicht auf TIM1 liegen.

Bemerkung

Mehrere Pins teilen sich Timer-Kanäle:

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

Wählen Sie einen Verbraucher pro Timer-Kanal.

Software-Bit-Banging-Busse¶

machine.SoftI2C und machine.SoftSPI funktionieren an jedem GPIO, falls Sie einen zusätzlichen Bus benötigen.

Thermosensor (extern)¶

Die Firmware enthält den fir — Wärmesensortreiber (fir == far infrared)-Treiber für extern verdrahtete Wärmebildkameras:

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

Verdrahten Sie das Modul mit dem I²C-Bus des Boards und lesen Sie Einzelbilder mit fir.init() + fir.snapshot() aus:

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

Der fir-Treiber kommuniziert mit dem Sensor ausschließlich über I²C 1 — verdrahten Sie das Modul mit D8 (SCL) und D9 (SDA).

Timing¶

time¶

Das time-Modul deckt blockierende Verzögerungen, monotone Ticks und die Messung der verstrichenen Zeit ab:

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)

Virtuelle Timer¶

machine.Timer plant periodische oder einmalige Callbacks, ohne einen Hardware-Timer-Slot zu belegen. Übergeben Sie -1 als ID, um einen virtuellen (Software-)Timer zu verwenden:

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

Periodenwerte sind in Millisekunden angegeben. Rufen Sie deinit() auf, um den Timer zu stoppen und den Slot freizugeben.

Echtzeituhr¶

machine.RTC hält die Echtzeit über Resets hinweg — und über das vollständige Abschalten hinaus, wenn eine Knopfzelle mit dem VRTC-Pin verbunden ist:

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 setzt das Board zurück, wenn die Anwendung hängen bleibt. Einmal gestartet, kann er nicht mehr gestoppt oder neu konfiguriert werden — speisen Sie ihn regelmäßig in Ihrer Hauptschleife:

from machine import WDT

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

Boot- und Laufzeitinformationen¶

Firmware-Update (DFU)¶

Das Giga R1 verwendet Arduinos standardmäßigen Double-Tap-Reset, um in den Bootloader von Arduino zu gelangen. Drücken Sie die RESET-Taste zweimal schnell hintereinander — das Board meldet sich über USB als DFU-Gerät neu an, und OpenMV IDE kann ein neues Firmware-Image flashen. Falls der Bootloader vollständig fehlt, halten Sie die BOOT0-Taste gedrückt, während Sie RESET drücken, um das SoC in den ROM-Bootloader-Modus zu zwingen.

Ein laufendes Skript kann bei Bedarf in den Bootloader zurückkehren, indem es machine.bootloader() aufruft:

import machine

machine.bootloader()

Dateisystem und Boot-Reihenfolge¶

Die Firmware des Giga R1 bindet beim Booten bis zu zwei Dateisysteme ein:

Internes Flash — stets unter /flash eingebunden. Enthält standardmäßig main.py und README.txt; wird beim allerersten Booten erstellt.
ROMFS — schreibgeschütztes, speicherabgebildetes Dateisystem unter /rom, das von MicroPython beim Start automatisch eingebunden wird.

Nach dem Einbinden wird das Arbeitsverzeichnis auf /flash gesetzt. Der Interpreter führt dann Skripte aus diesem Verzeichnis aus:

boot.py wird bei jedem Soft-Reset ausgeführt (Kaltstart, Ctrl‑D aus der REPL oder immer dann, wenn das laufende Skript zurückkehrt).
main.py wird nur beim Kaltstart ausgeführt, unmittelbar nach boot.py. Nachfolgende Soft-Resets führen boot.py erneut aus, gelangen dann aber direkt zur REPL — um main.py erneut auszuführen, müssen Sie das Board vollständig zurücksetzen.

Das standardmäßige main.py, das auf einem frisch geflashten Board ausgeliefert wird, lässt lediglich den blauen Kanal der Benutzer-RGB-LED als Heartbeat blinken (zwei kurze Pulse, kurze Pause), sodass Sie ohne angeschlossenen Host erkennen können, dass die Firmware sauber gebootet ist.

sys.path wird so erweitert, dass es beide Dateisysteme und deren lib/-Unterverzeichnisse umfasst, sodass importierbare Module in /flash/lib oder /rom/lib liegen können.

Bei einer USB-Verbindung wird /flash auf dem Host außerdem als USB-Massenspeicherlaufwerk angemeldet, sodass Sie boot.py, main.py und beliebige andere Dateien direkt bearbeiten können. Werfen Sie das Laufwerk aus, bevor Sie das Board zurücksetzen, damit der Host seine zwischengespeicherten Schreibvorgänge schreibt.

Bemerkung

Da das Betriebssystem das Laufwerk als passives Blockgerät behandelt, erscheinen Dateien, die von auf der Kamera laufendem Code erstellt oder geändert wurden, erst, nachdem der Host das Laufwerk neu eingebunden hat. Wenn sowohl das Betriebssystem als auch die Kamera dasselbe Dateisystem gleichzeitig beschreiben, gewinnt das Betriebssystem und überschreibt von der Kamera vorgenommene Änderungen.

Bemerkung

Der rote Kanal der Benutzer-RGB-LED kann kurz aufleuchten, während der Host vom USB-Massenspeicherlaufwerk liest oder darauf schreibt — dies ist eine firmwaregesteuerte Aktivitätsanzeige, kein Fehler.

Speichergrößen¶

Das Giga R1 wird ausgeliefert mit:

/flash — 11 MB FAT-Dateisystem, Lese-/Schreibzugriff.
/rom — 4 MB schreibgeschütztes, speicherabgebildetes ROMFS, das zum Ausliefern von Skripten und ML-Modellen dient, die vom Zero-Copy-mmap-Zugriff profitieren.

Hard-Fault-Anzeige¶

Wenn die Benutzer-RGB-LED schnell durch alle Farben wechselt — so schnell, dass sie eher wie eine funkelnde weiße LED als wie einzelne Farbtöne aussieht — ist die Firmware auf einen nicht behebbaren Hard Fault gestoßen. Flashen Sie die Firmware neu, um das Problem zu beheben; wenn das erneute Flashen nicht hilft, ist das Board möglicherweise physisch beschädigt.

Software-Bibliotheken¶

Im Bibliotheksindex finden Sie die vollständige Liste der Module — einschließlich derer, die ausschließlich im Giga-R1-Build enthalten sind.