Arduino Giga R1 WiFi¶

De Arduino Giga R1 WiFi is een 101 × 53 mm board met Mega-vormfactor, gebouwd rond de STMicroelectronics STM32H747XI — een dual-core SoC die een Cortex-M7 op 480 MHz combineert met een Cortex-M4 op 240 MHz. De OpenMV-firmware draait volledig op de M7-core. De Giga voegt aan de standaard Arduino Mega-headerindeling een 22-pins Arducam-cameraflexconnector toe, een MIPI-DSI-connector voor het Arduino Giga Display Shield en een 3,5 mm stereo audio-aansluiting.

Voor de volledige datasheet, foto’s en afmetingen, zie de productpagina van de Arduino Giga R1 WiFi.

Hoogtepunten¶

STMicroelectronics STM32H747XI dual Cortex-M7 (480 MHz) + Cortex-M4 (240 MHz). De OpenMV-firmware draait alleen op de M7-core; de M4-core wordt via openamp beschikbaar gesteld voor communicatie tussen processoren.
8 MB extern SDRAM plus 2 MB intern flashgeheugen en 16 MB extern QSPI-flashgeheugen.
Hardware JPEG-encoder/-decoder.
22-pins Arducam-compatibele cameraflexconnector (J6) — driverondersteuning voor de sensormodules OV5640 (5MP), OV7670, GC2145, HM01B0 en HM0360.
MIPI-DSI-displayconnector (J5) voor het Arduino Giga Display Shield (480×800 capacitief aanraakscherm) plus een LTDC RGB-displayengine voor geavanceerde carriers.
3,5 mm audio-aansluiting met stereo line-out en microfooningang.
Wi-Fi b/g/n (2,4 GHz) + Bluetooth LE 5.1 via de Murata 1DX (CYW4343W)-module — sluit aan op de meegeleverde antenne via een on-board U.FL-connector.
USB-C (full-speed) voor voeding / serieel / programmeren.
Gebruikers-I/O op de Mega-headers — D0–D75 (digitaal), A0–A11 (analoog), DAC0/DAC1 (DAC-uitgangen), CAN_RX/CAN_TX (FDCAN2) en het SDA1/SCL1 I²C-paar op de binnenrij. Een aparte 6-pins SPI1-header aan de voorkant van het board brengt CIPO/COPI/SCK (D89/D90/D91) naar buiten.
JTAG / SWD naar buiten gebracht op de debug-header aan de bovenkant voor geavanceerd debuggen.

Pinout¶

Pinreferentie¶

De Arduino Mega-stijl headers brengen 76 digitale pinnen (D0–D75), 12 analoge pinnen (A0–A11), twee DAC-uitgangen (DAC0/DAC1), een secundair I²C-paar (SDA1/SCL1) en een FDCAN2-paar (CAN_RX/CAN_TX) naar buiten. Een aparte 6-pins SPI1-header aan de voorkant van het board brengt CIPO/COPI/SCK (D89/D90/D91) naar buiten.

Pinnaam	Referentie	Functie
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 (cameramasterklok — 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 (camerareset — geclaimd wanneer de camera actief is)
D67	3.3 V	GPIO (camera power-down — geclaimd wanneer de camera actief is)
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-microfoondata)
D74	3.3 V	GPIO (displayverlichting — geclaimd door het Giga Display Shield)
D75	3.3 V	SPI2 SCK (Display Shield DFSDM-microfoonklok)
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 (microfooningang audio-aansluiting)
A8	3.3 V	ADC3 IN0 (alleen analoog)
A9	3.3 V	ADC3 IN1 (alleen analoog)
A10	3.3 V	ADC12 IN1 (alleen analoog)
A11	3.3 V	ADC12 IN0 (alleen analoog)
DAC0 / A12 / D84	3.3 V	DAC1 OUT1 / ADC12 IN18 (line-out L audio-aansluiting)
DAC1 / A13 / D85	3.3 V	DAC1 OUT2 / TIM2 CH1 / SPI1 SCK / ADC12 IN19 (line-out R audio-aansluiting)
D89	3.3 V	SPI1 MISO (`CIPO` op de SPI-header aan de voorkant)
D90	3.3 V	SPI1 MOSI (`COPI` op de SPI-header aan de voorkant)
D91	3.3 V	SPI1 SCK (`SCK` op de SPI-header aan de voorkant)
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- / camerabesturingsbus)
SCL1 / D101	3.3 V	I2C4 SCL (display-touch- / camerabesturingsbus)
RESET	3.3 V	druk op de on-board RESET-knop of trek naar GND om te resetten
LED_RED	3.3 V	rood kanaal van de RGB-LED (active low)
LED_GREEN	3.3 V	groen kanaal van de RGB-LED (active low)
LED_BLUE	3.3 V	blauw kanaal van de RGB-LED (active low)

Notitie

A8–A11 zijn alleen analoge pads op de _C-pinnen van de STM32H747 — ze hebben geen GPIO-functie en kunnen alleen via de ADC worden uitgelezen.

Voedingspinnen¶

Mega-headerpinnen:

VIN — 6–32 V ingang. Voedt het board via de on-board buck-regelaar.
+5V — 5 V-rail, gevoed vanaf USB via een diode of de on-board buck-regelaar.
+3V3 — hoofd-3,3 V-rail.
IOREF — geeft de I/O-spanning van het board weer (3,3 V).
AREF — analoge spanningsreferentie voor de ADC-pinnen. Standaard 3,3 V; stuur extern aan om een andere referentie te gebruiken.
OFF — trek naar GND om de +3,3 V-rail uit te schakelen en het systeem af te sluiten.
VRTC — 3,0 V knoopcelingang (max. 3,3 V) die de on-chip RTC laat doorlopen terwijl de rest van het board uitgeschakeld is.
GND — gemeenschappelijke massa.

De Giga R1 kan via elk van deze paden gevoed worden:

USB-C — levert 5 V aan de on-board buck-regelaar.
VIN-pin — stuur direct een geregelde voeding van 6–32 V aan.

Tip

Gebruik de accuduurschatter om te modelleren hoe lang de Giga R1 op een accu draait bij een gegeven actief / deep-sleep duty cycle.

Herstel- en debugpinnen¶

RESET — zowel een naar buiten gebrachte pin op de voedingsheader als een drukschakelaar bovenop het board, verbonden met de NRST-lijn van de SoC. Trek naar GND of druk op de knop om te resetten.

Als de bootloader volledig ontbreekt, houd de BOOT0-knop ingedrukt terwijl je op RESET drukt om de SoC in de ROM-bootloadermodus te dwingen.

De SWD-signalen van de STM32 zijn naar buiten gebracht op de 10-pins 1,27 mm Cortex Debug-header aan de voorkant van het board. Verbind ze via een SEGGER J-Link, ST-Link of een willekeurige standaard ARM JTAG/SWD-probe. Alle debugsignalen zijn 3,3 V-gerefereerd.

On-board randapparaten¶

LEDs¶

De Giga R1 heeft één RGB-LED voor de gebruiker, softwarematig bestuurbaar via machine.LED

from machine import LED

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

Een aparte power-LED op het board brandt zodra de +3,3 V-rail actief is en is niet door de gebruiker te besturen.

Cameraconnector (J6)¶

J6 is een 22-pins Arducam-compatibele cameraflexconnector. Sluit een van de ondersteunde sensormodules aan en de firmware detecteert deze automatisch via de csi — camerasensoren-module:

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

Ondersteunde sensors:

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

Waarschuwing

Terwijl de camera geïnitialiseerd is, worden de volgende Mega-headerpinnen door de firmware geclaimd en kunnen ze niet gebruikt worden:

Pin	Reden
`D54`–`D65`	DCMI-data- + sync-signalen op de cameraflexconnector
`D57`	TIM1 CH3 — cameramasterklok
`D66`	Camera-reset-GPIO
`D67`	Camera-power-down-GPIO
`SDA1` / `SCL1`	I²C 4 — gedeeld met de camera; de bus is bruikbaar maar vermijd het I²C-adres van de sensor

Machine learning¶

ml — Machine Learning draait gekwantiseerde TFLite-modellen op de Cortex-M7 met CMSIS-NN-kernels — snel genoeg voor compacte detectors op een paar frames per seconde. Modellen op het alleen-lezen /rom-bestandssysteem laden rechtstreeks vanuit flashgeheugen zonder naar RAM te kopiëren. Hier is een 128×128 BlazeFace-detector die het gedetecteerde gezicht en de zes landmarks erop in elk frame overlayt:

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

De Cortex-M4-core wordt via openamp beschikbaar gesteld voor communicatie tussen processoren. De OpenMV-firmware draait alleen op de M7; de M4 heeft geen eigen MicroPython-runtime, dus om hem te gebruiken moet je een apart C-firmware-image bouwen en het vanuit het bestandssysteem laden via openamp.RemoteProc. Voorgebouwde voorbeeldfirmware die een virtueel UART-eindpunt implementeert is beschikbaar in de openamp_vuart-repository — volg de README om vuart.elf te bouwen:

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 de praktijk kun je deze ondersteuning het beste beschouwen als een demonstratie van de openamp-interface en niet als een werkend dual-core platform — de M4 kan niet onafhankelijk van de M7 worden gereset, dus het stoppen van de M4 forceert een volledige systeemherstart.

Display (J5)¶

J5 is een MIPI-DSI-connector voor het Arduino Giga Display Shield — een 480 × 800 capacitief aanraakscherm gebouwd rond de ST7701-paneeldriver en de GT911-touchcontroller. Beide drivers worden ingevroren met de firmware meegeleverd. Gebruik display — display-stuurprogramma om framebuffers te pushen en gt911.GT911 voor aanraakinvoer.

Het onderstaande voorbeeld spiegelt de camera naar een 800 × 480 displayvenster in staande oriëntatie en overlayt elk aanraakcontact als een gekleurde cirkel:

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

Waarschuwing

Het Giga Display Shield gebruikt dezelfde I²C 4-bus (SDA1/SCL1) als de camera, D74 voor het inschakelen van de LCD-achtergrondverlichting, D70/D71 voor de GT911-touch-IRQ en -reset, en D68/D69 voor de TE- en RESET-signalen van het DSI-paneel.

Microfoon (Display Shield)¶

Het Arduino Giga Display Shield bevat een digitale microfoon die aangesloten is op het DFSDM-randapparaat van de STM32H747 (microfoonklok op D75, microfoondata op D73). De microfoon wordt vastgelegd via audio — Audio Module. Elke buffer komt binnen als signed-16-bit PCM bytearray, klaar om aan ulab/numpy te voeden voor 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)¶

Het Arduino Giga Display Shield bevat een Bosch BMI270 6-assige IMU (3D-accelerometer + 3D-gyroscoop) op dezelfde I²C 4-bus op adres 0x68. Gebruik de community-driver micropython_bmi270 om hem uit te lezen:

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)

De volledige registermap staat in de BMI270-datasheet.

RGB-LED (Display Shield)¶

Het Arduino Giga Display Shield bevat een on-board RGB-LED aangestuurd door een ISSI IS31FL3197 3-kanaals LED-driver op dezelfde I²C 4-bus. De AD-pin van de driver is verbonden met GND, dus hij bevindt zich op I²C-adres 0x50. Gebruik de community-driver IS31FL3197 om de LED te besturen:

from machine import I2C
from is31fl3197 import IS31FL3197

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

De volledige registermap staat in de IS31FL3197-datasheet.

Wi-Fi¶

De on-board Murata 1DX (CYW4343W) wordt via network — netwerkconfiguratie beschikbaar gesteld als station-interface. Sluit de meegeleverde antenne aan op de on-board U.FL-connector voordat je de radio inschakelt:

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¶

Dezelfde Murata 1DX stelt ook Bluetooth LE 5.1 beschikbaar. Gebruik aioble — Async BLE voor asyncio-vriendelijke BLE — adverteer bijvoorbeeld als peripheral en wacht tot een central verbinding maakt:

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

Busreferentie¶

GPIO¶

Gebruik machine.Pin om een van de op de silkscreen aangegeven pinnen uit te lezen of aan te sturen. Uitgangen zijn 3,3 V CMOS en kunnen tot 20 mA per pin afvoeren/leveren (140 mA totaal over de hele 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())

Elke ingangspin kan ook een interrupt afvuren bij flankovergangen:

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-naam
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, de op de silkscreen aangegeven SCL/SDA) is de standaard Arduino Wire-bus. Bus 4 (SCL1/SDA1) is gedeeld met de camera en de GT911-touchcontroller van het Giga Display Shield — gebruikersapparaten op deze bus moeten de volgende adressen (7-bits) vermijden:

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

Dezelfde hardware kan via machine.I2CTarget ook in target-modus (slave) gebruikt worden om een geheugengebied beschikbaar te stellen aan een andere I²C-controller:

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 is naar buiten gebracht op een speciale 6-pins header aan de voorkant van het board. SPI5 is naar buiten gebracht op de op de silkscreen aangegeven labels COPI/CIPO/SCK op D11/D12/D13.

Notitie

Pinout van de 6-pins SPI1-header aan de voorkant (J7):

Pin	Signaal
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¶

De Giga R1 stelt twaalf 12-bits ADC-kanalen beschikbaar op A0–A11, allemaal 3,3 V-gerefereerd — read_u16 retourneert 0–65535 over 0–3,3 V op de pin. A8–A11 zijn alleen-analoge _C-pads zonder GPIO-randapparaat:

from machine import ADC
import time

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

Notitie

A7 is ook verbonden met de microfooningang op de 3,5 mm TRRS audio-aansluiting — wanneer een headset is aangesloten, leest ADC("A7") het analoge microfoonsignaal rechtstreeks uit.

DAC¶

Twee 12-bits DAC-kanalen zijn beschikbaar op DAC0 en DAC1 via pyb.DAC. Beide zijn verbonden met de 3,5 mm TRRS audio-aansluiting als de linker- en rechter-line-out-kanalen:

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 / kanaal
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

Stuur een van deze aan via machine.PWM

from machine import Pin, PWM

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

Waarschuwing

TIM1 is gereserveerd voor de cameramasterklok wanneer de camera geïnitialiseerd wordt via csi — camerasensoren. Pinnen waarvan de enige PWM-functie op TIM1 ligt — D1, D10, D11, D12 — kunnen niet PWM-aangestuurd worden terwijl de camera actief is. De overige genoemde pinnen hebben allemaal alternatieven buiten TIM1.

Notitie

Meerdere pinnen delen timerkanalen:

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

Kies één verbruiker per timerkanaal.

Softwarematig bit-banged bussen¶

machine.SoftI2C en machine.SoftSPI werken op elke GPIO als je een extra bus nodig hebt.

Thermische sensor (extern)¶

De firmware bevat de fir — thermische sensor-driver (fir == far infrared)-driver voor extern bedrade thermische imagers:

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

Sluit de module aan op de I²C-bus van het board en lees frames met 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())

De fir-driver communiceert met de sensor uitsluitend over I²C 1 — sluit de module aan op D8 (SCL) en D9 (SDA).

Timing¶

time¶

De time-module behandelt blokkerende vertragingen, monotone ticks en het meten van verstreken tijd:

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)

Virtuele timers¶

machine.Timer plant periodieke of eenmalige callbacks zonder een hardwaretimer-slot te verbruiken. Geef -1 als id door om een virtuele (software-)timer te gebruiken:

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

Periodewaarden zijn in milliseconden. Roep deinit() aan om te stoppen en het slot vrij te geven.

Real-timeklok¶

machine.RTC houdt de kloktijd bij over resets heen — en over een volledige uitschakeling heen wanneer er een knoopcel op de VRTC-pin is aangesloten:

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 reset het board als de applicatie vastloopt. Eenmaal gestart kan hij niet meer gestopt of opnieuw geconfigureerd worden — voed hem periodiek binnen je hoofdloop:

from machine import WDT

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

Boot- en runtime-informatie¶

Firmware-update (DFU)¶

De Giga R1 gebruikt de standaard double-tap reset van Arduino om de bootloader van Arduino te activeren. Druk snel tweemaal op de RESET-knop — het board meldt zich opnieuw aan over USB als DFU-apparaat en OpenMV IDE kan een nieuw firmware-image flashen. Als de bootloader volledig ontbreekt, houd de BOOT0-knop ingedrukt terwijl je op RESET drukt om de SoC in de ROM-bootloadermodus te dwingen.

Een draaiend script kan op verzoek de bootloader opnieuw activeren door machine.bootloader() aan te roepen:

import machine

machine.bootloader()

Bestandssysteem en bootvolgorde¶

De Giga R1-firmware koppelt bij het opstarten maximaal twee bestandssystemen:

Intern flashgeheugen — altijd gekoppeld op /flash. Bevat standaard main.py en README.txt; aangemaakt bij de allereerste boot.
ROMFS — alleen-lezen, memory-mapped bestandssysteem op /rom dat door MicroPython automatisch bij het opstarten gekoppeld wordt.

Na het koppelen wordt de werkmap ingesteld op /flash. De interpreter draait vervolgens scripts vanuit die map:

boot.py wordt uitgevoerd bij elke soft reset (koude boot, Ctrl‑D vanuit de REPL, of telkens wanneer het draaiende script terugkeert).
main.py wordt alleen bij een koude boot uitgevoerd, direct na boot.py. Volgende soft resets draaien boot.py opnieuw maar vallen direct terug naar de REPL — om main.py opnieuw te draaien moet je het board volledig resetten.

De standaard main.py die op een vers geflasht board wordt meegeleverd laat alleen het blauwe kanaal van de RGB-LED van de gebruiker knipperen als heartbeat (twee korte pulsen, korte pauze), zodat je kunt zien dat de firmware schoon is opgestart zonder dat er een host aangesloten is.

sys.path wordt uitgebreid met beide bestandssystemen en hun lib/-submappen, zodat importeerbare modules in /flash/lib of /rom/lib kunnen staan.

Wanneer aangesloten via USB, wordt /flash op de host ook als USB-massaopslagstation weergegeven, zodat je boot.py, main.py en alle andere bestanden rechtstreeks kunt bewerken. Werp het station uit voordat je het board reset zodat de host zijn gecachete schrijfacties wegschrijft.

Notitie

Omdat het OS het station als een passief blokapparaat behandelt, verschijnen bestanden die door code op de camera worden aangemaakt of gewijzigd pas wanneer de host het station opnieuw koppelt. Als zowel het OS als de camera tegelijk naar hetzelfde bestandssysteem schrijven, wint het OS en overschrijft het wijzigingen die door de camera zijn gemaakt.

Notitie

Het rode kanaal van de RGB-LED van de gebruiker kan kort oplichten terwijl de host van het USB-massaopslagstation leest of ernaar schrijft — dit is een firmware-aangestuurde activiteitsindicator, geen storing.

Opslaggroottes¶

De Giga R1 wordt geleverd met:

/flash — 11 MB FAT-bestandssysteem, lezen/schrijven.
/rom — 4 MB alleen-lezen memory-mapped ROMFS, gebruikt om scripts en ML-modellen mee te leveren die baat hebben bij zero-copy mmap-toegang.

Hard-fault-indicator¶

Als de RGB-LED van de gebruiker snel door alle kleuren cyclet — snel genoeg dat het meestal lijkt op een flikkerende witte LED in plaats van afzonderlijke tinten — is de firmware op een onherstelbare hard fault gestoten. Flash de firmware opnieuw om te herstellen; als opnieuw flashen niet helpt, is het board mogelijk fysiek beschadigd.

Softwarebibliotheken¶

Zie de bibliotheekindex voor de volledige lijst met modules — inclusief welke uniek zijn voor de Giga R1-build.