Arduino Giga R1 WiFi¶

O Arduino Giga R1 WiFi é uma placa no formato Mega de 101 × 53 mm, construída em torno do STMicroelectronics STM32H747XI — um SoC de núcleo duplo que combina um Cortex‑M7 a 480 MHz com um Cortex‑M4 a 240 MHz. O firmware OpenMV corre exclusivamente no núcleo M7. O Giga adiciona um conector flex para câmara Arducam de 22 pinos, um conector MIPI‑DSI para o Arduino Giga Display Shield, e uma ficha de áudio estéreo de 3,5 mm ao layout padrão de cabeçalhos Arduino Mega.

Para a ficha técnica completa, fotos e dimensões, consulte a página do produto Arduino Giga R1 WiFi.

Destaques¶

STMicroelectronics STM32H747XI dual Cortex‑M7 (480 MHz) + Cortex‑M4 (240 MHz). O firmware OpenMV corre apenas no núcleo M7; o núcleo M4 é exposto através de openamp para comunicação entre processadores.
8 MB de SDRAM externa mais 2 MB de flash interna e 16 MB de flash QSPI externa.
Codificador/descodificador JPEG por hardware.
Conector flex para câmara compatível com Arducam de 22 pinos (J6) — suporte de controlador para módulos de sensor OV5640 (5 MP), OV7670, GC2145, HM01B0 e HM0360.
Conector de ecrã MIPI‑DSI (J5) para o Arduino Giga Display Shield (painel táctil capacitivo de 480×800) mais um motor de ecrã RGB LTDC para portadoras avançadas.
Ficha de áudio de 3,5 mm com saída de linha estéreo e entrada de microfone.
Wi‑Fi b/g/n (2,4 GHz) + Bluetooth LE 5.1 via módulo Murata 1DX (CYW4343W) — liga‑se à antena fornecida através de um conector U.FL na placa.
USB‑C (velocidade máxima) para alimentação / série / programação.
E/S de utilizador nos cabeçalhos no estilo Mega — D0–D75 (digital), A0–A11 (analógico), DAC0/DAC1 (saídas DAC), CAN_RX/CAN_TX (FDCAN2), e o par I²C SDA1/SCL1 na fila interior. Um cabeçalho SPI1 de 6 pinos na frente da placa disponibiliza CIPO/COPI/SCK (D89/D90/D91).
JTAG / SWD disponível no cabeçalho de depuração no topo da placa para depuração avançada.

Diagrama de pinos¶

Referência de pinos¶

Os cabeçalhos no estilo Arduino Mega expõem 76 pinos digitais (D0–D75), 12 pinos analógicos (A0–A11), duas saídas DAC (DAC0/DAC1), um par I²C secundário (SDA1/SCL1) e um par FDCAN2 (CAN_RX/CAN_TX). Um cabeçalho SPI1 de 6 pinos na frente da placa disponibiliza CIPO/COPI/SCK (D89/D90/D91).

Nome do pino	Referência	Função
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 (DCMI VSYNC da câmara)
D55	3,3 V	I2C3 SDA (DCMI HSYNC da câmara)
D56	3,3 V	TIM3 CH1 / TIM13 CH1 (DCMI PXCLK da câmara)
D57	3,3 V	TIM8 CH1N / UART8 RX (relógio principal da câmara — TIM1 CH3)
D58	3,3 V	TIM8 CH3 (DCMI D7 da câmara)
D59	3,3 V	TIM8 CH2 (DCMI D6 da câmara)
D60	3,3 V	GPIO (DCMI D5 da câmara)
D61	3,3 V	TIM8 CH2N / UART4 RX (DCMI D4 da câmara)
D62	3,3 V	SPI1 SCK (DCMI D3 da câmara)
D63	3,3 V	TIM5 CH2 / I2C4 SCL (I²C do ecrã)
D64	3,3 V	TIM5 CH1 (DCMI D1 da câmara)
D65	3,3 V	TIM12 CH2 (DCMI D0 da câmara)
D66	3,3 V	GPIO (reset da câmara — ocupado quando a câmara está activa)
D67	3,3 V	GPIO (power‑down da câmara — ocupado quando a câmara está activa)
D68	3,3 V	TIM3 CH1 / TIM8 CH1 / USART6 TX (DSI RESET do Display Shield)
D69	3,3 V	TIM5 CH4 (DSI TE do Display Shield)
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 (dados do microfone DFSDM do Display Shield)
D74	3,3 V	GPIO (retroiluminação do ecrã — ocupado pelo Giga Display Shield)
D75	3,3 V	SPI2 SCK (relógio do microfone DFSDM do 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 (entrada de microfone da ficha de áudio)
A8	3,3 V	ADC3 IN0 (apenas analógico)
A9	3,3 V	ADC3 IN1 (apenas analógico)
A10	3,3 V	ADC12 IN1 (apenas analógico)
A11	3,3 V	ADC12 IN0 (apenas analógico)
DAC0 / A12 / D84	3,3 V	DAC1 OUT1 / ADC12 IN18 (saída de linha L da ficha de áudio)
DAC1 / A13 / D85	3,3 V	DAC1 OUT2 / TIM2 CH1 / SPI1 SCK / ADC12 IN19 (saída de linha R da ficha de áudio)
D89	3,3 V	SPI1 MISO (`CIPO` no cabeçalho SPI frontal)
D90	3,3 V	SPI1 MOSI (`COPI` no cabeçalho SPI frontal)
D91	3,3 V	SPI1 SCK (`SCK` no cabeçalho SPI frontal)
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 de controlo táctil do ecrã / câmara)
SCL1 / D101	3,3 V	I2C4 SCL (bus de controlo táctil do ecrã / câmara)
RESET	3,3 V	prima o botão RESET na placa ou ligue ao GND para reiniciar
LED_RED	3,3 V	Canal vermelho do LED RGB (activo a nível baixo)
LED_GREEN	3,3 V	Canal verde do LED RGB (activo a nível baixo)
LED_BLUE	3,3 V	Canal azul do LED RGB (activo a nível baixo)

Nota

A8–A11 são pinos apenas analógicos nos pinos _C do STM32H747 — não têm função GPIO e só podem ser lidos através do ADC.

Pinos de alimentação¶

Pinos do cabeçalho Mega:

VIN — entrada de 6–32 V. Alimenta a placa através do regulador buck integrado.
+5V — rail de 5 V fornecido por USB através de um díodo ou pelo regulador buck integrado.
+3V3 — rail principal de 3,3 V.
IOREF — reflecte a tensão de E/S da placa (3,3 V).
AREF — referência de tensão analógica para os pinos ADC. Por defeito é 3,3 V; pode ser conduzida externamente para usar uma referência diferente.
OFF — ligue ao GND para desligar o rail +3,3 V e desligar o sistema.
VRTC — entrada de pilha de botão de 3,0 V (máx. 3,3 V) que mantém o RTC do chip a funcionar enquanto o restante da placa está desligado.
GND — terra comum.

O Giga R1 pode ser alimentado por qualquer um destes caminhos:

USB‑C — fornece 5 V ao regulador buck integrado.
Pino VIN — ligue directamente uma fonte regulada de 6–32 V.

Dica

Use o estimador de autonomia da bateria para modelar quanto tempo o Giga R1 funcionará com uma bateria para um determinado ciclo de actividade / sono profundo.

Pinos de recuperação e depuração¶

RESET — tanto um pino exposto no cabeçalho de alimentação como um comutador momentâneo no topo da placa, ligado à linha NRST do SoC. Ligue ao GND ou prima o botão para reiniciar.

Se o bootloader estiver completamente em falta, mantenha premido o botão BOOT0 enquanto prime RESET para forçar o SoC a entrar no modo bootloader ROM.

Os sinais SWD do STM32 estão expostos no cabeçalho de depuração Cortex de 10 pinos a 1,27 mm na frente da placa. Ligue‑os via SEGGER J‑Link, ST‑Link ou qualquer sonda JTAG/SWD ARM padrão. Todos os sinais de depuração são referenciados a 3,3 V.

Periféricos integrados¶

LEDs¶

O Giga R1 possui um único LED RGB de utilizador, controlável por software através de machine.LED

from machine import LED

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

Um LED de alimentação separado na placa acende sempre que o rail +3,3 V está activo e não é controlável pelo utilizador.

Conector de câmara (J6)¶

J6 é um conector flex para câmara compatível com Arducam de 22 pinos. Ligue qualquer um dos módulos de sensor suportados e o firmware detecta‑os automaticamente através do módulo csi — sensores de câmara

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

Sensores suportados:

OV5640 — 5 MP cor, até QSXGA (2592 × 1944).
OV7670 — 0,3 MP cor, até VGA (640 × 480).
GC2145 — 2 MP cor, até UXGA (1600 × 1200).
HM01B0 — 320 × 320 monocromático.
HM0360 — VGA (640 × 480) monocromático.

Aviso

Enquanto a câmara está inicializada, os seguintes pinos do cabeçalho Mega estão ocupados pelo firmware e não podem ser utilizados:

Pino	Motivo
`D54`–`D65`	Dados DCMI + sinais de sincronização no conector flex da câmara
`D57`	TIM1 CH3 — relógio principal da câmara
`D66`	GPIO de reset da câmara
`D67`	GPIO de power‑down da câmara
`SDA1` / `SCL1`	I²C 4 — partilhado com a câmara; o bus é utilizável, mas evite o endereço I²C do sensor

Aprendizagem automática¶

ml — Machine Learning executa modelos TFLite quantizados no Cortex‑M7 com kernels CMSIS‑NN — rápido o suficiente para detectores compactos a alguns fotogramas por segundo. Os modelos no sistema de ficheiros somente de leitura /rom carregam directamente da flash sem copiar para RAM. Aqui está um detector BlazeFace de 128×128 que sobrepõe a face detectada e os seus seis pontos de referência em cada fotograma:

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

Núcleo M4¶

O núcleo Cortex‑M4 é exposto através de openamp para comunicação entre processadores. O firmware OpenMV corre apenas no M7; o M4 não tem runtime MicroPython próprio, pelo que utilizá‑lo implica construir uma imagem de firmware C separada e carregá‑la do sistema de ficheiros via openamp.RemoteProc. O firmware de exemplo pré‑compilado que implementa um endpoint UART virtual está disponível no repositório openamp_vuart — siga o README para compilar 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)

Na prática, este suporte é mais adequado como demonstração da interface openamp do que como plataforma de núcleo duplo funcional — o M4 não pode ser reiniciado independentemente do M7, pelo que parar o M4 força um reinício completo do sistema.

Ecrã (J5)¶

J5 é um conector MIPI‑DSI para o Arduino Giga Display Shield — um painel táctil capacitivo de 480 × 800 construído em torno do controlador de painel ST7701 e do controlador táctil GT911. Ambos os controladores estão incluídos no firmware. Use display — controlador de ecrã para enviar buffers de fotograma e gt911.GT911 para entrada táctil.

O exemplo abaixo reflecte a câmara numa janela de ecrã retrato de 800 × 480 e sobrepõe cada contacto táctil como um círculo colorido:

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

Aviso

O Giga Display Shield usa o mesmo bus I²C 4 (SDA1/SCL1) que a câmara, D74 para a activação da retroiluminação LCD, D70/D71 para o IRQ e reset táctil GT911, e D68/D69 para os sinais TE e RESET do painel DSI.

Microfone (Display Shield)¶

O Arduino Giga Display Shield incorpora um microfone digital ligado ao periférico DFSDM do STM32H747 (relógio do microfone em D75, dados do microfone em D73). O microfone é capturado através de audio — Módulo de Áudio. Cada buffer chega como bytearray PCM com sinal de 16 bits, pronto para alimentar ulab/numpy para processamento de sinal:

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

O Arduino Giga Display Shield incorpora um IMU Bosch BMI270 de 6 eixos (acelerómetro 3D + giroscópio 3D) no mesmo bus I²C 4, no endereço 0x68. Use o controlador comunitário micropython_bmi270 para o ler:

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)

O mapa de registos completo está na ficha técnica do BMI270.

LED RGB (Display Shield)¶

O Arduino Giga Display Shield incorpora um LED RGB integrado controlado por um controlador LED de 3 canais ISSI IS31FL3197 no mesmo bus I²C 4. O pino AD do controlador está ligado ao GND, ficando no endereço I²C 0x50. Use o controlador comunitário IS31FL3197 para controlar o LED:

from machine import I2C
from is31fl3197 import IS31FL3197

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

O mapa de registos completo está na ficha técnica do IS31FL3197.

Wi‑Fi¶

O Murata 1DX (CYW4343W) integrado é exposto via network — configuração de rede como interface de estação. Ligue a antena fornecida ao conector U.FL na placa antes de activar o rádio:

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¶

O mesmo Murata 1DX também expõe Bluetooth LE 5.1. Use aioble — BLE Assíncrono para BLE compatível com asyncio — por exemplo, anuncie como periférico e aguarde que um central se ligue:

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

Referência de barramento¶

GPIO¶

Use machine.Pin para ler ou controlar qualquer um dos pinos serigrafados. As saídas são CMOS a 3,3 V e podem absorver/fornecer até 20 mA por pino (140 mA no total em todo o cabeçalho).

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

Qualquer pino de entrada também pode disparar uma interrupção em transições de flanco:

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

O Bus 2 (D20/D21, os pinos serigrafados SCL/SDA) é o bus Wire padrão do Arduino. O Bus 4 (SCL1/SDA1) é partilhado com a câmara e o controlador táctil GT911 do Giga Display Shield — os dispositivos do utilizador neste bus devem evitar os seguintes endereços (7 bits):

0x3C — OV5640 / GC2145
0x24 — HM01B0 / HM0360
0x21 — OV7670
0x5D — controlador táctil GT911 (Giga Display Shield)

O mesmo hardware também pode ser utilizado em modo alvo (escravo) através de machine.I2CTarget para expor uma região de memória a outro controlador 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

O SPI1 está exposto num cabeçalho dedicado de 6 pinos na frente da placa. O SPI5 está exposto nas etiquetas serigrafadas COPI/CIPO/SCK em D11/D12/D13.

Nota

Diagrama do cabeçalho frontal de 6 pinos SPI1 (J7):

Pino	Sinal
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¶

O Giga R1 expõe doze canais ADC de 12 bits em A0–A11, todos referenciados a 3,3 V — read_u16 devolve 0–65535 para 0–3,3 V no pino. A8–A11 são pads _C apenas analógicos sem periférico 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 também está ligado à entrada de microfone na ficha de áudio TRRS de 3,5 mm — quando um auricular está ligado, ADC("A7") lê directamente o sinal analógico do microfone.

DAC¶

Dois canais DAC de 12 bits estão expostos em DAC0 e DAC1 através de pyb.DAC. Ambos estão ligados à ficha de áudio TRRS de 3,5 mm como canais de saída de linha esquerdo e direito:

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¶

Pino	Temporizador / 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

Controle qualquer um deles através de machine.PWM

from machine import Pin, PWM

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

Aviso

TIM1 está reservado para o relógio principal da câmara quando a câmara é inicializada através de csi — sensores de câmara. Os pinos cuja única função PWM é no TIM1 — D1, D10, D11, D12 — não podem ser controlados por PWM enquanto a câmara está activa. Os restantes pinos listados têm alternativas não TIM1.

Nota

Vários pinos partilham canais de temporizador:

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

Escolha um único utilizador por canal de temporizador.

Buses emulados por software¶

machine.SoftI2C e machine.SoftSPI funcionam em qualquer GPIO se precisar de um bus adicional.

Sensor térmico (externo)¶

O firmware inclui o controlador fir — driver de sensor térmico (fir == infravermelho longínquo) para sensores térmicos ligados externamente:

MLX90621 — array de infravermelhos 16 × 4
MLX90640 — array de infravermelhos 32 × 24
MLX90641 — array de infravermelhos 16 × 12
AMG8833 — array de infravermelhos 8 × 8

Ligue o módulo ao bus I²C da placa e leia fotogramas com 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())

O controlador fir comunica com o sensor apenas por I²C 1 — ligue o módulo a D8 (SCL) e D9 (SDA).

Temporização¶

time¶

O módulo time cobre atrasos bloqueantes, contagens monótonas e medição de tempo decorrido:

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)

Temporizadores virtuais¶

machine.Timer agenda callbacks periódicos ou únicos sem consumir um slot de temporizador de hardware. Passe -1 como id para usar um temporizador virtual (por 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"))

Os valores de período são em milissegundos. Chame deinit() para parar e libertar o slot.

Relógio em tempo real¶

machine.RTC mantém a hora do relógio entre reinícios — e entre desligamentos completos quando uma pilha de botão está ligada ao pino 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 reinicia a placa se a aplicação ficar bloqueada. Uma vez iniciado não pode ser parado ou reconfigurado — alimente‑o periodicamente dentro do seu loop principal:

from machine import WDT

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

Informação de arranque e runtime¶

Actualização de firmware (DFU)¶

O Giga R1 usa o reset de duplo toque padrão do Arduino para entrar no bootloader do Arduino. Prima rapidamente o botão RESET duas vezes — a placa re‑enumera sobre USB como dispositivo DFU e o OpenMV IDE pode instalar uma nova imagem de firmware. Se o bootloader estiver completamente em falta, mantenha premido o botão BOOT0 enquanto prime RESET para forçar o SoC a entrar no modo bootloader ROM.

Um script em execução pode reentrar no bootloader a pedido chamando machine.bootloader()

import machine

machine.bootloader()

Sistema de ficheiros e ordem de arranque¶

O firmware do Giga R1 monta até dois sistemas de ficheiros no arranque:

Flash interna — montada sempre em /flash. Contém main.py e README.txt por defeito; criada no primeiro arranque.
ROMFS — sistema de ficheiros somente de leitura mapeado em memória em /rom, montado automaticamente pelo MicroPython no arranque.

Após a montagem, o directório de trabalho é definido para /flash. O interpretador executa então scripts desse directório:

boot.py é executado em cada reset suave (arranque a frio, Ctrl‑D a partir do REPL, ou sempre que o script em execução termina).
main.py é executado apenas no arranque a frio, imediatamente após boot.py. Os resets suaves subsequentes re‑executam boot.py mas vão directamente ao REPL — para re‑executar main.py é necessário reiniciar completamente a placa.

O main.py padrão fornecido numa placa recém‑instalada faz piscar o canal azul do LED RGB do utilizador como batimento (dois pulsos curtos, pausa curta), para que se possa verificar que o firmware arrancou correctamente sem nenhum anfitrião ligado.

sys.path é estendido para incluir ambos os sistemas de ficheiros e os seus subdirectórios lib/, pelo que os módulos importáveis podem estar em /flash/lib ou /rom/lib.

Quando ligado por USB, /flash também é enumerado como uma unidade de armazenamento de massa USB no anfitrião, permitindo editar boot.py, main.py e quaisquer outros ficheiros directamente. Ejeccte a unidade antes de reiniciar a placa para que o anfitrião descarregue as suas gravações em cache.

Nota

Como o sistema operativo trata a unidade como um dispositivo de bloco passivo, os ficheiros criados ou modificados pelo código em execução na câmara não aparecerão enquanto o anfitrião não remontar a unidade. Se tanto o sistema operativo como a câmara escreverem no mesmo sistema de ficheiros ao mesmo tempo, o sistema operativo prevalecerá e substituirá as alterações feitas pela câmara.

Nota

O canal vermelho do LED RGB do utilizador pode acender brevemente enquanto o anfitrião lê ou escreve na unidade de armazenamento de massa USB — isto é um indicador de actividade gerido pelo firmware, não uma falha.

Tamanhos de armazenamento¶

O Giga R1 é fornecido com:

/flash — sistema de ficheiros FAT de 11 MB, leitura/escrita.
/rom — ROMFS de 4 MB somente de leitura mapeado em memória, utilizado para fornecer scripts e modelos de ML que beneficiam de acesso mmap sem cópia.

Indicador de falha grave¶

Se o LED RGB do utilizador estiver a ciclar rapidamente por todas as cores — rápido o suficiente para parecer um LED branco a cintilar em vez de matizes distintos — o firmware encontrou uma falha grave irrecuperável. Reinstale o firmware para recuperar; se a reinstalação não ajudar, a placa pode estar fisicamente danificada.

Bibliotecas de software¶

Consulte o índice da biblioteca para a lista completa de módulos — incluindo quais são exclusivos da versão Giga R1.