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.

Arduino Giga R1 WiFi

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#

Arduino Giga R1 WiFi Pinout

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.

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.

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.