Arduino Giga R1 WiFi

L’Arduino Giga R1 WiFi est une carte de 101 × 53 mm au format Mega construite autour du STMicroelectronics STM32H747XI — un SoC double cœur combinant un Cortex‑M7 à 480 MHz avec un Cortex‑M4 à 240 MHz. Le micrologiciel OpenMV s’exécute entièrement sur le cœur M7. La Giga ajoute un connecteur de nappe caméra Arducam 22 broches, un connecteur MIPI‑DSI pour le Arduino Giga Display Shield et une prise audio stéréo 3,5 mm à la disposition standard des connecteurs Arduino Mega.

Arduino Giga R1 WiFi

Pour la fiche technique complète, les photos et les dimensions, consultez la page produit de l’Arduino Giga R1 WiFi.

Points forts

  • STMicroelectronics STM32H747XI double Cortex‑M7 (480 MHz) + Cortex‑M4 (240 MHz). Le micrologiciel OpenMV s’exécute uniquement sur le cœur M7 ; le cœur M4 est exposé via openamp pour la communication inter‑processeurs.

  • 8 Mo de SDRAM externe plus 2 Mo de mémoire flash interne et 16 Mo de mémoire flash QSPI externe.

  • Encodeur/décodeur JPEG matériel.

  • Connecteur de nappe caméra 22 broches compatible Arducam (J6) — prise en charge des pilotes pour les modules de capteur OV5640 (5 Mpx), OV7670, GC2145, HM01B0 et HM0360.

  • Connecteur d’affichage MIPI‑DSI (J5) pour le Arduino Giga Display Shield (dalle tactile capacitive 480×800) plus un moteur d’affichage LTDC RGB pour les cartes porteuses avancées.

  • Prise audio 3,5 mm avec sortie ligne stéréo et entrée micro.

  • Wi‑Fi b/g/n (2,4 GHz) + Bluetooth LE 5.1 via le module Murata 1DX (CYW4343W) — se connecte à l’antenne fournie via un connecteur U.FL intégré.

  • USB‑C (full‑speed) pour l’alimentation / le port série / la programmation.

  • E/S utilisateur sur les connecteurs de type Mega — D0–D75 (numériques), A0–A11 (analogiques), DAC0/DAC1 (sorties DAC), CAN_RX/CAN_TX (FDCAN2) et la paire I²C SDA1/SCL1 de la rangée interne. Un connecteur SPI1 6 broches séparé à l’avant de la carte expose CIPO/COPI/SCK (D89/D90/D91).

  • JTAG / SWD exposé sur le connecteur de débogage du dessus pour le débogage avancé.

Brochage

Brochage de l'Arduino Giga R1 WiFi

Référence des broches

Les connecteurs de type Arduino Mega exposent 76 broches numériques (D0–D75), 12 broches analogiques (A0–A11), deux sorties DAC (DAC0/DAC1), une paire I²C secondaire (SDA1/SCL1) et une paire FDCAN2 (CAN_RX/CAN_TX). Un connecteur SPI1 6 broches séparé à l’avant de la carte expose CIPO/COPI/SCK (D89/D90/D91).

Nom de la broche

Référence

Fonction

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 (caméra DCMI VSYNC)

D55

3,3 V

I2C3 SDA (caméra DCMI HSYNC)

D56

3,3 V

TIM3 CH1 / TIM13 CH1 (caméra DCMI PXCLK)

D57

3,3 V

TIM8 CH1N / UART8 RX (horloge maître de la caméra — TIM1 CH3)

D58

3,3 V

TIM8 CH3 (caméra DCMI D7)

D59

3,3 V

TIM8 CH2 (caméra DCMI D6)

D60

3,3 V

GPIO (caméra DCMI D5)

D61

3,3 V

TIM8 CH2N / UART4 RX (caméra DCMI D4)

D62

3,3 V

SPI1 SCK (caméra DCMI D3)

D63

3,3 V

TIM5 CH2 / I2C4 SCL (I²C de l’affichage)

D64

3,3 V

TIM5 CH1 (caméra DCMI D1)

D65

3,3 V

TIM12 CH2 (caméra DCMI D0)

D66

3,3 V

GPIO (réinitialisation caméra — réservé lorsque la caméra est active)

D67

3,3 V

GPIO (mise hors tension caméra — réservé lorsque la caméra est active)

D68

3,3 V

TIM3 CH1 / TIM8 CH1 / USART6 TX (Display Shield DSI RESET)

D69

3,3 V

TIM5 CH4 (Display Shield DSI TE)

D70

3,3 V

SPI2 SCK

D71

3,3 V

TIM8 CH4 / SPI2 MISO

D72

3,3 V

SPI2 MOSI

D73

3,3 V

ADC123 IN11 (données du micro DFSDM du Display Shield)

D74

3,3 V

GPIO (rétroéclairage de l’affichage — réservé par le Giga Display Shield)

D75

3,3 V

SPI2 SCK (horloge du micro DFSDM du 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 (entrée micro de la prise audio)

A8

3,3 V

ADC3 IN0 (analogique uniquement)

A9

3,3 V

ADC3 IN1 (analogique uniquement)

A10

3,3 V

ADC12 IN1 (analogique uniquement)

A11

3,3 V

ADC12 IN0 (analogique uniquement)

DAC0 / A12 / D84

3,3 V

DAC1 OUT1 / ADC12 IN18 (sortie ligne G de la prise audio)

DAC1 / A13 / D85

3,3 V

DAC1 OUT2 / TIM2 CH1 / SPI1 SCK / ADC12 IN19 (sortie ligne D de la prise audio)

D89

3,3 V

SPI1 MISO (CIPO sur le connecteur SPI avant)

D90

3,3 V

SPI1 MOSI (COPI sur le connecteur SPI avant)

D91

3,3 V

SPI1 SCK (SCK sur le connecteur SPI avant)

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 (bus tactile de l’affichage / commande de la caméra)

SCL1 / D101

3,3 V

I2C4 SCL (bus tactile de l’affichage / commande de la caméra)

RESET

3,3 V

appuyez sur le bouton RESET intégré ou tirez à la masse (GND) pour réinitialiser

LED_RED

3,3 V

canal rouge de la LED RVB (actif à l’état bas)

LED_GREEN

3,3 V

canal vert de la LED RVB (actif à l’état bas)

LED_BLUE

3,3 V

canal bleu de la LED RVB (actif à l’état bas)

Note

A8–A11 sont des pastilles analogiques uniquement sur les broches _C du STM32H747 — elles n’ont aucune fonction GPIO et ne peuvent être lues qu’à travers l’ADC.

Broches d’alimentation

Broches du connecteur Mega :

  • VIN — entrée 6–32 V. Alimente la carte via le régulateur abaisseur intégré.

  • +5V — rail 5 V alimenté depuis l’USB via une diode ou le régulateur abaisseur intégré.

  • +3V3 — rail principal 3,3 V.

  • IOREF — reflète la tension d’E/S de la carte (3,3 V).

  • AREF — référence de tension analogique pour les broches ADC. Vaut 3,3 V par défaut ; appliquez une tension externe pour utiliser une référence différente.

  • OFF — tirez à la masse (GND) pour couper le rail +3,3 V et arrêter le système.

  • VRTC — entrée pour pile bouton 3,0 V (3,3 V max) qui maintient le RTC intégré en fonctionnement pendant que le reste de la carte est hors tension.

  • GND — masse commune.

La Giga R1 peut être alimentée par l’une de ces voies :

  • USB‑C — fournit 5 V au régulateur abaisseur intégré.

  • Broche VIN — appliquez directement une alimentation régulée de 6–32 V.

Astuce

Utilisez l”estimateur d’autonomie de batterie pour estimer combien de temps la Giga R1 fonctionnera sur batterie pour un cycle d’activité actif / veille profonde donné.

Broches de récupération et de débogage

  • RESET — à la fois une broche exposée sur le connecteur d’alimentation et un bouton momentané sur le dessus de la carte, reliés à la ligne NRST du SoC. Tirez à la masse (GND) ou appuyez sur le bouton pour réinitialiser.

La Giga R1 utilise le double appui de réinitialisation standard d’Arduino pour entrer dans le programme d’amorçage d’Arduino. Appuyez rapidement deux fois sur le bouton RESET — la carte se ré‑énumère via USB en tant que périphérique DFU et OpenMV IDE peut flasher une nouvelle image de micrologiciel.

Si le programme d’amorçage est entièrement absent, maintenez le bouton BOOT0 tout en appuyant sur RESET pour forcer le SoC en mode programme d’amorçage ROM.

Les signaux SWD du STM32 sont exposés sur le connecteur de débogage Cortex 10 broches au pas de 1,27 mm à l’avant de la carte. Câblez‑les via un SEGGER J‑Link, un ST‑Link ou n’importe quelle sonde ARM JTAG/SWD standard. Tous les signaux de débogage sont référencés à 3,3 V.

Périphériques intégrés

LEDs

La Giga R1 dispose d’une unique LED RVB utilisateur, contrôlable par logiciel via machine.LED:

from machine import LED

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

Une LED d’alimentation distincte sur la carte s’allume dès que le rail +3,3 V est actif et n’est pas contrôlable par l’utilisateur.

Connecteur caméra (J6)

J6 est un connecteur de nappe caméra 22 broches compatible Arducam. Branchez l’un des modules de capteur pris en charge et le micrologiciel les détecte automatiquement via le module csi — capteurs de caméra:

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

Capteurs pris en charge :

  • OV5640 — 5 Mpx couleur, jusqu’à QSXGA (2592 × 1944).

  • OV7670 — 0,3 Mpx couleur, jusqu’à VGA (640 × 480).

  • GC2145 — 2 Mpx couleur, jusqu’à UXGA (1600 × 1200).

  • HM01B0 — 320 × 320 monochrome.

  • HM0360 — VGA (640 × 480) monochrome.

Avertissement

Lorsque la caméra est initialisée, les broches suivantes du connecteur Mega sont réservées par le micrologiciel et ne peuvent pas être utilisées :

Broche

Raison

D54–D65

signaux de données + synchronisation DCMI sur le connecteur de nappe caméra

D57

TIM1 CH3 — horloge maître de la caméra

D66

GPIO de réinitialisation caméra

D67

GPIO de mise hors tension caméra

SDA1 / SCL1

I²C 4 — partagé avec la caméra ; le bus est utilisable mais évitez l’adresse I²C du capteur

Apprentissage automatique

ml — Apprentissage automatique exécute des modèles TFLite quantifiés sur le Cortex‑M7 avec les noyaux CMSIS‑NN — assez rapides pour des détecteurs compacts à quelques trames par seconde. Les modèles présents sur le système de fichiers en lecture seule /rom se chargent directement depuis la mémoire flash sans copie en RAM. Voici un détecteur BlazeFace 128×128 qui superpose le visage détecté et ses six points de repère sur chaque trame:

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

Cœur M4

Le cœur Cortex‑M4 est exposé via openamp pour la communication inter‑processeurs. Le micrologiciel OpenMV s’exécute uniquement sur le M7 ; le M4 n’a pas son propre environnement d’exécution MicroPython, donc l’utiliser implique de compiler une image de micrologiciel C séparée et de la charger depuis le système de fichiers via openamp.RemoteProc. Un micrologiciel d’exemple précompilé qui implémente un point de terminaison UART virtuel est disponible dans le dépôt openamp_vuart — suivez son README pour compiler 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)

En pratique, cette prise en charge doit plutôt être considérée comme une démonstration de l’interface openamp que comme une plateforme double cœur fonctionnelle — le M4 ne peut pas être réinitialisé indépendamment du M7, donc arrêter le M4 force un redémarrage complet du système.

Affichage (J5)

J5 est un connecteur MIPI‑DSI pour le Arduino Giga Display Shield — une dalle tactile capacitive 480 × 800 construite autour du pilote d’écran ST7701 et du contrôleur tactile GT911. Les deux pilotes sont livrés figés avec le micrologiciel. Utilisez display — pilote d’affichage pour envoyer des tampons d’image et gt911.GT911 pour la saisie tactile.

L’exemple ci‑dessous reproduit l’image de la caméra dans une fenêtre d’affichage portrait 800 × 480 et superpose chaque contact tactile sous la forme d’un cercle coloré:

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

Avertissement

Le Giga Display Shield utilise le même bus I²C 4 (SDA1/SCL1) que la caméra, D74 pour l’activation du rétroéclairage LCD, D70/D71 pour l’IRQ et la réinitialisation tactile du GT911, et D68/D69 pour les signaux TE et RESET de la dalle DSI.

Microphone (Display Shield)

L’Arduino Giga Display Shield embarque un microphone numérique câblé au périphérique DFSDM du STM32H747 (horloge micro sur D75, données micro sur D73). Le microphone est capturé via audio — Module Audio. Chaque tampon arrive sous forme de PCM 16 bits signé dans un bytearray, prêt à être fourni à ulab/numpy pour le traitement du signal:

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)

L’Arduino Giga Display Shield embarque une IMU Bosch BMI270 6 axes (accéléromètre 3D + gyroscope 3D) sur le même bus I²C 4 à l’adresse 0x68. Utilisez le pilote communautaire micropython_bmi270 pour la lire:

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)

Le mappage complet des registres se trouve dans la fiche technique du BMI270.

LED RVB (Display Shield)

L’Arduino Giga Display Shield embarque une LED RVB intégrée pilotée par un pilote de LED 3 canaux ISSI IS31FL3197 sur le même bus I²C 4. La broche AD du pilote est reliée à la masse (GND), il se trouve donc à l’adresse I²C 0x50. Utilisez le pilote communautaire IS31FL3197 pour contrôler la LED:

from machine import I2C
from is31fl3197 import IS31FL3197

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

Le mappage complet des registres se trouve dans la fiche technique de l’IS31FL3197.

Wi‑Fi

Le Murata 1DX (CYW4343W) intégré est exposé via network — configuration réseau en tant qu’interface station. Connectez l’antenne fournie au connecteur U.FL intégré avant d’activer la 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

Le même Murata 1DX expose également le Bluetooth LE 5.1. Utilisez aioble — BLE asynchrone pour du BLE compatible asyncio — par exemple, s’annoncer en tant que périphérique et attendre qu’un central se connecte:

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

Référence des bus

GPIO

Utilisez machine.Pin pour lire ou piloter n’importe quelle broche sérigraphiée. Les sorties sont en CMOS 3,3 V et peuvent absorber/fournir jusqu’à 20 mA par broche (140 mA au total sur l’ensemble du connecteur).

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

Toute broche d’entrée peut aussi déclencher une interruption sur les transitions de front:

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

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

Le bus 2 (D20/D21, les SCL/SDA sérigraphiés) est le bus Wire Arduino par défaut. Le bus 4 (SCL1/SDA1) est partagé avec la caméra et le contrôleur tactile GT911 du Giga Display Shield — les périphériques utilisateur sur ce bus doivent éviter les adresses suivantes (7 bits) :

  • 0x3C — OV5640 / GC2145

  • 0x24 — HM01B0 / HM0360

  • 0x21 — OV7670

  • 0x5D — contrôleur tactile GT911 (Giga Display Shield)

Le même matériel peut aussi être utilisé en mode cible (esclave) via machine.I2CTarget pour exposer une zone mémoire à un autre contrôleur 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 est exposé sur un connecteur 6 broches dédié à l’avant de la carte. SPI5 est exposé sur les étiquettes sérigraphiées COPI/CIPO/SCK de D11/D12/D13.

Note

Brochage du connecteur SPI1 6 broches avant (J7) :

Broche

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

La Giga R1 expose douze canaux ADC 12 bits sur A0–A11, tous référencés à 3,3 V — read_u16 renvoie 0–65535 sur la plage 0–3,3 V à la broche. A8–A11 sont des pastilles _C analogiques uniquement, sans périphérique 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)

Note

A7 est également câblé à l”entrée microphone de la prise audio TRRS 3,5 mm — lorsqu’un casque est branché, ADC("A7") lit directement le signal micro analogique.

DAC

Deux canaux DAC 12 bits sont exposés sur DAC0 et DAC1 via pyb.DAC. Les deux sont câblés à la prise audio TRRS 3,5 mm en tant que canaux sortie ligne gauche et droit:

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

Broche

Minuteur / canal

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

Pilotez n’importe laquelle d’entre elles via machine.PWM:

from machine import Pin, PWM

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

Avertissement

TIM1 est réservé à l”horloge maître de la caméra lorsque la caméra est initialisée via csi — capteurs de caméra. Les broches dont la seule fonction PWM est sur TIM1 — D1, D10, D11, D12 — ne peuvent pas être pilotées en PWM tant que la caméra est active. Les autres broches listées disposent toutes d’alternatives hors TIM1.

Note

Plusieurs broches partagent des canaux de minuteur :

  • TIM2 CH4 est sur D2 et D20.

  • TIM2 CH1 est sur D83/A7 et D85/A13.

  • TIM3 CH1 est sur D7, D56, et D68.

  • TIM3 CH2 est sur D5 et D15.

  • TIM4 CH2 est sur D0 et D6.

  • TIM5 CH1 est sur D64 et D83/A7.

  • TIM5 CH4 est sur D2 et D69.

  • TIM8 CH1 est sur D4, D54, et D68.

  • TIM8 CH1N est sur D5, D16, D57, et D85/A13.

  • TIM8 CH2 est sur D11, D15, D37, et D59.

  • TIM8 CH2N est sur D12, D38, D61, et D78/A2.

  • TIM8 CH3 est sur D48 et D58.

  • TIM8 CH3N est sur D10, D46, et D79/A3.

  • TIM15 CH1 est sur D3 et D51.

  • TIM15 CH2 est sur D2 et D40.

Choisissez un seul consommateur par canal de minuteur.

Bus émulés par logiciel (bit‑banging)

machine.SoftI2C et machine.SoftSPI fonctionnent sur n’importe quel GPIO si vous avez besoin d’un bus supplémentaire.

Capteur thermique (externe)

Le micrologiciel inclut le pilote fir — pilote de capteur thermique (fir == infrarouge lointain) pour les imageurs thermiques câblés en externe :

  • MLX90621 — matrice IR 16 × 4

  • MLX90640 — matrice IR 32 × 24

  • MLX90641 — matrice IR 16 × 12

  • AMG8833 — matrice IR 8 × 8

Câblez le module au bus I²C de la carte et lisez les trames avec 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())

Le pilote fir ne communique avec le capteur que via I²C 1 — câblez le module à D8 (SCL) et D9 (SDA).

Synchronisation

time

Le module time couvre les délais bloquants, les tics monotones et la mesure du temps écoulé:

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)

Minuteurs virtuels

machine.Timer planifie des fonctions de rappel périodiques ou à exécution unique sans consommer d’emplacement de minuteur matériel. Passez -1 comme identifiant pour utiliser un minuteur virtuel (logiciel):

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

Les valeurs de période sont exprimées en millisecondes. Appelez deinit() pour arrêter et libérer l’emplacement.

Horloge temps réel

machine.RTC conserve l’heure murale entre les réinitialisations — et même lors d’une mise hors tension complète si une pile bouton est connectée à la broche VRTC:

from machine import RTC

rtc = RTC()
rtc.datetime((2026, 4, 30, 4, 12, 0, 0, 0))   # Y, M, D, weekday, h, m, s, subsec
print(rtc.datetime())

Chien de garde

machine.WDT réinitialise la carte si l’application se bloque. Une fois démarré, il ne peut être ni arrêté ni reconfiguré — rafraîchissez‑le périodiquement dans votre boucle principale:

from machine import WDT

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

Informations de démarrage et d’exécution

Mise à jour du micrologiciel (DFU)

La Giga R1 utilise le double appui de réinitialisation standard d’Arduino pour entrer dans le programme d’amorçage d’Arduino. Appuyez rapidement deux fois sur le bouton RESET — la carte se ré‑énumère via USB en tant que périphérique DFU et OpenMV IDE peut flasher une nouvelle image de micrologiciel. Si le programme d’amorçage est entièrement absent, maintenez le bouton BOOT0 tout en appuyant sur RESET pour forcer le SoC en mode programme d’amorçage ROM.

Un script en cours d’exécution peut ré‑entrer dans le programme d’amorçage à la demande en appelant machine.bootloader():

import machine

machine.bootloader()

Système de fichiers et ordre de démarrage

Le micrologiciel de la Giga R1 monte jusqu’à deux systèmes de fichiers au démarrage :

  • Mémoire flash interne — toujours montée sur /flash. Contient main.py et README.txt par défaut ; créée lors du tout premier démarrage.

  • ROMFS — système de fichiers en lecture seule, mappé en mémoire, sur /rom, monté automatiquement par MicroPython au démarrage.

Après le montage, le répertoire de travail est défini sur /flash. L’interpréteur exécute ensuite les scripts depuis ce répertoire :

  • boot.py est exécuté à chaque réinitialisation logicielle (démarrage à froid, Ctrl‑D depuis le REPL, ou chaque fois que le script en cours se termine).

  • main.py est exécuté uniquement au démarrage à froid, immédiatement après boot.py. Les réinitialisations logicielles suivantes ré‑exécutent boot.py mais passent directement au REPL — pour ré‑exécuter main.py, vous devez réinitialiser entièrement la carte.

Le main.py par défaut livré sur une carte fraîchement flashée se contente de faire clignoter le canal bleu de la LED RVB utilisateur en guise de battement de cœur (deux impulsions courtes, courte pause), pour que vous puissiez constater que le micrologiciel a démarré proprement sans aucun hôte connecté.

sys.path est étendu pour inclure les deux systèmes de fichiers et leurs sous‑répertoires lib/, afin que les modules importables puissent se trouver dans /flash/lib ou /rom/lib.

Lorsqu’elle est connectée via USB, /flash s’énumère également comme un lecteur de stockage de masse USB sur l’hôte, vous permettant d’éditer boot.py, main.py et tout autre fichier directement. Éjectez le lecteur avant de réinitialiser la carte pour que l’hôte vide ses écritures en cache.

Note

Comme le système d’exploitation traite le lecteur comme un périphérique de bloc passif, les fichiers créés ou modifiés par le code s’exécutant sur la caméra n’apparaîtront pas tant que l’hôte n’a pas remonté le lecteur. Si le système d’exploitation et la caméra écrivent sur le même système de fichiers en même temps, le système d’exploitation l’emportera et écrasera les modifications faites par la caméra.

Note

Le canal rouge de la LED RVB utilisateur peut s’allumer brièvement pendant que l’hôte lit ou écrit sur le lecteur de stockage de masse USB — c’est un indicateur d’activité piloté par le micrologiciel, pas un défaut.

Tailles de stockage

La Giga R1 est livrée avec :

  • /flash — système de fichiers FAT de 11 Mo, lecture/écriture.

  • /rom — ROMFS en lecture seule mappé en mémoire de 4 Mo, utilisé pour livrer des scripts et des modèles ML qui bénéficient d’un accès mmap sans copie.

Indicateur de défaut grave (hard fault)

Si la LED RVB utilisateur défile rapidement à travers toutes les couleurs — assez vite pour ressembler à une LED blanche scintillante plutôt qu’à des teintes distinctes — le micrologiciel a rencontré un défaut grave irrécupérable. Reflashez le micrologiciel pour récupérer ; si le reflashage n’aide pas, la carte est peut‑être physiquement endommagée.

Bibliothèques logicielles

Consultez l”index des bibliothèques pour la liste complète des modules — y compris ceux qui sont propres à la build de la Giga R1.