Arduino Giga R1 WiFi¶

La Arduino Giga R1 WiFi es una placa de 101 × 53 mm con factor de forma Mega construida en torno al STMicroelectronics STM32H747XI, un SoC de doble núcleo que combina un Cortex‑M7 a 480 MHz con un Cortex‑M4 a 240 MHz. El firmware de OpenMV se ejecuta enteramente en el núcleo M7. La Giga añade un conector flex de cámara Arducam de 22 pines, un conector MIPI‑DSI para el Arduino Giga Display Shield y un conector de audio estéreo de 3,5 mm a la disposición estándar de cabezales Arduino Mega.

Para la hoja de datos completa, fotos y dimensiones, consulta la página del producto Arduino Giga R1 WiFi.

Aspectos destacados¶

STMicroelectronics STM32H747XI con doble Cortex‑M7 (480 MHz) + Cortex‑M4 (240 MHz). El firmware de OpenMV se ejecuta únicamente en el núcleo M7; el núcleo M4 se expone a través de openamp para la comunicación entre procesadores.
8 MB de SDRAM externa además de 2 MB de memoria flash interna y 16 MB de memoria flash QSPI externa.
Codificador/decodificador JPEG por hardware.
Conector flex de cámara compatible con Arducam de 22 pines (J6) — soporte de controladores para los módulos de sensor OV5640 (5MP), OV7670, GC2145, HM01B0 y HM0360.
Conector de pantalla MIPI‑DSI (J5) para el Arduino Giga Display Shield (panel táctil capacitivo de 480×800) más un motor de pantalla LTDC RGB para placas portadoras avanzadas.
Conector de audio de 3,5 mm con salida de línea estéreo y entrada de micrófono.
Wi‑Fi b/g/n (2,4 GHz) + Bluetooth LE 5.1 a través del módulo Murata 1DX (CYW4343W) — se conecta a la antena suministrada mediante un conector U.FL integrado.
USB‑C (full‑speed) para alimentación / serie / programación.
E/S de usuario en los cabezales estilo Mega — D0–D75 (digital), A0–A11 (analógico), DAC0/DAC1 (salidas DAC), CAN_RX/CAN_TX (FDCAN2) y el par I²C SDA1/SCL1 de la fila interior. Un cabezal SPI1 de 6 pines independiente en el frente de la placa expone CIPO/COPI/SCK (D89/D90/D91).
JTAG / SWD expuestos en el cabezal de depuración del lado superior para depuración avanzada.

Pinout¶

Referencia de pines¶

Los cabezales estilo Arduino Mega exponen 76 pines digitales (D0–D75), 12 pines analógicos (A0–A11), dos salidas DAC (DAC0/DAC1), un par I²C secundario (SDA1/SCL1) y un par FDCAN2 (CAN_RX/CAN_TX). Un cabezal SPI1 de 6 pines independiente en el frente de la placa expone CIPO/COPI/SCK (D89/D90/D91).

Nombre del pin	Referencia	Función
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 de la cámara)
D55	3.3 V	I2C3 SDA (DCMI HSYNC de la cámara)
D56	3.3 V	TIM3 CH1 / TIM13 CH1 (DCMI PXCLK de la cámara)
D57	3.3 V	TIM8 CH1N / UART8 RX (reloj maestro de la cámara — TIM1 CH3)
D58	3.3 V	TIM8 CH3 (DCMI D7 de la cámara)
D59	3.3 V	TIM8 CH2 (DCMI D6 de la cámara)
D60	3.3 V	GPIO (DCMI D5 de la cámara)
D61	3.3 V	TIM8 CH2N / UART4 RX (DCMI D4 de la cámara)
D62	3.3 V	SPI1 SCK (DCMI D3 de la cámara)
D63	3.3 V	TIM5 CH2 / I2C4 SCL (I²C de la pantalla)
D64	3.3 V	TIM5 CH1 (DCMI D1 de la cámara)
D65	3.3 V	TIM12 CH2 (DCMI D0 de la cámara)
D66	3.3 V	GPIO (reinicio de la cámara — reservado cuando la cámara está activa)
D67	3.3 V	GPIO (apagado de la cámara — reservado cuando la cámara está activa)
D68	3.3 V	TIM3 CH1 / TIM8 CH1 / USART6 TX (RESET DSI del Display Shield)
D69	3.3 V	TIM5 CH4 (TE DSI del 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 (datos de micrófono DFSDM del Display Shield)
D74	3.3 V	GPIO (retroiluminación de la pantalla — reservado por el Giga Display Shield)
D75	3.3 V	SPI2 SCK (reloj de micrófono DFSDM del 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 micrófono del conector de audio)
A8	3.3 V	ADC3 IN0 (solo analógico)
A9	3.3 V	ADC3 IN1 (solo analógico)
A10	3.3 V	ADC12 IN1 (solo analógico)
A11	3.3 V	ADC12 IN0 (solo analógico)
DAC0 / A12 / D84	3.3 V	DAC1 OUT1 / ADC12 IN18 (salida de línea L del conector de audio)
DAC1 / A13 / D85	3.3 V	DAC1 OUT2 / TIM2 CH1 / SPI1 SCK / ADC12 IN19 (salida de línea R del conector de audio)
D89	3.3 V	SPI1 MISO (`CIPO` en el cabezal SPI frontal)
D90	3.3 V	SPI1 MOSI (`COPI` en el cabezal SPI frontal)
D91	3.3 V	SPI1 SCK (`SCK` en el cabezal 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 control de táctil de pantalla / cámara)
SCL1 / D101	3.3 V	I2C4 SCL (bus de control de táctil de pantalla / cámara)
RESET	3.3 V	pulsa el botón RESET integrado o conecta a GND para reiniciar
LED_RED	3.3 V	canal rojo del LED RGB (activo en bajo)
LED_GREEN	3.3 V	canal verde del LED RGB (activo en bajo)
LED_BLUE	3.3 V	canal azul del LED RGB (activo en bajo)

Nota

A8–A11 son pads solo analógicos en los pines _C del STM32H747; no tienen función GPIO y solo pueden leerse a través del ADC.

Pines de alimentación¶

Pines del cabezal Mega:

VIN — entrada de 6–32 V. Alimenta la placa a través del regulador reductor integrado.
+5V — riel de 5 V alimentado desde USB mediante un diodo o el regulador reductor integrado.
+3V3 — riel principal de 3,3 V.
IOREF — refleja la tensión de E/S de la placa (3,3 V).
AREF — referencia de tensión analógica para los pines del ADC. Por defecto es 3,3 V; aplica una tensión externa para usar una referencia distinta.
OFF — conecta a GND para apagar el riel de +3,3 V y apagar el sistema.
VRTC — entrada de pila de botón de 3,0 V (3,3 V máx.) que mantiene en funcionamiento el RTC del chip mientras el resto de la placa está apagado.
GND — tierra común.

La Giga R1 puede alimentarse a través de cualquiera de estas vías:

USB‑C — suministra 5 V al regulador reductor integrado.
Pin VIN — aplica directamente una fuente regulada de 6–32 V.

Truco

Usa el estimador de duración de batería para modelar cuánto durará la Giga R1 con una batería para un ciclo de trabajo activo / sueño profundo determinado.

Pines de recuperación y depuración¶

RESET — tanto un pin expuesto en el cabezal de alimentación como un pulsador momentáneo en la parte superior de la placa, conectados a la línea NRST del SoC. Conecta a GND o pulsa el botón para reiniciar.

Si el gestor de arranque (bootloader) falta por completo, mantén pulsado el botón BOOT0 mientras pulsas RESET para forzar al SoC al modo de gestor de arranque de ROM.

Las señales SWD del STM32 se exponen en el cabezal de depuración Cortex de 10 pines y 1,27 mm en el frente de la placa. Conéctalas mediante una SEGGER J‑Link, ST‑Link o cualquier sonda JTAG/SWD ARM estándar. Todas las señales de depuración están referenciadas a 3,3 V.

Periféricos integrados¶

LEDs¶

La Giga R1 tiene un único LED RGB de usuario, controlable por software a través de machine.LED:

from machine import LED

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

Un LED de alimentación independiente en la placa se enciende siempre que el riel de +3,3 V está activo y no es controlable por el usuario.

Conector de cámara (J6)¶

J6 es un conector flex de cámara compatible con Arducam de 22 pines. Conecta cualquiera de los módulos de sensor compatibles y el firmware los detecta automáticamente a través del 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 compatibles:

OV5640 — 5 MP a color, hasta QSXGA (2592 × 1944).
OV7670 — 0,3 MP a color, hasta VGA (640 × 480).
GC2145 — 2 MP a color, hasta UXGA (1600 × 1200).
HM01B0 — monocromo de 320 × 320.
HM0360 — monocromo VGA (640 × 480).

Advertencia

Mientras la cámara está inicializada, los siguientes pines del cabezal Mega quedan reservados por el firmware y no pueden usarse:

Pin	Motivo
`D54`–`D65`	señales de datos + sincronización DCMI en el conector flex de la cámara
`D57`	TIM1 CH3 — reloj maestro de la cámara
`D66`	GPIO de reinicio de la cámara
`D67`	GPIO de apagado de la cámara
`SDA1` / `SCL1`	I²C 4 — compartido con la cámara; el bus es utilizable pero evita la dirección I²C del sensor

Aprendizaje automático¶

ml — Aprendizaje automático ejecuta modelos TFLite cuantizados en el Cortex‑M7 con núcleos CMSIS‑NN — lo bastante rápido para detectores compactos a unos pocos fotogramas por segundo. Los modelos en el sistema de archivos de solo lectura /rom se cargan directamente desde la memoria flash sin copiarse a la RAM. Aquí tienes un detector BlazeFace de 128×128 que superpone el rostro detectado y sus seis puntos de referencia en 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¶

El núcleo Cortex‑M4 se expone a través de openamp para la comunicación entre procesadores. El firmware de OpenMV se ejecuta únicamente en el M7; el M4 no tiene un entorno de ejecución de MicroPython propio, por lo que usarlo significa compilar una imagen de firmware C independiente y cargarla desde el sistema de archivos mediante openamp.RemoteProc. En el repositorio openamp_vuart hay disponible un firmware de ejemplo precompilado que implementa un punto final UART virtual — sigue su 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)

En la práctica, conviene tratar este soporte como una demostración de la interfaz openamp en lugar de como una plataforma de doble núcleo funcional — el M4 no puede reiniciarse independientemente del M7, por lo que detener el M4 fuerza un reinicio completo del sistema.

Pantalla (J5)¶

J5 es un conector MIPI‑DSI para el Arduino Giga Display Shield — un panel táctil capacitivo de 480 × 800 construido en torno al controlador de panel ST7701 y el controlador táctil GT911. Ambos controladores se incluyen congelados con el firmware. Usa display — controlador de pantalla para enviar framebuffers y gt911.GT911 para la entrada táctil.

El ejemplo siguiente refleja la cámara en una ventana de pantalla vertical de 800 × 480 y superpone cada contacto táctil como un círculo de color:

import csi
import time
import image
import display
from gt911 import GT911
from machine import I2C

IMG_OFFSET = 80
touch_detected = False
points_colors = ((255, 0, 0), (0, 255, 0), (0, 0, 255),
                 (0, 255, 255), (255, 255, 0))

csi0 = csi.CSI()
csi0.reset()
csi0.pixformat(csi.RGB565)
csi0.framesize(csi.VGA)

lcd = display.DSIDisplay(
    framesize=display.FWVGA,
    portrait=True,
    refresh=60,
    controller=display.ST7701(),
)

# Pass pin names (not Pin objects) so the driver can flip
# the reset pin's direction during start-up.
touch = GT911(
    I2C(4, freq=400_000),
    reset_pin="D71",
    irq_pin="D70",
    touch_points=5,
    refresh_rate=240,
    reverse_x=True,
    touch_callback=lambda pin: globals().update(touch_detected=True),
)

clock = time.clock()
while True:
    clock.tick()
    img = csi0.snapshot()

    if touch_detected:
        n, points = touch.read_points()
        for i in range(n):
            img.draw_circle(
                (points[i][0] - IMG_OFFSET,
                 points[i][1],
                 points[i][2] * 3),
                color=points_colors[points[i][3]],
                thickness=2,
            )
        touch_detected = False

    lcd.write(img, y=IMG_OFFSET, hint=image.TRANSPOSE | image.VFLIP)
    print(clock.fps())

Advertencia

El Giga Display Shield usa el mismo bus I²C 4 (SDA1/SCL1) que la cámara, D74 para la activación de la retroiluminación del LCD, D70/D71 para el IRQ y el reinicio táctil del GT911, y D68/D69 para las señales TE y RESET del panel DSI.

Micrófono (Display Shield)¶

El Arduino Giga Display Shield lleva un micrófono digital conectado al periférico DFSDM del STM32H747 (reloj de micrófono en D75, datos de micrófono en D73). El micrófono se captura a través de audio — Módulo de audio. Cada búfer llega como PCM de 16 bits con signo en un bytearray, listo para alimentar a 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)¶

El Arduino Giga Display Shield lleva una IMU Bosch BMI270 de 6 ejes (acelerómetro 3D + giroscopio 3D) en el mismo bus I²C 4 en la dirección 0x68. Usa el controlador de la comunidad micropython_bmi270 para leerla:

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)

El mapa de registros completo está en la hoja de datos del BMI270.

LED RGB (Display Shield)¶

El Arduino Giga Display Shield lleva un LED RGB integrado controlado por un controlador de LED de 3 canales ISSI IS31FL3197 en el mismo bus I²C 4. El pin AD del controlador está conectado a GND, por lo que reside en la dirección I²C 0x50. Usa el controlador de la comunidad IS31FL3197 para controlar el LED:

from machine import I2C
from is31fl3197 import IS31FL3197

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

El mapa de registros completo está en la hoja de datos del IS31FL3197.

Wi‑Fi¶

El Murata 1DX (CYW4343W) integrado se expone mediante network — configuración de red como interfaz de estación. Conecta la antena suministrada al conector U.FL integrado antes de activar 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¶

El mismo Murata 1DX también expone Bluetooth LE 5.1. Usa aioble — BLE asíncrono para BLE compatible con asyncio — por ejemplo, anúnciate como periférico y espera a que un central se conecte:

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

Referencia de buses¶

GPIO¶

Usa machine.Pin para leer o controlar cualquiera de los pines serigrafiados. Las salidas son CMOS de 3,3 V y pueden absorber/suministrar hasta 20 mA por pin (140 mA en total a través de todo el cabezal).

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

Cualquier pin de entrada también puede disparar una interrupción en las transiciones 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	Nombre 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")

El bus 2 (D20/D21, los SCL/SDA serigrafiados) es el bus Wire predeterminado de Arduino. El bus 4 (SCL1/SDA1) se comparte con la cámara y el controlador táctil GT911 del Giga Display Shield — los dispositivos de usuario en este bus deben evitar las siguientes direcciones (7 bits):

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

El mismo hardware también puede usarse en modo destino (esclavo) a través de machine.I2CTarget para exponer una región de memoria a otro 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

SPI1 se expone en un cabezal dedicado de 6 pines en el frente de la placa. SPI5 se expone en las etiquetas serigrafiadas COPI/CIPO/SCK en D11/D12/D13.

Nota

Pinout del cabezal SPI1 frontal de 6 pines (J7):

Pin	Señal
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 expone doce canales ADC de 12 bits en A0–A11, todos referenciados a 3,3 V — read_u16 devuelve 0–65535 en el rango de 0–3,3 V en el pin. A8–A11 son pads _C solo analógicos sin 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 también está conectado a la entrada de micrófono del conector de audio TRRS de 3,5 mm — cuando se enchufa unos auriculares con micrófono, ADC("A7") lee directamente la señal analógica del micrófono.

DAC¶

Dos canales DAC de 12 bits se exponen en DAC0 y DAC1 a través de pyb.DAC. Ambos están conectados al conector de audio TRRS de 3,5 mm como los canales de salida de línea izquierdo y derecho:

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

Controla cualquiera de ellos mediante machine.PWM:

from machine import Pin, PWM

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

Advertencia

TIM1 se reserva para el reloj maestro de la cámara cuando la cámara se inicializa a través de csi — sensores de cámara. Los pines cuya única función PWM está en TIM1 — D1, D10, D11, D12 — no pueden controlarse por PWM mientras la cámara está activa. Los demás pines listados tienen alternativas que no son de TIM1.

Nota

Varios pines comparten canales de temporizador:

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

Elige un único consumidor por canal de temporizador.

Buses por software (bit‑banging)¶

machine.SoftI2C y machine.SoftSPI funcionan en cualquier GPIO si necesitas un bus adicional.

Sensor térmico (externo)¶

El firmware incluye el controlador fir — controlador de sensor térmico (fir == infrarrojo lejano) para cámaras térmicas cableadas externamente:

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

Conecta el módulo al bus I²C de la placa y lee fotogramas 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())

El controlador fir solo se comunica con el sensor a través de I²C 1 — conecta el módulo a D8 (SCL) y D9 (SDA).

Temporización¶

time¶

El módulo time cubre retardos bloqueantes, ticks monotónicos y medición de tiempo transcurrido:

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

machine.Timer programa funciones de retorno (callbacks) periódicas o de un solo disparo sin consumir una ranura de temporizador hardware. Pasa -1 como id para usar un 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"))

Los valores de periodo están en milisegundos. Llama a deinit() para detener y liberar la ranura.

Reloj en tiempo real¶

machine.RTC mantiene la hora del reloj a través de los reinicios — y a través de un apagado completo cuando hay una pila de botón conectada 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 reinicia la placa si la aplicación se cuelga. Una vez iniciado, no puede detenerse ni reconfigurarse — aliméntalo periódicamente dentro de tu bucle principal:

from machine import WDT

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

Información de arranque y de ejecución¶

Actualización de firmware (DFU)¶

La Giga R1 usa el doble toque de reset estándar de Arduino para entrar en el gestor de arranque (bootloader) de Arduino. Pulsa rápidamente el botón RESET dos veces — la placa se vuelve a enumerar por USB como dispositivo DFU y OpenMV IDE puede grabar una nueva imagen de firmware. Si el gestor de arranque falta por completo, mantén pulsado el botón BOOT0 mientras pulsas RESET para forzar al SoC al modo de gestor de arranque de ROM.

Un script en ejecución puede volver a entrar en el gestor de arranque a demanda llamando a machine.bootloader():

import machine

machine.bootloader()

Sistema de archivos y orden de arranque¶

El firmware de la Giga R1 monta hasta dos sistemas de archivos al arrancar:

Memoria flash interna — siempre montada en /flash. Contiene main.py y README.txt por defecto; se crea en el primer arranque.
ROMFS — sistema de archivos de solo lectura mapeado en memoria en /rom, montado automáticamente por MicroPython al inicio.

Tras el montaje, el directorio de trabajo se establece en /flash. El intérprete ejecuta entonces los scripts de ese directorio:

boot.py se ejecuta en cada reinicio suave (arranque en frío, Ctrl‑D desde el REPL, o cada vez que el script en ejecución finaliza).
main.py se ejecuta solo en el arranque en frío, inmediatamente después de boot.py. Los reinicios suaves posteriores vuelven a ejecutar boot.py pero pasan directamente al REPL — para volver a ejecutar main.py tienes que reiniciar la placa por completo.

El main.py predeterminado que viene en una placa recién grabada simplemente parpadea el canal azul del LED RGB de usuario como latido (dos pulsos cortos, una pausa breve), de modo que puedes saber que el firmware arrancó correctamente sin ningún host conectado.

sys.path se amplía para incluir ambos sistemas de archivos y sus subdirectorios lib/, de modo que los módulos importables pueden residir en /flash/lib o /rom/lib.

Cuando está conectada por USB, /flash también se enumera como una unidad de almacenamiento masivo USB en el host, lo que te permite editar boot.py, main.py y cualquier otro archivo directamente. Expulsa la unidad antes de reiniciar la placa para que el host vacíe sus escrituras en caché.

Nota

Como el sistema operativo trata la unidad como un dispositivo de bloques pasivo, los archivos creados o modificados por el código que se ejecuta en la cámara no aparecerán hasta que el host vuelva a montar la unidad. Si tanto el sistema operativo como la cámara escriben en el mismo sistema de archivos al mismo tiempo, el sistema operativo ganará y sobrescribirá los cambios realizados por la cámara.

Nota

El canal rojo del LED RGB de usuario puede encenderse brevemente mientras el host lee o escribe en la unidad de almacenamiento masivo USB — es un indicador de actividad gestionado por el firmware, no un fallo.

Tamaños de almacenamiento¶

La Giga R1 viene con:

/flash — sistema de archivos FAT de 11 MB, lectura/escritura.
/rom — ROMFS de 4 MB de solo lectura mapeado en memoria, usado para incluir scripts y modelos de ML que se benefician del acceso mmap sin copia.

Indicador de fallo grave (hard fault)¶

Si el LED RGB de usuario está recorriendo rápidamente todos los colores — lo bastante rápido como para parecer un LED blanco parpadeante en lugar de tonos distintos — el firmware ha sufrido un fallo grave irrecuperable. Vuelve a grabar el firmware para recuperarlo; si volver a grabarlo no ayuda, la placa puede estar dañada físicamente.

Bibliotecas de software¶

Consulta el índice de la biblioteca para ver la lista completa de módulos — incluidos los que son exclusivos de la compilación para la Giga R1.