Arduino Giga R1 WiFi

Arduino Giga R1 WiFi è una scheda da 101 × 53 mm in formato Mega costruita attorno allo STMicroelectronics STM32H747XI, un SoC dual-core che combina un Cortex-M7 a 480 MHz con un Cortex-M4 a 240 MHz. Il firmware OpenMV viene eseguito interamente sul core M7. La Giga aggiunge al consueto layout degli header Arduino Mega un connettore flex per camera Arducam a 22 pin, un connettore MIPI-DSI per l”Arduino Giga Display Shield e un jack audio stereo da 3,5 mm.

Arduino Giga R1 WiFi

Per il datasheet completo, le foto e le dimensioni, consultare la pagina prodotto di Arduino Giga R1 WiFi.

Caratteristiche principali

  • STMicroelectronics STM32H747XI dual Cortex-M7 (480 MHz) + Cortex-M4 (240 MHz). Il firmware OpenMV viene eseguito solo sul core M7; il core M4 è esposto tramite openamp per la comunicazione inter-processore.

  • 8 MB di SDRAM esterna più 2 MB di flash interna e 16 MB di flash QSPI esterna.

  • Codificatore/decodificatore JPEG hardware.

  • Connettore flex per camera compatibile Arducam a 22 pin (J6) — supporto driver per i moduli sensore OV5640 (5MP), OV7670, GC2145, HM01B0 e HM0360.

  • Connettore display MIPI-DSI (J5) per l”Arduino Giga Display Shield (pannello touch capacitivo 480×800) più un motore display LTDC RGB per carrier avanzati.

  • Jack audio da 3,5 mm con line-out stereo e ingresso microfono.

  • Wi-Fi b/g/n (2,4 GHz) + Bluetooth LE 5.1 tramite il modulo Murata 1DX (CYW4343W) — si collega all’antenna fornita tramite un connettore U.FL integrato.

  • USB-C (full-speed) per alimentazione / seriale / programmazione.

  • I/O utente sugli header in stile Mega — D0–D75 (digitali), A0–A11 (analogici), DAC0/DAC1 (uscite DAC), CAN_RX/CAN_TX (FDCAN2) e la coppia I²C SDA1/SCL1 della fila interna. Un header SPI1 a 6 pin separato sul lato frontale della scheda espone CIPO/COPI/SCK (D89/D90/D91).

  • JTAG / SWD esposti sull’header di debug sul lato superiore per il debug avanzato.

Pinout

Pinout di Arduino Giga R1 WiFi

Riferimento dei pin

Gli header in stile Arduino Mega espongono 76 pin digitali (D0–D75), 12 pin analogici (A0–A11), due uscite DAC (DAC0/DAC1), una coppia I²C secondaria (SDA1/SCL1) e una coppia FDCAN2 (CAN_RX/CAN_TX). Un header SPI1 a 6 pin separato sul lato frontale della scheda espone CIPO/COPI/SCK (D89/D90/D91).

Nome del pin

Riferimento

Funzione

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 (clock master della camera — 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 (I²C del display)

D64

3,3 V

TIM5 CH1 (camera DCMI D1)

D65

3,3 V

TIM12 CH2 (camera DCMI D0)

D66

3,3 V

GPIO (reset della camera — riservato quando la camera è attiva)

D67

3,3 V

GPIO (power-down della camera — riservato quando la camera è attiva)

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 (dati microfono DFSDM Display Shield)

D74

3,3 V

GPIO (retroilluminazione display — riservato dalla Giga Display Shield)

D75

3,3 V

SPI2 SCK (clock microfono DFSDM Display Shield)

A0 / D76

3,3 V

ADC12 IN4

A1 / D77

3,3 V

ADC12 IN8

A2 / D78

3,3 V

ADC12 IN9 / TIM3 CH3 / TIM8 CH2N

A3 / D79

3,3 V

ADC12 IN5 / TIM3 CH4 / TIM8 CH3N

A4 / D80

3,3 V

ADC12 IN13 / SPI2 MOSI

A5 / D81

3,3 V

ADC123 IN12 / SPI2 MISO

A6 / D82

3,3 V

ADC123 IN10

A7 / D83

3,3 V

ADC1 IN16 / TIM2 CH1 / TIM5 CH1 (ingresso microfono jack audio)

A8

3,3 V

ADC3 IN0 (solo analogico)

A9

3,3 V

ADC3 IN1 (solo analogico)

A10

3,3 V

ADC12 IN1 (solo analogico)

A11

3,3 V

ADC12 IN0 (solo analogico)

DAC0 / A12 / D84

3,3 V

DAC1 OUT1 / ADC12 IN18 (line-out L jack audio)

DAC1 / A13 / D85

3,3 V

DAC1 OUT2 / TIM2 CH1 / SPI1 SCK / ADC12 IN19 (line-out R jack audio)

D89

3,3 V

SPI1 MISO (CIPO sull’header SPI frontale)

D90

3,3 V

SPI1 MOSI (COPI sull’header SPI frontale)

D91

3,3 V

SPI1 SCK (SCK sull’header SPI frontale)

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 touch del display / controllo camera)

SCL1 / D101

3,3 V

I2C4 SCL (bus touch del display / controllo camera)

RESET

3,3 V

premere il pulsante RESET integrato o collegare a GND per resettare

LED_RED

3,3 V

canale rosso del LED RGB (attivo basso)

LED_GREEN

3,3 V

canale verde del LED RGB (attivo basso)

LED_BLUE

3,3 V

canale blu del LED RGB (attivo basso)

Nota

I pad A8–A11 sono solo analogici sui pin _C dello STM32H747 — non hanno funzione GPIO e possono essere letti soltanto tramite l’ADC.

Pin di alimentazione

Pin dell’header Mega:

  • VIN — ingresso 6–32 V. Alimenta la scheda attraverso il regolatore buck integrato.

  • +5V — linea a 5 V alimentata da USB tramite un diodo o dal regolatore buck integrato.

  • +3V3 — linea principale a 3,3 V.

  • IOREF — riflette la tensione di I/O della scheda (3,3 V).

  • AREF — riferimento di tensione analogico per i pin ADC. Per impostazione predefinita è 3,3 V; pilotarlo esternamente per usare un riferimento diverso.

  • OFF — collegare a GND per spegnere la linea a +3,3 V e arrestare il sistema.

  • VRTC — ingresso per batteria a bottone da 3,0 V (3,3 V max) che mantiene in funzione l’RTC integrato mentre il resto della scheda è spento.

  • GND — massa comune.

La Giga R1 può essere alimentata attraverso una qualsiasi di queste vie:

  • USB-C — fornisce 5 V al regolatore buck integrato.

  • Pin VIN — fornire direttamente un’alimentazione regolata da 6–32 V.

Suggerimento

Utilizzare lo stimatore della durata della batteria per modellare quanto a lungo la Giga R1 funzionerà a batteria per un dato duty cycle attivo / deep-sleep.

Pin di recupero e debug

  • RESET — sia un pin esposto sull’header di alimentazione sia un pulsante momentaneo sulla parte superiore della scheda, collegato alla linea NRST del SoC. Collegare a GND o premere il pulsante per resettare.

La Giga R1 utilizza il double-tap reset standard di Arduino per entrare nel bootloader di Arduino. Premere rapidamente il pulsante RESET due volte — la scheda si rienumera su USB come dispositivo DFU e OpenMV IDE può flashare una nuova immagine firmware.

Se il bootloader manca completamente, tenere premuto il pulsante BOOT0 mentre si preme RESET per forzare il SoC nella modalità bootloader ROM.

I segnali SWD dello STM32 sono esposti sull”header Cortex Debug a 10 pin con passo 1,27 mm sul lato frontale della scheda. Collegarli tramite un SEGGER J-Link, ST-Link o qualsiasi sonda ARM JTAG/SWD standard. Tutti i segnali di debug sono riferiti a 3,3 V.

Periferiche integrate

LED

La Giga R1 ha un unico LED RGB utente, controllabile via software tramite machine.LED

from machine import LED

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

Un LED power separato sulla scheda si accende ogni volta che la linea a +3,3 V è attiva e non è controllabile dall’utente.

Connettore camera (J6)

J6 è un connettore flex per camera compatibile Arducam a 22 pin. Collegare uno qualsiasi dei moduli sensore supportati e il firmware li rileva automaticamente tramite il modulo csi — sensori camera

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

Sensori supportati:

  • OV5640 — 5 MP a colori, fino a QSXGA (2592 × 1944).

  • OV7670 — 0,3 MP a colori, fino a VGA (640 × 480).

  • GC2145 — 2 MP a colori, fino a UXGA (1600 × 1200).

  • HM01B0 — monocromatico 320 × 320.

  • HM0360 — monocromatico VGA (640 × 480).

Avvertimento

Mentre la camera è inizializzata, i seguenti pin dell’header Mega sono riservati dal firmware e non possono essere usati:

Pin

Motivo

D54–D65

Segnali dati DCMI + sync sul connettore flex della camera

D57

TIM1 CH3 — clock master della camera

D66

GPIO di reset della camera

D67

GPIO di power-down della camera

SDA1 / SCL1

I²C 4 — condiviso con la camera; il bus è utilizzabile ma evitare l’indirizzo I²C del sensore

Machine learning

ml — Machine Learning esegue modelli TFLite quantizzati sul Cortex-M7 con kernel CMSIS-NN — abbastanza veloci per rilevatori compatti a pochi frame al secondo. I modelli sul filesystem di sola lettura /rom vengono caricati direttamente dalla flash senza copia in RAM. Ecco un rilevatore BlazeFace 128×128 che sovrappone il volto rilevato e i suoi sei landmark su ogni frame:

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

Core M4

Il core Cortex-M4 è esposto tramite openamp per la comunicazione inter-processore. Il firmware OpenMV viene eseguito solo sull’M7; l’M4 non ha un runtime MicroPython proprio, quindi utilizzarlo significa creare un’immagine firmware C separata e caricarla dal filesystem tramite openamp.RemoteProc. Un firmware di esempio pre-compilato che implementa un endpoint UART virtuale è disponibile nel repository openamp_vuart — seguire il suo README per compilare 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)

In pratica conviene considerare questo supporto come una dimostrazione dell’interfaccia openamp piuttosto che come una piattaforma dual-core funzionante — l’M4 non può essere resettato indipendentemente dall’M7, quindi arrestare l’M4 forza un riavvio completo del sistema.

Display (J5)

J5 è un connettore MIPI-DSI per l”Arduino Giga Display Shield — un pannello touch capacitivo 480 × 800 costruito attorno al driver di pannello ST7701 e al controller touch GT911. Entrambi i driver vengono forniti freezati con il firmware. Utilizzare display — driver del display per inviare framebuffer e gt911.GT911 per l’input touch.

L’esempio seguente replica la camera in una finestra display verticale 800 × 480 e sovrappone ogni contatto touch come un cerchio colorato:

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

Avvertimento

La Giga Display Shield utilizza lo stesso bus I²C 4 (SDA1/SCL1) della camera, D74 per l’abilitazione della retroilluminazione LCD, D70/D71 per l’IRQ e il reset del touch GT911 e D68/D69 per i segnali TE e RESET del pannello DSI.

Microfono (Display Shield)

L’Arduino Giga Display Shield è dotata di un microfono digitale collegato alla periferica DFSDM dello STM32H747 (clock microfono su D75, dati microfono su D73). Il microfono viene acquisito tramite audio — Modulo Audio. Ogni buffer arriva come PCM con segno a 16 bit in un bytearray, pronto per essere passato a ulab/numpy per l’elaborazione del segnale:

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 è dotata di una IMU a 6 assi Bosch BMI270 (accelerometro 3D + giroscopio 3D) sullo stesso bus I²C 4 all’indirizzo 0x68. Utilizzare il driver della community micropython_bmi270 per leggerla:

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)

La mappa completa dei registri è nel datasheet del BMI270.

LED RGB (Display Shield)

L’Arduino Giga Display Shield è dotata di un LED RGB integrato pilotato da un driver LED a 3 canali ISSI IS31FL3197 sullo stesso bus I²C 4. Il pin AD del driver è collegato a GND, quindi si trova all’indirizzo I²C 0x50. Utilizzare il driver della community IS31FL3197 per controllare il LED:

from machine import I2C
from is31fl3197 import IS31FL3197

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

La mappa completa dei registri è nel datasheet dell’IS31FL3197.

Wi-Fi

Il Murata 1DX (CYW4343W) integrato è esposto tramite network — configurazione di rete come interfaccia station. Collegare l’antenna fornita al connettore U.FL integrato prima di attivare 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

Lo stesso Murata 1DX espone anche il Bluetooth LE 5.1. Utilizzare aioble — BLE asincrono per il BLE compatibile con asyncio — ad esempio, fare advertising come periferica e attendere che un central si connetta:

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

Riferimento dei bus

GPIO

Utilizzare machine.Pin per leggere o pilotare uno qualsiasi dei pin serigrafati. Le uscite sono CMOS a 3,3 V e possono assorbire/erogare fino a 20 mA per pin (140 mA totali su tutto l’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())

Qualsiasi pin di ingresso può anche generare un interrupt sulle transizioni di fronte:

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

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

Il bus 2 (D20/D21, i serigrafati SCL/SDA) è il bus Wire Arduino predefinito. Il bus 4 (SCL1/SDA1) è condiviso con la camera e con il controller touch GT911 della Giga Display Shield — i dispositivi utente su questo bus devono evitare i seguenti indirizzi (7 bit):

  • 0x3C — OV5640 / GC2145

  • 0x24 — HM01B0 / HM0360

  • 0x21 — OV7670

  • 0x5D — controller touch GT911 (Giga Display Shield)

Lo stesso hardware può essere usato anche in modalità target (slave) tramite machine.I2CTarget per esporre una regione di memoria a un altro controller 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 è esposto su un header dedicato a 6 pin sul lato frontale della scheda. SPI5 è esposto sulle etichette serigrafate COPI/CIPO/SCK su D11/D12/D13.

Nota

Pinout dell’header SPI1 frontale a 6 pin (J7):

Pin

Segnale

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 espone dodici canali ADC a 12 bit su A0–A11, tutti riferiti a 3,3 V — read_u16 restituisce 0–65535 nell’intervallo 0–3,3 V al pin. A8–A11 sono pad _C solo analogici senza periferica 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)

Nota

A7 è anche collegato all”ingresso microfono sul jack audio TRRS da 3,5 mm — quando è inserita una cuffia, ADC("A7") legge direttamente il segnale analogico del microfono.

DAC

Due canali DAC a 12 bit sono esposti su DAC0 e DAC1 tramite pyb.DAC. Entrambi sono collegati al jack audio TRRS da 3,5 mm come canali line-out sinistro e destro:

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

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

Pilotare uno qualsiasi di essi tramite machine.PWM

from machine import Pin, PWM

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

Avvertimento

TIM1 è riservato al clock master della camera quando la camera è inizializzata tramite csi — sensori camera. I pin la cui unica funzione PWM è su TIM1 — D1, D10, D11, D12 — non possono essere pilotati in PWM mentre la camera è attiva. Tutti gli altri pin elencati hanno alternative non-TIM1.

Nota

Diversi pin condividono i canali timer:

  • TIM2 CH4 è su D2 e D20.

  • TIM2 CH1 è su D83/A7 e D85/A13.

  • TIM3 CH1 è su D7, D56, e D68.

  • TIM3 CH2 è su D5 e D15.

  • TIM4 CH2 è su D0 e D6.

  • TIM5 CH1 è su D64 e D83/A7.

  • TIM5 CH4 è su D2 e D69.

  • TIM8 CH1 è su D4, D54, e D68.

  • TIM8 CH1N è su D5, D16, D57, e D85/A13.

  • TIM8 CH2 è su D11, D15, D37, e D59.

  • TIM8 CH2N è su D12, D38, D61, e D78/A2.

  • TIM8 CH3 è su D48 e D58.

  • TIM8 CH3N è su D10, D46, e D79/A3.

  • TIM15 CH1 è su D3 e D51.

  • TIM15 CH2 è su D2 e D40.

Scegliere un solo consumer per canale timer.

Bus software con bit-banging

machine.SoftI2C e machine.SoftSPI funzionano su qualsiasi GPIO se serve un bus aggiuntivo.

Sensore termico (esterno)

Il firmware include il driver fir — driver del sensore termico (fir == far infrared) per termocamere cablate esternamente:

  • MLX90621 — array IR 16 × 4

  • MLX90640 — array IR 32 × 24

  • MLX90641 — array IR 16 × 12

  • AMG8833 — array IR 8 × 8

Collegare il modulo al bus I²C della scheda e leggere i frame con 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())

Il driver fir comunica con il sensore solo tramite I²C 1 — collegare il modulo a D8 (SCL) e D9 (SDA).

Temporizzazione

time

Il modulo time copre i ritardi bloccanti, i tick monotoni e la misurazione del tempo trascorso:

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)

Timer virtuali

machine.Timer pianifica callback periodiche o one-shot senza occupare uno slot timer hardware. Passare -1 come id per usare un timer virtuale (software):

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

I valori di periodo sono in millisecondi. Chiamare deinit() per fermare e rilasciare lo slot.

Orologio in tempo reale

machine.RTC mantiene l’ora di sistema attraverso i reset — e attraverso lo spegnimento completo quando una batteria a bottone è collegata al pin 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())

Watchdog

machine.WDT resetta la scheda se l’applicazione si blocca. Una volta avviato non può essere fermato né riconfigurato — alimentarlo periodicamente all’interno del ciclo principale:

from machine import WDT

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

Informazioni di boot e runtime

Aggiornamento firmware (DFU)

La Giga R1 utilizza il double-tap reset standard di Arduino per entrare nel bootloader di Arduino. Premere rapidamente il pulsante RESET due volte — la scheda si rienumera su USB come dispositivo DFU e OpenMV IDE può flashare una nuova immagine firmware. Se il bootloader manca completamente, tenere premuto il pulsante BOOT0 mentre si preme RESET per forzare il SoC nella modalità bootloader ROM.

Uno script in esecuzione può rientrare nel bootloader su richiesta chiamando machine.bootloader()

import machine

machine.bootloader()

Filesystem e ordine di boot

Il firmware della Giga R1 monta fino a due filesystem all’avvio:

  • Flash interna — sempre montata su /flash. Contiene main.py e README.txt per impostazione predefinita; creata al primissimo avvio.

  • ROMFS — filesystem di sola lettura, mappato in memoria su /rom, montato automaticamente da MicroPython all’avvio.

Dopo il montaggio, la directory di lavoro è impostata su /flash. L’interprete esegue quindi gli script da quella directory:

  • boot.py viene eseguito a ogni soft reset (avvio a freddo, Ctrl‑D dalla REPL, o ogni volta che lo script in esecuzione termina).

  • main.py viene eseguito solo all’avvio a freddo, subito dopo boot.py. I soft reset successivi rieseguono boot.py ma passano direttamente alla REPL — per rieseguire main.py occorre resettare completamente la scheda.

Il main.py predefinito fornito su una scheda appena flashata si limita a far lampeggiare il canale blu del LED RGB utente come segnale di heartbeat (due brevi impulsi, breve pausa), così da poter verificare che il firmware si sia avviato correttamente senza alcun host collegato.

sys.path viene esteso per includere entrambi i filesystem e le rispettive sottodirectory lib/, così i moduli importabili possono trovarsi in /flash/lib o /rom/lib.

Quando è collegata via USB, /flash viene enumerata anche come unità di archiviazione di massa USB sull’host, permettendo di modificare direttamente boot.py, main.py e qualsiasi altro file. Espellere l’unità prima di resettare la scheda in modo che l’host scarichi le scritture memorizzate nella cache.

Nota

Poiché il sistema operativo tratta l’unità come un dispositivo a blocchi passivo, i file creati o modificati dal codice in esecuzione sulla camera non compariranno finché l’host non rimonta l’unità. Se sia il sistema operativo sia la camera scrivono sullo stesso filesystem contemporaneamente, vincerà il sistema operativo, sovrascrivendo le modifiche apportate dalla camera.

Nota

Il canale rosso del LED RGB utente può accendersi brevemente mentre l’host legge o scrive sull’unità di archiviazione di massa USB — è un indicatore di attività pilotato dal firmware, non un guasto.

Dimensioni di archiviazione

La Giga R1 viene fornita con:

  • /flash — filesystem FAT da 11 MB, in lettura/scrittura.

  • /rom — ROMFS di sola lettura mappata in memoria da 4 MB, usata per distribuire script e modelli ML che beneficiano dell’accesso mmap zero-copy.

Indicatore di hard fault

Se il LED RGB utente cicla rapidamente attraverso tutti i colori — abbastanza velocemente da sembrare un LED bianco scintillante anziché tonalità distinte — il firmware ha incontrato un hard fault irrecuperabile. Riflashare il firmware per recuperare; se il riflash non aiuta, la scheda potrebbe essere danneggiata fisicamente.

Librerie software

Consultare l”indice delle librerie per l’elenco completo dei moduli — inclusi quelli esclusivi della build della Giga R1.