Arduino Giga R1 WiFi¶

Arduino Giga R1 WiFi este o placă de 101 × 53 mm în format Mega construită în jurul cipului STMicroelectronics STM32H747XI — un SoC dual-core care combină un Cortex-M7 la 480 MHz cu un Cortex-M4 la 240 MHz. Firmware-ul OpenMV rulează în întregime pe nucleul M7. Giga adaugă un conector flex pentru cameră Arducam cu 22 de pini, un conector MIPI-DSI pentru Arduino Giga Display Shield și o mufă audio stereo de 3,5 mm la dispunerea standard a headerelor Arduino Mega.

Pentru fișa tehnică completă, fotografii și dimensiuni, consultați pagina de produs Arduino Giga R1 WiFi.

Puncte forte¶

STMicroelectronics STM32H747XI dual Cortex-M7 (480 MHz) + Cortex-M4 (240 MHz). Firmware-ul OpenMV rulează doar pe nucleul M7; nucleul M4 este expus prin openamp pentru comunicarea inter-procesor.
8 MB SDRAM extern plus 2 MB memorie flash internă și 16 MB memorie flash QSPI externă.
Codificator/decodificator JPEG hardware.
Conector flex pentru cameră compatibil Arducam cu 22 de pini (J6) — suport de driver pentru modulele de senzor OV5640 (5MP), OV7670, GC2145, HM01B0 și HM0360.
Conector de afișaj MIPI-DSI (J5) pentru Arduino Giga Display Shield (panou tactil capacitiv 480×800) plus un motor de afișaj LTDC RGB pentru carriere avansate.
Mufă audio de 3,5 mm cu ieșire de linie stereo și intrare de microfon.
Wi-Fi b/g/n (2,4 GHz) + Bluetooth LE 5.1 prin modulul Murata 1DX (CYW4343W) — se conectează la antena furnizată printr-un conector U.FL integrat.
USB-C (full-speed) pentru alimentare / serial / programare.
I/O utilizator pe headerele în stil Mega — D0–D75 (digital), A0–A11 (analogic), DAC0/DAC1 (ieșiri DAC), CAN_RX/CAN_TX (FDCAN2) și perechea I²C SDA1/SCL1 de pe rândul interior. Un header SPI1 separat cu 6 pini de pe partea frontală a plăcii expune CIPO/COPI/SCK (D89/D90/D91).
JTAG / SWD expus pe headerul de depanare de pe partea superioară pentru depanare avansată.

Pinout¶

Referință pini¶

Headerele în stil Arduino Mega expun 76 de pini digitali (D0–D75), 12 pini analogici (A0–A11), două ieșiri DAC (DAC0/DAC1), o pereche I²C secundară (SDA1/SCL1) și o pereche FDCAN2 (CAN_RX/CAN_TX). Un header SPI1 separat cu 6 pini de pe partea frontală a plăcii expune CIPO/COPI/SCK (D89/D90/D91).

Nume pin	Referință	Funcție
D0	3.3 V	USART1 RX (Serial1) / TIM4 CH2
D1	3.3 V	USART1 TX (Serial1) / TIM1 CH2
D2	3.3 V	TIM2 CH4 / TIM5 CH4 / USART2 RX
D3	3.3 V	TIM2 CH3 / TIM5 CH3 / USART2 TX
D4	3.3 V	TIM8 CH1 / UART8 TX
D5	3.3 V	TIM3 CH2 / SPI1 MOSI / SPI6 MOSI
D6	3.3 V	TIM4 CH2
D7	3.3 V	TIM3 CH1 / SPI1 MISO / SPI3 MISO / SPI6 MISO
D8	3.3 V	TIM4 CH3 / I2C1 SCL / I2C4 SCL / UART4 RX
D9	3.3 V	TIM4 CH4 / I2C1 SDA / I2C4 SDA / UART4 TX
D10	3.3 V	TIM1 CH1 / TIM8 CH3N
D11	3.3 V	TIM8 CH2 / SPI5 MOSI
D12	3.3 V	TIM8 CH2N / SPI5 MISO
D13	3.3 V	TIM12 CH1 / SPI5 SCK
D14	3.3 V	USART6 TX (Serial2) / SPI6 MOSI
D15	3.3 V	USART6 RX (Serial2) / TIM3 CH2 / TIM8 CH2
D16	3.3 V	UART4 TX (Serial3) / TIM8 CH1N
D17	3.3 V	UART4 RX (Serial3)
D18	3.3 V	USART2 TX (Serial4)
D19	3.3 V	USART2 RX (Serial4) / SPI3 MOSI
D20	3.3 V	I2C2 SDA / TIM2 CH4 / USART3 RX
D21	3.3 V	I2C2 SCL
D22	3.3 V	GPIO
D23	3.3 V	GPIO / SPI6 SCK
D24	3.3 V	GPIO / SPI6 MISO
D25	3.3 V	GPIO
D26	3.3 V	GPIO
D27	3.3 V	GPIO
D28	3.3 V	GPIO
D29	3.3 V	GPIO
D30	3.3 V	GPIO
D31	3.3 V	GPIO
D32	3.3 V	GPIO
D33	3.3 V	GPIO
D34	3.3 V	GPIO
D35	3.3 V	GPIO
D36	3.3 V	GPIO
D37	3.3 V	TIM8 CH2
D38	3.3 V	TIM8 CH2N
D39	3.3 V	GPIO
D40	3.3 V	TIM15 CH2 / SPI4 MOSI
D41	3.3 V	GPIO
D42	3.3 V	GPIO
D43	3.3 V	GPIO
D44	3.3 V	GPIO
D45	3.3 V	GPIO
D46	3.3 V	TIM8 CH3N
D47	3.3 V	SPI3 MOSI
D48	3.3 V	TIM8 CH3 / SPI5 SCK
D49	3.3 V	GPIO
D50	3.3 V	GPIO
D51	3.3 V	TIM15 CH1 / SPI4 MISO
D52	3.3 V	GPIO
D53	3.3 V	GPIO
D54	3.3 V	TIM8 CH1 (camera DCMI VSYNC)
D55	3.3 V	I2C3 SDA (camera DCMI HSYNC)
D56	3.3 V	TIM3 CH1 / TIM13 CH1 (camera DCMI PXCLK)
D57	3.3 V	TIM8 CH1N / UART8 RX (camera master clock — TIM1 CH3)
D58	3.3 V	TIM8 CH3 (camera DCMI D7)
D59	3.3 V	TIM8 CH2 (camera DCMI D6)
D60	3.3 V	GPIO (camera DCMI D5)
D61	3.3 V	TIM8 CH2N / UART4 RX (camera DCMI D4)
D62	3.3 V	SPI1 SCK (camera DCMI D3)
D63	3.3 V	TIM5 CH2 / I2C4 SCL (display I²C)
D64	3.3 V	TIM5 CH1 (camera DCMI D1)
D65	3.3 V	TIM12 CH2 (camera DCMI D0)
D66	3.3 V	GPIO (camera reset — claimed when camera is active)
D67	3.3 V	GPIO (camera power‑down — claimed when camera is active)
D68	3.3 V	TIM3 CH1 / TIM8 CH1 / USART6 TX (Display Shield DSI RESET)
D69	3.3 V	TIM5 CH4 (Display Shield DSI TE)
D70	3.3 V	SPI2 SCK
D71	3.3 V	TIM8 CH4 / SPI2 MISO
D72	3.3 V	SPI2 MOSI
D73	3.3 V	ADC123 IN11 (Display Shield DFSDM mic data)
D74	3.3 V	GPIO (display backlight — claimed by the Giga Display Shield)
D75	3.3 V	SPI2 SCK (Display Shield DFSDM mic clock)
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 (audio jack mic input)
A8	3.3 V	ADC3 IN0 (analog only)
A9	3.3 V	ADC3 IN1 (analog only)
A10	3.3 V	ADC12 IN1 (analog only)
A11	3.3 V	ADC12 IN0 (analog only)
DAC0 / A12 / D84	3.3 V	DAC1 OUT1 / ADC12 IN18 (audio jack line‑out L)
DAC1 / A13 / D85	3.3 V	DAC1 OUT2 / TIM2 CH1 / SPI1 SCK / ADC12 IN19 (audio jack line‑out R)
D89	3.3 V	SPI1 MISO (`CIPO` pe headerul SPI frontal)
D90	3.3 V	SPI1 MOSI (`COPI` pe headerul SPI frontal)
D91	3.3 V	SPI1 SCK (`SCK` pe headerul 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 (magistrală tactilă afișaj / control cameră)
SCL1 / D101	3.3 V	I2C4 SCL (magistrală tactilă afișaj / control cameră)
RESET	3.3 V	apăsați butonul RESET integrat sau trageți la GND pentru a reseta
LED_RED	3.3 V	canalul roșu al LED-ului RGB (activ pe nivel jos)
LED_GREEN	3.3 V	canalul verde al LED-ului RGB (activ pe nivel jos)
LED_BLUE	3.3 V	canalul albastru al LED-ului RGB (activ pe nivel jos)

Notă

A8–A11 sunt pad-uri exclusiv analogice pe pinii _C ai STM32H747 — nu au funcție GPIO și pot fi citite doar prin ADC.

Pini de alimentare¶

Pini de pe headerul Mega:

VIN — intrare de 6–32 V. Alimentează placa prin regulatorul buck integrat.
+5V — magistrală de 5 V alimentată de la USB printr-o diodă sau de la regulatorul buck integrat.
+3V3 — magistrala principală de 3,3 V.
IOREF — reflectă tensiunea I/O a plăcii (3,3 V).
AREF — referința de tensiune analogică pentru pinii ADC. Implicit 3,3 V; alimentați extern pentru a folosi o referință diferită.
OFF — trageți la GND pentru a opri magistrala de +3,3 V și a închide sistemul.
VRTC — intrare pentru baterie cu celulă-monedă de 3,0 V (3,3 V maxim) care menține RTC-ul on-chip în funcțiune în timp ce restul plăcii este oprit.
GND — masă comună.

Giga R1 poate fi alimentat prin oricare dintre aceste căi:

USB-C — furnizează 5 V regulatorului buck integrat.
Pinul VIN — alimentați direct cu o sursă reglată de 6–32 V.

Sfat

Folosiți estimatorul duratei de viață a bateriei pentru a modela cât timp va funcționa Giga R1 pe baterie pentru un anumit ciclu de lucru activ / somn profund.

Pini de recuperare și depanare¶

RESET — atât un pin expus pe headerul de alimentare, cât și un comutator momentan în partea superioară a plăcii, legate de linia NRST a SoC-ului. Trageți la GND sau apăsați butonul pentru a reseta.

Dacă bootloader-ul lipsește complet, țineți apăsat butonul BOOT0 în timp ce apăsați RESET pentru a forța SoC-ul în modul bootloader ROM.

Semnalele SWD ale STM32 sunt expuse pe headerul Cortex Debug cu 10 pini și pas de 1,27 mm de pe partea frontală a plăcii. Conectați-le printr-un SEGGER J-Link, ST-Link sau orice sondă ARM JTAG/SWD standard. Toate semnalele de depanare sunt referențiate la 3,3 V.

Periferice integrate¶

LED-uri¶

Giga R1 are un singur LED RGB de utilizator, controlabil prin software prin machine.LED

from machine import LED

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

Un LED power separat pe placă se aprinde ori de câte ori magistrala de +3,3 V este activă și nu poate fi controlat de utilizator.

Conector pentru cameră (J6)¶

J6 este un conector flex pentru cameră cu 22 de pini compatibil Arducam. Conectați oricare dintre modulele de senzor acceptate, iar firmware-ul le detectează automat prin modulul csi — senzori de cameră

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

Senzori acceptați:

OV5640 — 5 MP color, până la QSXGA (2592 × 1944).
OV7670 — 0,3 MP color, până la VGA (640 × 480).
GC2145 — 2 MP color, până la UXGA (1600 × 1200).
HM01B0 — 320 × 320 monocrom.
HM0360 — VGA (640 × 480) monocrom.

Atenționare

În timp ce camera este inițializată, următorii pini de pe headerul Mega sunt rezervați de firmware și nu pot fi folosiți:

Pin	Motiv
`D54`–`D65`	Semnale de date + sincronizare DCMI pe conectorul flex al camerei
`D57`	TIM1 CH3 — ceasul principal al camerei
`D66`	GPIO de resetare a camerei
`D67`	GPIO de power-down a camerei
`SDA1` / `SCL1`	I²C 4 — partajat cu camera; magistrala este utilizabilă, dar evitați adresa I²C a senzorului

Învățare automată¶

ml — Învățare automată rulează modele TFLite cuantizate pe Cortex-M7 cu kernel-uri CMSIS-NN — suficient de rapid pentru detectoare compacte la câteva cadre pe secundă. Modelele de pe sistemul de fișiere read-only /rom se încarcă direct din memoria flash, fără copiere în RAM. Iată un detector BlazeFace de 128×128 care suprapune pe fiecare cadru fața detectată și cele șase repere ale sale:

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

Nucleul M4¶

Nucleul Cortex-M4 este expus prin openamp pentru comunicarea inter-procesor. Firmware-ul OpenMV rulează doar pe M7; M4 nu are propriul runtime MicroPython, așa că folosirea lui înseamnă construirea unei imagini de firmware C separate și încărcarea acesteia din sistemul de fișiere prin openamp.RemoteProc. Un firmware de exemplu pre-compilat care implementează un endpoint UART virtual este disponibil în depozitul openamp_vuart — urmați fișierul README al acestuia pentru a compila 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)

În practică, acest suport este cel mai bine tratat ca o demonstrație a interfeței openamp, mai degrabă decât o platformă dual-core funcțională — M4 nu poate fi resetat independent de M7, așa că oprirea M4 forțează o repornire completă a sistemului.

Afișaj (J5)¶

J5 este un conector MIPI-DSI pentru Arduino Giga Display Shield — un panou tactil capacitiv de 480 × 800 construit în jurul driverului de panou ST7701 și al controlerului tactil GT911. Ambele drivere sunt livrate înghețate cu firmware-ul. Folosiți display — driver de afișaj pentru a împinge tampoane de cadre și gt911.GT911 pentru intrarea tactilă.

Exemplul de mai jos oglindește camera într-o fereastră de afișaj portret de 800 × 480 și suprapune fiecare contact tactil sub forma unui cerc colorat:

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

Atenționare

Giga Display Shield folosește aceeași magistrală I²C 4 (SDA1/SCL1) ca și camera, D74 pentru activarea iluminării de fundal a LCD-ului, D70/D71 pentru IRQ-ul și resetarea tactilă GT911 și D68/D69 pentru semnalele TE și RESET ale panoului DSI.

Microfon (Display Shield)¶

Arduino Giga Display Shield include un microfon digital conectat la periferia DFSDM a STM32H747 (ceasul microfonului pe D75, datele microfonului pe D73). Microfonul este capturat prin audio — Modulul Audio. Fiecare tampon ajunge ca PCM pe 16 biți cu semn bytearray, gata de a fi alimentat în ulab/numpy pentru 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)¶

Arduino Giga Display Shield include un IMU Bosch BMI270 cu 6 axe (accelerometru 3D + giroscop 3D) pe aceeași magistrală I²C 4 la adresa 0x68. Folosiți driverul comunitar micropython_bmi270 pentru a-l citi:

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)

Harta completă a registrelor se află în fișa tehnică BMI270.

LED RGB (Display Shield)¶

Arduino Giga Display Shield include un LED RGB integrat condus de un driver LED cu 3 canale ISSI IS31FL3197 pe aceeași magistrală I²C 4. Pinul AD al driverului este legat la GND, deci se află la adresa I²C 0x50. Folosiți driverul comunitar IS31FL3197 pentru a controla LED-ul:

from machine import I2C
from is31fl3197 import IS31FL3197

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

Harta completă a registrelor se află în fișa tehnică IS31FL3197.

Wi-Fi¶

Modulul Murata 1DX (CYW4343W) integrat este expus prin network — configurarea rețelei ca interfață de stație. Conectați antena furnizată la conectorul U.FL integrat înainte de a porni radioul:

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¶

Același modul Murata 1DX expune și Bluetooth LE 5.1. Folosiți aioble — BLE asincron pentru BLE prietenos cu asyncio — de exemplu, faceți reclamă ca periferic și așteptați conectarea unui dispozitiv central:

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

Referință magistrale¶

GPIO¶

Folosiți machine.Pin pentru a citi sau alimenta oricare dintre pinii serigrafiați. Ieșirile sunt CMOS de 3,3 V și pot absorbi/furniza până la 20 mA per pin (140 mA în total pe întregul header).

from machine import Pin

out = Pin("D2", Pin.OUT)
out.on()
out.off()
out.value(1)

inp = Pin("D3", Pin.IN, Pin.PULL_UP)
print(inp.value())

Orice pin de intrare poate, de asemenea, declanșa o întrerupere la tranzițiile de muchie:

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

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

UART¶

Magistrală	TX	RX	Nume 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¶

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

Magistrala 2 (D20/D21, SCL/SDA serigrafiate) este magistrala Wire Arduino implicită. Magistrala 4 (SCL1/SDA1) este partajată cu camera și cu controlerul tactil GT911 al Giga Display Shield — dispozitivele utilizatorului de pe această magistrală trebuie să evite următoarele adrese (pe 7 biți):

0x3C — OV5640 / GC2145
0x24 — HM01B0 / HM0360
0x21 — OV7670
0x5D — controler tactil GT911 (Giga Display Shield)

Același hardware poate fi folosit și în mod țintă (slave) prin machine.I2CTarget pentru a expune o regiune de memorie unui alt controler I²C:

from machine import I2CTarget

buf = bytearray(32)
target = I2CTarget(2, addr=0x42, mem=buf)

SPI¶

Magistrală	MOSI	MISO	SCK
SPI1	D90	D89	D91
SPI5	D11	D12	D13

SPI1 este expus pe un header dedicat cu 6 pini de pe partea frontală a plăcii. SPI5 este expus pe etichetele serigrafiate COPI/CIPO/SCK de pe D11/D12/D13.

Notă

Pinout-ul headerului frontal SPI1 cu 6 pini (J7):

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

Magistrală	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¶

Giga R1 expune douăsprezece canale ADC pe 12 biți pe A0–A11, toate referențiate la 3,3 V — read_u16 returnează 0–65535 pentru 0–3,3 V la pin. A8–A11 sunt pad-uri _C exclusiv analogice, fără periferic 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)

Notă

A7 este, de asemenea, conectat la intrarea de microfon de pe mufa audio TRRS de 3,5 mm — când este conectat un căști-microfon, ADC("A7") citește direct semnalul analogic al microfonului.

DAC¶

Două canale DAC pe 12 biți sunt expuse pe DAC0 și DAC1 prin pyb.DAC. Ambele sunt conectate la mufa audio TRRS de 3,5 mm ca fiind canalele de ieșire de linie stâng și drept:

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

Alimentați oricare dintre ele prin machine.PWM

from machine import Pin, PWM

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

Atenționare

TIM1 este rezervat pentru ceasul principal al camerei atunci când camera este inițializată prin csi — senzori de cameră. Pinii a căror singură funcție PWM este pe TIM1 — D1, D10, D11, D12 — nu pot fi acționați prin PWM în timp ce camera este activă. Ceilalți pini enumerați au toți alternative care nu sunt pe TIM1.

Notă

Mai mulți pini partajează canale de temporizator:

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

Alegeți un singur consumator per canal de temporizator.

Magistrale software bit-banged¶

machine.SoftI2C și machine.SoftSPI funcționează pe orice GPIO dacă aveți nevoie de o magistrală suplimentară.

Senzor termic (extern plăcii)¶

Firmware-ul include driverul fir — driver pentru senzori termici (fir == far infrared) pentru imagistice termice conectate extern:

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

Conectați modulul la magistrala I²C a plăcii și citiți cadre cu 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())

Driverul fir comunică cu senzorul doar prin I²C 1 — conectați modulul la D8 (SCL) și D9 (SDA).

Temporizare¶

time¶

Modulul time acoperă întârzieri blocante, tick-uri monotone și măsurarea timpului scurs:

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)

Temporizatoare virtuale¶

machine.Timer programează funcții de retroapelare (callback) periodice sau cu o singură execuție fără a consuma un slot de temporizator hardware. Transmiteți -1 ca id pentru a folosi un temporizator virtual (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"))

Valorile perioadei sunt în milisecunde. Apelați deinit() pentru a opri și elibera slotul.

Ceas în timp real¶

machine.RTC menține ora de perete între resetări — și pe parcursul opririi complete când o celulă-monedă este conectată la pinul 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 resetează placa dacă aplicația se blochează. Odată pornit, nu poate fi oprit sau reconfigurat — hrăniți-l periodic în interiorul buclei principale:

from machine import WDT

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

Informații despre boot și runtime¶

Actualizare firmware (DFU)¶

Giga R1 folosește resetarea prin dublă apăsare standard Arduino pentru a intra în bootloader-ul Arduino. Apăsați rapid butonul RESET de două ori — placa se re-enumeră prin USB ca dispozitiv DFU și OpenMV IDE poate scrie o nouă imagine de firmware. Dacă bootloader-ul lipsește complet, țineți apăsat butonul BOOT0 în timp ce apăsați RESET pentru a forța SoC-ul în modul bootloader ROM.

Un script în execuție poate re-intra în bootloader la cerere apelând machine.bootloader()

import machine

machine.bootloader()

Sistem de fișiere și ordinea de boot¶

Firmware-ul Giga R1 montează până la două sisteme de fișiere la pornire:

Memoria flash internă — întotdeauna montată la /flash. Conține implicit main.py și README.txt; create la prima pornire.
ROMFS — sistem de fișiere read-only, memory-mapped la /rom montat automat de MicroPython la pornire.

După montare, directorul de lucru este setat la /flash. Interpretorul rulează apoi scripturi din acel director:

boot.py este executat la fiecare resetare soft (cold boot, Ctrl‑D din REPL sau ori de câte ori scriptul în execuție revine).
main.py este executat doar la cold boot, imediat după boot.py. Resetările soft ulterioare re-execută boot.py dar trec direct la REPL — pentru a re-executa main.py trebuie să resetați complet placa.

Fișierul main.py implicit livrat pe o placă proaspăt scrisă doar clipește canalul albastru al LED-ului RGB de utilizator ca un puls de viață (două impulsuri scurte, pauză scurtă), astfel încât să puteți spune că firmware-ul a pornit curat fără niciun host atașat.

sys.path este extins pentru a include ambele sisteme de fișiere și subdirectoarele lor lib/, astfel încât modulele importabile pot exista în /flash/lib sau /rom/lib.

Când este conectat prin USB, /flash se enumeră de asemenea ca o unitate de stocare în masă USB pe host, permițându-vă să editați direct boot.py, main.py și orice alte fișiere. Ejectați unitatea înainte de a reseta placa astfel încât host-ul să golească scrierile sale stocate în cache.

Notă

Deoarece sistemul de operare tratează unitatea ca un dispozitiv de blocuri pasiv, fișierele create sau modificate de codul care rulează pe cameră nu vor apărea până când host-ul nu re-montează unitatea. Dacă atât sistemul de operare, cât și camera scriu pe același sistem de fișiere în același timp, sistemul de operare va câștiga și va suprascrie modificările făcute de cameră.

Notă

Canalul roșu al LED-ului RGB de utilizator se poate aprinde scurt în timp ce host-ul citește de pe sau scrie pe unitatea de stocare în masă USB — acesta este un indicator de activitate condus de firmware, nu o defecțiune.

Dimensiuni de stocare¶

Giga R1 este livrat cu:

/flash — sistem de fișiere FAT de 11 MB, citire/scriere.
/rom — ROMFS memory-mapped read-only de 4 MB, folosit pentru a livra scripturi și modele ML care beneficiază de acces mmap zero-copy.

Indicator de hard-fault¶

Dacă LED-ul RGB de utilizator parcurge rapid toate culorile — suficient de rapid încât tinde să arate ca un LED alb licăritor mai degrabă decât nuanțe distincte — firmware-ul a întâlnit un hard fault nerecuperabil. Rescrieți firmware-ul pentru a recupera; dacă rescrierea nu ajută, placa poate fi deteriorată fizic.

Biblioteci software¶

Consultați indexul de biblioteci pentru lista completă de module — inclusiv care dintre ele sunt unice pentru build-ul Giga R1.