Arduino Nano RP2040 Connect

Avvertimento

Questa scheda non è più supportata. L’ultima release del firmware OpenMV per Arduino Nano RP2040 Connect è la 4.7.0. Non verranno rilasciati ulteriori aggiornamenti del firmware, correzioni di bug o nuove funzionalità per questo target. Le informazioni riportate di seguito sono conservate per gli utenti che eseguono la versione 4.7.0 o precedente.

Arduino Nano RP2040 Connect è una scheda di 45 × 18 mm in formato Arduino Nano costruita attorno al Raspberry Pi RP2040 — un dual ARM Cortex‑M0+ che funziona a 133 MHz con 264 KB di SRAM interna. WiFi e BLE provengono da un modulo U‑blox NINA‑W102, e la scheda è dotata di una IMU a 6 assi LSM6DSOX e di un microfono PDM MP34DT06. Il firmware OpenMV pilota tutti questi componenti da MicroPython.

Arduino Nano RP2040 Connect

Per il datasheet completo, le foto e le dimensioni, vedere la pagina del prodotto Arduino Nano RP2040 Connect.

In evidenza

  • Raspberry Pi RP2040 dual ARM Cortex‑M0+ a 133 MHz con 264 KB di SRAM interna.

  • 16 MB di flash QSPI esterna.

  • Modulo U‑blox NINA‑W102 che fornisce Wi‑Fi 2.4 GHz b/g/n e Bluetooth 4.2 (BR/EDR + LE).

  • IMU a 6 assi LSM6DSOX e microfono PDM MP34DT06.

  • Connettore Micro USB per alimentazione, programmazione e una REPL CDC.

  • 22 pin di I/O utente sui connettori standard del Nano — TX/RX, D2–D13 (digitali), A0–A7 (analogici).

Pinout

Pinout di Arduino Nano RP2040 Connect

Riferimento dei pin

Nome del pin

Riferimento

Funzione

TX

3.3 V

UART0 TX / SPI0 RX / I2C0 SDA / PWM0 A

RX

3.3 V

UART0 RX / SPI0 CS / I2C0 SCL / PWM0 B

D2

3.3 V

SPI1 CS / UART1 RX / I2C0 SCL / PWM4 B

D3

3.3 V

SPI1 TX / UART0 RTS / I2C1 SCL / PWM7 B

D4

3.3 V

SPI0 RX / UART0 TX / I2C0 SDA / PWM0 A

D5

3.3 V

SPI0 CS / UART0 RX / I2C0 SCL / PWM0 B

D6

3.3 V

SPI0 SCK / UART0 CTS / I2C1 SDA / PWM1 A

D7

3.3 V

SPI0 TX / UART0 RTS / I2C1 SCL / PWM1 B

D8

3.3 V

SPI0 RX / UART1 TX / I2C0 SDA / PWM2 A

D9

3.3 V

SPI0 CS / UART1 RX / I2C0 SCL / PWM2 B

D10

3.3 V

SPI0 CS / UART1 RX / I2C0 SCL / PWM2 B

D11

3.3 V

SPI0 TX / UART1 RTS / I2C1 SCL / PWM3 B

D12

3.3 V

SPI0 RX / UART1 TX / I2C0 SDA / PWM2 A

D13

3.3 V

SPI0 SCK / UART1 CTS / I2C1 SDA / PWM3 A

D14 / A0

3.3 V

ADC / SPI1 SCK / UART1 CTS / I2C1 SDA / PWM5 A

D15 / A1

3.3 V

ADC / SPI1 TX / UART1 RTS / I2C1 SCL / PWM5 B

D16 / A2

3.3 V

ADC / SPI1 RX / UART0 TX / I2C0 SDA / PWM6 A

D17 / A3

3.3 V

ADC / SPI1 CS / UART0 RX / I2C0 SCL / PWM6 B

D18 / A4 / SDA

3.3 V

ADC / I2C0 SDA / SPI1 RX / UART0 TX / PWM6 A

D19 / A5 / SCL

3.3 V

ADC / I2C0 SCL / SPI1 CS / UART0 RX / PWM6 B

D20 / A6

3.3 V

ADC / GPIO

D21 / A7

3.3 V

ADC / GPIO

RESET

3.3 V

premere il pulsante RESET integrato o portare a GND per effettuare il reset

REC

3.3 V

BOOTSEL — portare a livello alto all’accensione per entrare nel bootloader ROM del RP2040

LED_BUILTIN

—

LED utente arancione su D13

LED_RED

—

Canale rosso del LED RGB

LED_GREEN

—

Canale verde del LED RGB

LED_BLUE

—

Canale blu del LED RGB

Avvertimento

I pin di I/O del Nano RP2040 Connect sono solo 3.3 V — non tollerano i 5 V. Applicare 5 V su di essi danneggerà il RP2040.

Pin di alimentazione

  • VIN — ingresso 4 – 20 V. Alimenta la scheda tramite il regolatore switching integrato. È inoltre alimentato tramite un diodo dalla linea 5 V dell’USB, quindi USB e VIN possono essere presenti contemporaneamente senza retroalimentarsi a vicenda.

  • +5V — non collegato per impostazione predefinita.

  • +3V3 — uscita del regolatore a 3.3 V.

  • AREF — pin di riferimento analogico. Su questa scheda non è collegato al RP2040 — l’ADC è sempre riferito a 3.3 V.

  • GND — massa comune.

Il Nano RP2040 Connect può essere alimentato attraverso entrambe le vie:

  • Micro USB — fornisce 5 V al regolatore integrato.

  • Pin VIN — applicare un’alimentazione regolata di 4 – 20 V.

Nota

Un jumper a saldare sul fondo della scheda collega +5V alla linea 5 V dell’USB. Chiuderlo per fare in modo che il pin del connettore +5V trasporti effettivamente i 5 V.

Nota

Un jumper a saldare normalmente chiuso sull’uscita del regolatore switching 4–20 V integrato può essere tagliato per disabilitare il regolatore, in modo che la scheda possa essere alimentata direttamente da un’alimentazione esterna a 3.3 V su +3V3.

Pin di recovery e debug

  • RESET — sia un pad esposto sia un pulsante RESET momentaneo nella parte superiore della scheda, collegati alla linea NRST del RP2040. Portare a GND o premere il pulsante per effettuare il reset.

  • REC — pad esposto. Tenere REC a livello alto all’accensione (o mentre si preme RESET) mette il RP2040 nel suo bootloader ROM; la scheda si rienumera come unità di archiviazione di massa USB denominata RPI-RP2 e accetta un’immagine firmware .uf2.

Il Nano RP2040 Connect utilizza il doppio tap di reset standard di Arduino per entrare nel bootloader di Arduino. Premere rapidamente il pulsante RESET due volte — la scheda si rienumera tramite USB come dispositivo UF2 e OpenMV IDE può flashare una nuova immagine firmware.

I segnali SWD del RP2040 sono esposti su pad metallizzati sul retro della scheda, appena sotto il modulo NINA. Tutti i segnali di debug sono riferiti a 3.3 V.

Periferiche integrate

LED

Il Nano RP2040 Connect dispone di un LED RGB utente — pilotato attraverso i canali serigrafati LED_RED, LED_GREEN e LED_BLUE — più un LED LED_BUILTIN arancione separato su D13. Tutti e quattro sono controllabili via software tramite machine.LED

from machine import LED

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

Un LED verde separato di alimentazione sulla scheda si accende ogni volta che la linea +3.3 V è attiva e non è controllabile dall’utente.

Sensore della camera

Il firmware OpenMV sul Nano RP2040 Connect supporta il sensore CMOS parallelo OmniVision OV7670. La scheda non ha un sensore di immagine integrato — collegare un modulo OV7670 ai pin serigrafati del connettore elencati di seguito e pilotarlo attraverso il modulo csi — sensori camera

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

Nota

L’OV7670 richiede 14 pin. Il firmware li collega come segue:

Segnale del sensore

Pin del Nano RP2040

D0

D3

D1

D4

D2

D5

D3

D6

D4

D7

D5

D8

D6

D9

D7

D2

HSYNC

A1

VSYNC

A0

PXCLK

A3

MXCLK

A2

POWER

TX

RESET

RX

SCL

SDA (I²C 0)

SDA

SCL (I²C 0)

Il bus di controllo I²C dell’OV7670 è condiviso con la IMU integrata e l’ATECC608A su I²C 0. Il sensore si trova all’indirizzo a 7 bit 0x21 — i dispositivi utente sul bus 0 devono anch’essi evitare questo indirizzo quando la camera è collegata.

IMU

L’accelerometro + giroscopio a 6 assi LSM6DSOX integrato si trova su I2C0. Il machine.I2C(0) della porta rp2 utilizza per impostazione predefinita un set di pin diverso, quindi passare esplicitamente i pad serigrafati SDA/SCL. Utilizzare il driver integrato lsm6dsox.LSM6DSOX

import time
from machine import I2C, Pin
from lsm6dsox import LSM6DSOX

bus = I2C(0, scl=Pin("SCL"), sda=Pin("SDA"))
imu = LSM6DSOX(bus)

while True:
    print(imu.accel())     # (x, y, z) in g
    print(imu.gyro())      # (x, y, z) in deg/s
    time.sleep_ms(100)

Microfono

Il microfono PDM MP34DT06 integrato viene acquisito tramite audio — Modulo Audio utilizzando uno dei blocchi PIO del RP2040:

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

Wi‑Fi

Il modulo NINA‑W102 integrato è esposto tramite network — configurazione di rete come interfaccia station:

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

Lo stesso modulo NINA espone anche il Bluetooth 4.2 LE. Utilizzare aioble — BLE asincrono per il BLE compatibile con asyncio — ad esempio, fare advertising come periferica e attendere che un central si connetta:

import asyncio
import aioble

async def run():
    while True:
        conn = await aioble.advertise(250_000, name="Nano-RP2040")
        print("Connected:", conn.device)
        await conn.disconnected()

asyncio.run(run())

Riferimento dei bus

GPIO

Utilizzare machine.Pin per leggere o pilotare uno qualsiasi dei pin serigrafati. Le uscite sono CMOS a 3.3 V, con un assorbimento totale di 50 mA su tutti i GPIO.

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

Qualsiasi pin di ingresso può anche generare un interrupt sulle transizioni di fronte:

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

UART0

TX

RX

Utilizzare i nomi serigrafati TX/RX con machine.UART

from machine import UART

uart = UART(0, baudrate=115200)
uart.write("hello")
uart.read(5)

Nota

machine.UART(1) esiste ma è riservato al modulo NINA‑W102 integrato (il collegamento BLE); non utilizzarlo direttamente.

I²C

Bus

SDA

SCL

I2C0

SDA / A4

SCL / A5

I2C1

A0

A1

Entrambi i bus richiedono che i loro pin siano passati esplicitamente a machine.I2C

from machine import I2C, Pin

bus0 = I2C(0, scl=Pin("SCL"), sda=Pin("SDA"), freq=400_000)
bus0.scan()

bus1 = I2C(1, scl=Pin("A1"),  sda=Pin("A0"),  freq=400_000)
bus1.scan()

Nota

Due chip integrati condividono il bus 0 — i dispositivi utente su questo bus devono evitare i loro indirizzi:

  • 0x6A — IMU LSM6DSOX

  • 0x60 — ATECC608A‑MAHDA‑T

Utilizzare A0/A1 come I²C li impegna per il bus, quindi non possono fungere contemporaneamente da ingressi ADC.

Nota

I pad SDA / SCL (bus 0) hanno resistenze di pull‑up integrate verso 3.3 V, quindi non sono necessari pull‑up esterni per i dispositivi su quel bus. A0 / A1 (bus 1) non li hanno — aggiungere pull‑up esterni quando si utilizza il bus 1.

Lo stesso hardware può essere utilizzato anche in modalità target (slave) tramite machine.I2CTarget per esporre una regione di memoria a un altro controller I²C:

from machine import I2CTarget

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

SPI

Bus

MOSI

MISO

SCK

CS

SPI0

D11

D12

D13

D10

La porta rp2 non preconfigura i pin di SPI0 su questa scheda, quindi passare esplicitamente i pad serigrafati durante la creazione del bus:

from machine import SPI, Pin

spi = SPI(0, baudrate=10_000_000,
          sck=Pin("D13"), mosi=Pin("D11"), miso=Pin("D12"))
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)

Nota

D13 funge anche da LED arancione LED_BUILTIN — pilotare l’SPI su questo bus farà lampeggiare il LED in sincronia con il clock del bus.

Nota

machine.SPI(1) esiste ma è riservato al modulo NINA‑W102 integrato (il collegamento SPI Wi‑Fi/BLE); non utilizzarlo direttamente.

ADC

Il RP2040 dispone di quattro canali ADC a 12 bit esposti su A0–A3, tutti riferiti a 3.3 V — read_u16 restituisce 0–65535 nell’intervallo 0–3.3 V al pin. Il pin AREF della scheda non è collegato, quindi il riferimento è sempre 3.3 V:

from machine import ADC
import time

adc = ADC("A0")
while True:
    voltage = adc.read_u16() * 3.3 / 65535
    print(voltage)
    time.sleep_ms(100)

PWM

Pin

Slice / canale

TX

PWM0 A

RX

PWM0 B

D2

PWM4 B

D3

PWM7 B

D4

PWM0 A

D5

PWM0 B

D6

PWM1 A

D7

PWM1 B

D8

PWM2 A

D9

PWM2 B

D10

PWM2 B

D11

PWM3 B

D12

PWM2 A

D13

PWM3 A

D14 / A0

PWM5 A

D15 / A1

PWM5 B

D16 / A2

PWM6 A

D17 / A3

PWM6 B

D18 / A4 / SDA

PWM6 A

D19 / A5 / SCL

PWM6 B

Pilotare uno qualsiasi di essi tramite machine.PWM

from machine import Pin, PWM

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

Nota

Diversi pin condividono i canali degli slice PWM:

  • PWM0 A è su TX e D4.

  • PWM0 B è su RX e D5.

  • PWM2 A è su D8 e D12.

  • PWM2 B è su D9 e D10.

  • PWM6 A è su D16/A2 e D18/A4/SDA.

  • PWM6 B è su D17/A3 e D19/A5/SCL.

Scegliere un solo utilizzatore per canale di slice. I canali A e B all’interno dello stesso slice condividono il loro periodo (frequenza) ma ciascuno ha il proprio duty cycle.

Bus software bit‑banged

machine.SoftI2C e machine.SoftSPI funzionano su qualsiasi GPIO se serve un bus aggiuntivo.

Sensore termico (esterno)

Il firmware include il driver fir — driver del sensore termico (fir == far infrared) per un imager termico 8×8 AMG8833 collegato esternamente. Collegare il modulo al bus I²C elencato di seguito, quindi leggere i frame 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())

Il driver fir comunica con il sensore solo tramite I²C 0 — collegare il modulo ai pad serigrafati SCL / SDA. L’indirizzo a 7 bit del sensore (0x69) non deve essere utilizzato da nessun altro dispositivo su quel bus.

Temporizzazione

time

Il modulo time copre i ritardi bloccanti, i tick monotoni e la misurazione del tempo trascorso:

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)

Timer virtuali

machine.Timer pianifica callback periodici o one‑shot senza occupare uno slot di timer hardware. Passare -1 come id per utilizzare un timer virtuale (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"))

I valori del periodo sono in millisecondi. Chiamare deinit() per fermare e rilasciare lo slot.

Orologio in tempo reale

machine.RTC mantiene l’orario reale attraverso i reset. L’RTC del RP2040 è collegato all’oscillatore on‑chip e non sopravvive a una perdita totale di alimentazione — impostare l’orario a ogni avvio a freddo se è importante per la tua applicazione:

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 resetta la scheda se l’applicazione si blocca. Una volta avviato non può essere fermato o riconfigurato — alimentarlo periodicamente all’interno del tuo loop principale:

from machine import WDT

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

Informazioni di boot e runtime

Aggiornamento del firmware (UF2)

Il Nano RP2040 Connect utilizza il doppio tap di reset standard di Arduino per entrare nel bootloader di Arduino. Premere rapidamente il pulsante reset due volte — la scheda si rienumera tramite USB come dispositivo UF2 e OpenMV IDE può flashare una nuova immagine firmware.

Uno script in esecuzione può rientrare nel bootloader su richiesta chiamando machine.bootloader()

import machine

machine.bootloader()

Filesystem e ordine di boot

Il firmware del Nano RP2040 Connect monta un singolo filesystem all’avvio:

  • Flash interna — sempre montata su /flash e utilizzata come directory di lavoro. Contiene per impostazione predefinita main.py e README.txt; creata al primo avvio in assoluto.

Dopo il montaggio, l’interprete esegue quindi gli script da /flash:

  • boot.py viene eseguito a ogni soft reset.

  • main.py viene eseguito solo all’avvio a freddo, immediatamente dopo boot.py.

Il main.py predefinito fornito su una scheda appena flashata si limita a far lampeggiare il canale blu del LED RGB utente come heartbeat (due impulsi brevi, breve pausa), così puoi capire che il firmware si è avviato correttamente senza alcun host collegato.

Quando è connessa tramite USB, /flash viene enumerata come unità di archiviazione di massa USB sull’host, consentendoti di modificare direttamente boot.py, main.py e qualsiasi altro file. Espellere l’unità prima di resettare la scheda in modo che l’host svuoti le scritture memorizzate nella cache.

Nota

Poiché il sistema operativo tratta l’unità come un dispositivo a blocchi passivo, i file creati o modificati dal codice in esecuzione sulla camera non compariranno finché l’host non rimonta l’unità. Se sia il sistema operativo sia la camera scrivono sullo stesso filesystem contemporaneamente, il sistema operativo prevarrà e sovrascriverà le modifiche apportate dalla camera. Utilizzare la scheda SD per qualsiasi dato che lo script scrive, e rimontare prima di leggere quei file dall’host.

Nota

Il canale rosso del LED RGB utente può accendersi brevemente mentre l’host legge o scrive sull’unità di archiviazione di massa USB — questo è un indicatore di attività pilotato dal firmware, non un guasto.

Dimensioni di archiviazione

Il Nano RP2040 Connect viene fornito con:

  • /flash — filesystem FAT da 14 MB, in lettura/scrittura.

La build del Nano RP2040 non include un ROMFS; distribuire i moduli Python e i modelli ML direttamente su /flash.

Librerie software

Consultare l”indice delle librerie per l’elenco completo dei moduli — inclusi quelli esclusivi della build del Nano RP2040 Connect.