Arduino Giga R1 WiFi¶

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

Para a folha de dados 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 da OpenMV roda apenas no núcleo M7; o núcleo M4 é exposto através do 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/decodificador JPEG por hardware.
Conector flex de câmera compatível com Arducam de 22 pinos (J6) — suporte de driver para os módulos de sensor OV5640 (5MP), OV7670, GC2145, HM01B0 e HM0360.
Conector de display MIPI-DSI (J5) para o Arduino Giga Display Shield (painel de toque capacitivo 480×800) mais um motor de display RGB LTDC para placas portadoras avançadas.
Entrada de áudio de 3,5 mm com line-out estéreo e entrada de microfone.
Wi-Fi b/g/n (2,4 GHz) + Bluetooth LE 5.1 através do módulo Murata 1DX (CYW4343W) — conecta-se à antena fornecida por meio de um conector U.FL embarcado.
USB-C (full-speed) para alimentação / serial / programação.
I/O de usuário nos cabeçalhos no estilo Mega — D0–D75 (digitais), A0–A11 (analógicos), DAC0/DAC1 (saídas DAC), CAN_RX/CAN_TX (FDCAN2) e o par I²C SDA1/SCL1 da fileira interna. Um cabeçalho SPI1 separado de 6 pinos na frente da placa expõe CIPO/COPI/SCK (D89/D90/D91).
JTAG / SWD exposto no cabeçalho de depuração da parte superior para depuração avançada.

Pinagem¶

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 separado de 6 pinos na frente da placa expõe 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 (câmera DCMI VSYNC)
D55	3.3 V	I2C3 SDA (câmera DCMI HSYNC)
D56	3.3 V	TIM3 CH1 / TIM13 CH1 (câmera DCMI PXCLK)
D57	3.3 V	TIM8 CH1N / UART8 RX (clock mestre da câmera — TIM1 CH3)
D58	3.3 V	TIM8 CH3 (câmera DCMI D7)
D59	3.3 V	TIM8 CH2 (câmera DCMI D6)
D60	3.3 V	GPIO (câmera DCMI D5)
D61	3.3 V	TIM8 CH2N / UART4 RX (câmera DCMI D4)
D62	3.3 V	SPI1 SCK (câmera DCMI D3)
D63	3.3 V	TIM5 CH2 / I2C4 SCL (I²C do display)
D64	3.3 V	TIM5 CH1 (câmera DCMI D1)
D65	3.3 V	TIM12 CH2 (câmera DCMI D0)
D66	3.3 V	GPIO (reset da câmera — reservado quando a câmera está ativa)
D67	3.3 V	GPIO (power-down da câmera — reservado quando a câmera está ativa)
D68	3.3 V	TIM3 CH1 / TIM8 CH1 / USART6 TX (RESET DSI do Display Shield)
D69	3.3 V	TIM5 CH4 (TE DSI 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 mic DFSDM do Display Shield)
D74	3.3 V	GPIO (luz de fundo do display — reservado pelo Giga Display Shield)
D75	3.3 V	SPI2 SCK (clock do mic 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 mic da entrada de áudio)
A8	3.3 V	ADC3 IN0 (somente analógico)
A9	3.3 V	ADC3 IN1 (somente analógico)
A10	3.3 V	ADC12 IN1 (somente analógico)
A11	3.3 V	ADC12 IN0 (somente analógico)
DAC0 / A12 / D84	3.3 V	DAC1 OUT1 / ADC12 IN18 (line-out L da entrada de áudio)
DAC1 / A13 / D85	3.3 V	DAC1 OUT2 / TIM2 CH1 / SPI1 SCK / ADC12 IN19 (line-out R da entrada 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 (barramento de toque do display / controle da câmera)
SCL1 / D101	3.3 V	I2C4 SCL (barramento de toque do display / controle da câmera)
RESET	3.3 V	pressione o botão RESET embarcado ou puxe para GND para reiniciar
LED_RED	3.3 V	canal vermelho do LED RGB (ativo em nível baixo)
LED_GREEN	3.3 V	canal verde do LED RGB (ativo em nível baixo)
LED_BLUE	3.3 V	canal azul do LED RGB (ativo em nível baixo)

Nota

A8–A11 são pads somente analógicos nos pinos _C do STM32H747 — eles 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 embarcado.
+5V — trilho de 5 V alimentado pelo USB através de um diodo ou do regulador buck embarcado.
+3V3 — trilho principal de 3,3 V.
IOREF — reflete a tensão de I/O da placa (3,3 V).
AREF — referência de tensão analógica para os pinos do ADC. Padrão de 3,3 V; aplique uma tensão externa para usar uma referência diferente.
OFF — puxe para GND para desligar o trilho de +3,3 V e desligar o sistema.
VRTC — entrada de bateria de moeda de 3,0 V (3,3 V no máximo) que mantém o RTC interno do chip funcionando enquanto o resto da placa está desligado.
GND — terra comum.

A Giga R1 pode ser alimentada por qualquer um destes caminhos:

USB-C — fornece 5 V ao regulador buck embarcado.
Pino VIN — aplique uma alimentação regulada de 6–32 V diretamente.

Dica

Use o estimador de vida útil da bateria para modelar por quanto tempo a Giga R1 funcionará com uma bateria para um determinado ciclo de trabalho ativo / sono profundo.

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

RESET — tanto um pino exposto no cabeçalho de alimentação quanto um botão momentâneo na parte superior da placa, ligado à linha NRST do SoC. Puxe para GND ou pressione o botão para reiniciar.

Se o bootloader estiver completamente ausente, mantenha pressionado o botão BOOT0 enquanto pressiona RESET para forçar o SoC no modo de bootloader da ROM.

Os sinais SWD do STM32 estão expostos no cabeçalho Cortex Debug de 10 pinos com passo de 1,27 mm na frente da placa. Conecte-os através de um SEGGER J-Link, ST-Link ou qualquer sonda JTAG/SWD ARM padrão. Todos os sinais de depuração têm referência de 3,3 V.

Periféricos embarcados¶

LEDs¶

A Giga R1 tem um único LED RGB de usuário, 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 trilho de +3,3 V está ativo e não é controlável pelo usuário.

Conector de câmera (J6)¶

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

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 colorido, até QSXGA (2592 × 1944).
OV7670 — 0,3 MP colorido, até VGA (640 × 480).
GC2145 — 2 MP colorido, até UXGA (1600 × 1200).
HM01B0 — 320 × 320 monocromático.
HM0360 — VGA (640 × 480) monocromático.

Aviso

Enquanto a câmera está inicializada, os seguintes pinos do cabeçalho Mega são reservados pelo firmware e não podem ser usados:

Pino	Motivo
`D54`–`D65`	sinais de dados + sincronização DCMI no conector flex da câmera
`D57`	TIM1 CH3 — clock mestre da câmera
`D66`	GPIO de reset da câmera
`D67`	GPIO de power-down da câmera
`SDA1` / `SCL1`	I²C 4 — compartilhado com a câmera; o barramento é utilizável, mas evite o endereço I²C do sensor

Aprendizado de máquina¶

ml — Aprendizado de Máquina executa modelos TFLite quantizados no Cortex-M7 com kernels CMSIS-NN — rápido o suficiente para detectores compactos a alguns quadros por segundo. Modelos no sistema de arquivos somente leitura /rom carregam diretamente da flash sem copiar para a RAM. Aqui está um detector BlazeFace de 128×128 sobrepondo o rosto detectado e seus seis pontos de referência em cada quadro:

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 do openamp para comunicação entre processadores. O firmware da OpenMV roda somente no M7; o M4 não tem runtime MicroPython próprio, então usá-lo significa compilar uma imagem de firmware C separada e carregá-la do sistema de arquivos via openamp.RemoteProc. Um firmware de exemplo pré-compilado que implementa um endpoint de UART virtual está disponível no repositório openamp_vuart — siga o README dele 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 é melhor tratado como uma demonstração da interface openamp do que como uma plataforma dual-core funcional — o M4 não pode ser reiniciado independentemente do M7, então parar o M4 força uma reinicialização completa do sistema.

Display (J5)¶

J5 é um conector MIPI-DSI para o Arduino Giga Display Shield — um painel de toque capacitivo 480 × 800 construído em torno do driver de painel ST7701 e do controlador de toque GT911. Ambos os drivers vêm congelados com o firmware. Use display — driver de display para enviar framebuffers e gt911.GT911 para entrada de toque.

O exemplo abaixo espelha a câmera em uma janela de display 800 × 480 em modo retrato e sobrepõe cada contato de toque 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 barramento I²C 4 (SDA1/SCL1) que a câmera, D74 para a habilitação da luz de fundo do LCD, D70/D71 para o IRQ e reset de toque do GT911 e D68/D69 para os sinais TE e RESET do painel DSI.

Microfone (Display Shield)¶

O Arduino Giga Display Shield possui um microfone digital ligado ao periférico DFSDM do STM32H747 (clock do mic em D75, dados do mic em D73). O microfone é capturado através de audio — Módulo de Áudio. Cada buffer chega como bytearray PCM de 16 bits com sinal, pronto para alimentar o ulab/numpy para 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)¶

O Arduino Giga Display Shield possui uma IMU de 6 eixos Bosch BMI270 (acelerômetro 3D + giroscópio 3D) no mesmo barramento I²C 4 no endereço 0x68. Use o driver da comunidade micropython_bmi270 para lê-la:

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 completo de registradores está na folha de dados do BMI270.

LED RGB (Display Shield)¶

O Arduino Giga Display Shield possui um LED RGB embarcado acionado por um driver de LED de 3 canais ISSI IS31FL3197 no mesmo barramento I²C 4. O pino AD do driver está ligado a GND, então ele fica no endereço I²C 0x50. Use o driver da comunidade 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 completo de registradores está na folha de dados do IS31FL3197.

Wi-Fi¶

O Murata 1DX (CYW4343W) embarcado é exposto via network — configuração de rede como uma interface de estação. Conecte a antena fornecida ao conector U.FL embarcado antes de ativar 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-se como um periférico e aguarde um central se conectar:

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

GPIO¶

Use machine.Pin para ler ou acionar qualquer um dos pinos serigrafados. As saídas são CMOS de 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 borda:

def handler(pin):
    print("triggered:", pin)

Pin("D3", Pin.IN, Pin.PULL_UP).irq(
    handler, Pin.IRQ_FALLING | Pin.IRQ_RISING,
)

UART¶

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

Barramento	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 Barramento 2 (D20/D21, os SCL/SDA serigrafados) é o barramento Wire padrão da Arduino. O Barramento 4 (SCL1/SDA1) é compartilhado com a câmera e o controlador de toque GT911 do Giga Display Shield — dispositivos de usuário neste barramento devem evitar os seguintes endereços (7 bits):

0x3C — OV5640 / GC2145
0x24 — HM01B0 / HM0360
0x21 — OV7670
0x5D — controlador de toque GT911 (Giga Display Shield)

O mesmo hardware também pode ser usado no 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¶

Barramento	MOSI	MISO	SCK
SPI1	D90	D89	D91
SPI5	D11	D12	D13

O SPI1 é exposto em um cabeçalho dedicado de 6 pinos na frente da placa. O SPI5 é exposto nos rótulos serigrafados COPI/CIPO/SCK em D11/D12/D13.

Nota

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

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

A Giga R1 expõe doze canais ADC de 12 bits em A0–A11, todos com referência de 3,3 V — read_u16 retorna 0–65535 ao longo de 0–3,3 V no pino. A8–A11 são pads _C somente 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 entrada de áudio TRRS de 3,5 mm — quando um headset está conectado, ADC("A7") lê o sinal analógico do microfone diretamente.

DAC¶

Dois canais DAC de 12 bits são expostos em DAC0 e DAC1 através de pyb.DAC. Ambos estão ligados à entrada de áudio TRRS de 3,5 mm como os canais de line-out 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	Timer / 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

Acione qualquer um deles via machine.PWM

from machine import Pin, PWM

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

Aviso

TIM1 é reservado para o clock mestre da câmera quando a câmera é inicializada através de csi — sensores de câmera. Pinos cuja única função PWM está no TIM1 — D1, D10, D11, D12 — não podem ser acionados por PWM enquanto a câmera está ativa. Os outros pinos listados têm alternativas fora do TIM1.

Nota

Vários pinos compartilham canais de timer:

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 consumidor por canal de timer.

Barramentos por software (bit-banged)¶

machine.SoftI2C e machine.SoftSPI funcionam em qualquer GPIO caso você precise de um barramento extra.

Sensor térmico (externo)¶

O firmware inclui o driver fir — driver de sensor térmico (fir == far infrared) para câmeras térmicas conectadas externamente:

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

Conecte o módulo ao barramento I²C da placa e leia os quadros 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 driver fir só se comunica com o sensor pelo I²C 1 — conecte o módulo a D8 (SCL) e D9 (SDA).

Temporização¶

time¶

O módulo time cobre atrasos bloqueantes, ticks monotônicos 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)

Timers virtuais¶

machine.Timer agenda callbacks periódicos ou de disparo único sem consumir um slot de timer de hardware. Passe -1 como id para usar um timer virtual (de 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 estão em milissegundos. Chame deinit() para parar e liberar o slot.

Relógio de tempo real¶

machine.RTC mantém a hora do relógio através de reinicializações — e através de desligamento completo quando uma bateria de moeda está conectada 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 travar. 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ções de boot e runtime¶

Atualização de firmware (DFU)¶

A Giga R1 usa o duplo toque de reset padrão da Arduino para entrar no bootloader da Arduino. Pressione rapidamente o botão RESET duas vezes — a placa é re-enumerada via USB como um dispositivo DFU e a OpenMV IDE pode gravar uma nova imagem de firmware. Se o bootloader estiver completamente ausente, mantenha pressionado o botão BOOT0 enquanto pressiona RESET para forçar o SoC no modo de bootloader da ROM.

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

import machine

machine.bootloader()

Sistema de arquivos e ordem de boot¶

O firmware da Giga R1 monta até dois sistemas de arquivos no boot:

Flash interna — sempre montada em /flash. Contém main.py e README.txt por padrão; criada no primeiro boot.
ROMFS — sistema de arquivos somente leitura, mapeado em memória em /rom, montado automaticamente pelo MicroPython na inicialização.

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

boot.py é executado a cada soft reset (cold boot, Ctrl‑D no REPL ou sempre que o script em execução retorna).
main.py é executado somente no cold boot, imediatamente após boot.py. Soft resets subsequentes reexecutam boot.py mas vão direto para o REPL — para reexecutar main.py você precisa reiniciar completamente a placa.

O main.py padrão fornecido em uma placa recém-gravada apenas pisca o canal azul do LED RGB de usuário como um heartbeat (dois pulsos curtos, intervalo curto), para que você possa saber que o firmware iniciou corretamente sem nenhum host conectado.

O sys.path é estendido para incluir ambos os sistemas de arquivos e seus subdiretórios lib/, então módulos importáveis podem ficar em /flash/lib ou /rom/lib.

Quando conectado via USB, /flash também é enumerado como uma unidade de armazenamento em massa USB no host, permitindo que você edite boot.py, main.py e quaisquer outros arquivos diretamente. Ejete a unidade antes de reiniciar a placa para que o host descarregue suas escritas em cache.

Nota

Como o SO trata a unidade como um dispositivo de bloco passivo, arquivos criados ou modificados por código executando na câmera não aparecerão até que o host remonte a unidade. Se tanto o SO quanto a câmera escreverem no mesmo sistema de arquivos ao mesmo tempo, o SO vencerá e sobrescreverá as alterações feitas pela câmera.

Nota

O canal vermelho do LED RGB de usuário pode acender brevemente enquanto o host está lendo ou escrevendo na unidade de armazenamento em massa USB — este é um indicador de atividade controlado pelo firmware, não uma falha.

Tamanhos de armazenamento¶

A Giga R1 vem com:

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

Indicador de hard fault¶

Se o LED RGB de usuário estiver ciclando rapidamente por todas as cores — rápido o suficiente para tender a parecer um LED branco cintilante em vez de tons distintos — o firmware atingiu um hard fault irrecuperável. Regrave o firmware para recuperar; se a regravaçã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 do build da Giga R1.