Arduino Nano RP2040 Connect

Atenționare

Această placă nu mai este acceptată. Ultima versiune de firmware OpenMV pentru Arduino Nano RP2040 Connect este 4.7.0. Nu vor mai fi lansate actualizări de firmware, corecții de erori sau funcții noi pentru acest target. Informațiile de mai jos sunt păstrate pentru utilizatorii care rulează 4.7.0 sau o versiune anterioară.

Arduino Nano RP2040 Connect este o placă de 45 × 18 mm în formatul Arduino Nano, construită în jurul Raspberry Pi RP2040 — un procesor dual ARM Cortex‑M0+ care rulează la 133 MHz cu 264 KB de SRAM intern. WiFi și BLE provin de la un modul U‑blox NINA‑W102, iar placa include un IMU LSM6DSOX cu 6 axe și un microfon PDM MP34DT06. Firmware-ul OpenMV controlează toate acestea din MicroPython.

Arduino Nano RP2040 Connect

Pentru fișa tehnică completă, fotografii și dimensiuni, consultați pagina de produs Arduino Nano RP2040 Connect.

Caracteristici principale

  • Raspberry Pi RP2040 dual ARM Cortex‑M0+ la 133 MHz cu 264 KB SRAM intern.

  • 16 MB memorie flash QSPI externă.

  • Modul U‑blox NINA‑W102 care oferă Wi‑Fi 2.4 GHz b/g/n și Bluetooth 4.2 (BR/EDR + LE).

  • IMU cu 6 axe LSM6DSOX și microfon PDM MP34DT06.

  • Conector Micro USB pentru alimentare, programare și un REPL CDC.

  • 22 de pini I/O de utilizator pe headerele standard Nano — TX/RX, D2–D13 (digitali), A0–A7 (analogici).

Pinout

Pinout Arduino Nano RP2040 Connect

Referință pini

Nume pin

Referință

Funcție

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

apăsați butonul RESET de pe placă sau conectați la GND pentru a reseta

REC

3.3 V

BOOTSEL — conectați la nivel logic înalt la pornire pentru a intra în bootloaderul ROM al RP2040

LED_BUILTIN

—

LED de utilizator portocaliu pe D13

LED_RED

—

Canalul roșu al LED-ului RGB

LED_GREEN

—

Canalul verde al LED-ului RGB

LED_BLUE

—

Canalul albastru al LED-ului RGB

Atenționare

Pinii I/O ai plăcii Nano RP2040 Connect sunt doar de 3.3 V — nu tolerează 5 V. Aplicarea a 5 V pe ei va deteriora RP2040.

Pini de alimentare

  • VIN — intrare 4 – 20 V. Alimentează placa prin regulatorul switching de pe placă. Este de asemenea alimentat printr-o diodă de la linia de 5 V a USB, astfel încât USB și VIN pot fi prezente în același timp fără a se alimenta reciproc înapoi.

  • +5V — neconectat în mod implicit.

  • +3V3 — ieșirea regulatorului de 3.3 V.

  • AREF — pin de referință analogică. Nu este conectat la RP2040 pe această placă — ADC-ul este întotdeauna raportat la 3.3 V.

  • GND — masă comună.

Placa Nano RP2040 Connect poate fi alimentată pe oricare dintre căi:

  • Micro USB — furnizează 5 V regulatorului de pe placă.

  • Pin VIN — alimentați cu o sursă reglată de 4 – 20 V.

Notă

Un jumper de lipire de pe partea inferioară a plăcii face puntea între +5V și linia de 5 V a USB. Închideți-l pentru ca pinul header +5V să transporte efectiv 5 V.

Notă

Un jumper de lipire normal-închis de pe ieșirea regulatorului switching de 4–20 V de pe placă poate fi tăiat pentru a dezactiva regulatorul, astfel încât placa să poată fi alimentată direct dintr-o sursă externă de 3.3 V pe +3V3.

Pini de recuperare și depanare

  • RESET — atât un pad expus, cât și un buton RESET momentan în partea de sus a plăcii, conectat la linia NRST a RP2040. Conectați la GND sau apăsați butonul pentru a reseta.

  • REC — pad expus. Menținerea REC la nivel logic înalt la pornire (sau în timp ce apăsați RESET) pune RP2040 în bootloaderul său ROM; placa se reenumerează ca o unitate de stocare USB numită RPI-RP2 și acceptă o imagine de firmware .uf2.

Placa Nano RP2040 Connect utilizează resetarea standard prin dublu apăs a Arduino pentru a intra în bootloaderul Arduino. Apăsați rapid butonul RESET de două ori — placa se reenumerează prin USB ca dispozitiv UF2 și OpenMV IDE poate scrie o nouă imagine de firmware.

Semnalele SWD ale RP2040 sunt expuse pe pad-uri placate cu metal pe spatele plăcii, chiar sub modulul NINA. Toate semnalele de depanare sunt raportate la 3.3 V.

Periferice de pe placă

LED-uri

Placa Nano RP2040 Connect are un LED RGB de utilizator — controlat prin canalele serigrafiate LED_RED, LED_GREEN și LED_BLUE — plus un LED portocaliu separat LED_BUILTIN pe D13. Toate cele patru pot fi controlate prin software prin 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 separat de alimentare de pe placă se aprinde ori de câte ori linia de +3.3 V este activă și nu poate fi controlat de utilizator.

Senzor cameră

Firmware-ul OpenMV de pe placa Nano RP2040 Connect acceptă senzorul CMOS paralel OmniVision OV7670. Placa nu are senzor de imagine pe placă — conectați un modul OV7670 la pinii header serigrafiați listați mai jos și controlați-l 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()

Notă

OV7670 ocupă 14 pini. Firmware-ul îi conectează astfel:

Semnal senzor

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

Magistrala de control I²C a OV7670 este partajată cu IMU-ul de pe placă și cu ATECC608A pe I²C 0. Senzorul se află la adresa pe 7 biți 0x21 — dispozitivele de utilizator de pe magistrala 0 trebuie de asemenea să evite această adresă atunci când camera este conectată.

IMU

Accelerometrul + giroscopul cu 6 axe LSM6DSOX de pe placă se află pe I2C0. machine.I2C(0) al portului rp2 folosește în mod implicit un set diferit de pini, așa că transmiteți explicit pad-urile serigrafiate SDA/SCL. Folosiți driverul integrat 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)

Microfon

Microfonul PDM MP34DT06 de pe placă este captat prin audio — Modulul Audio folosind unul dintre blocurile PIO ale 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

Modulul NINA‑W102 de pe placă este expus prin network — configurarea rețelei ca interfață de tip 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

Același modul NINA expune de asemenea Bluetooth 4.2 LE. Folosiți aioble — BLE asincron pentru BLE compatibil cu asyncio — de exemplu, publicați placa ca periferic și așteptați conectarea unui central:

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

Referință magistrale

GPIO

Folosiți machine.Pin pentru a citi sau a controla oricare dintre pinii serigrafiați. Ieșirile sunt CMOS de 3.3 V, cu absorbție totală de 50 mA pe toate GPIO-urile.

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

UART0

TX

RX

Folosiți numele serigrafiate TX/RX cu machine.UART

from machine import UART

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

Notă

machine.UART(1) există, dar este rezervat pentru modulul NINA‑W102 de pe placă (legătura BLE); nu îl folosiți direct.

I²C

Magistrală

SDA

SCL

I2C0

SDA / A4

SCL / A5

I2C1

A0

A1

Ambele magistrale au nevoie ca pinii lor să fie transmiși explicit către 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()

Notă

Două cipuri de pe placă partajează magistrala 0 — dispozitivele de utilizator de pe această magistrală trebuie să evite adresele lor:

  • 0x6A — IMU LSM6DSOX

  • 0x60 — ATECC608A‑MAHDA‑T

Folosirea A0/A1 ca I²C le ocupă pentru magistrală, astfel încât nu pot fi în același timp intrări ADC.

Notă

Pad-urile SDA / SCL (magistrala 0) au rezistențe pull-up pe placă către 3.3 V, deci nu sunt necesare pull-up-uri externe pentru dispozitivele de pe acea magistrală. A0 / A1 (magistrala 1) nu le au — adăugați pull-up-uri externe când folosiți magistrala 1.

Același hardware poate fi de asemenea folosit în mod target (slave) prin machine.I2CTarget pentru a expune o regiune de memorie către un alt controler I²C:

from machine import I2CTarget

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

SPI

Magistrală

MOSI

MISO

SCK

CS

SPI0

D11

D12

D13

D10

Portul rp2 nu preconfigurează pinii SPI0 pe această placă, așa că transmiteți explicit pad-urile serigrafiate la crearea magistralei:

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)

Notă

D13 servește și ca LED portocaliu LED_BUILTIN — controlul SPI pe această magistrală va face LED-ul să clipească în ritmul ceasului magistralei.

Notă

machine.SPI(1) există, dar este rezervat pentru modulul NINA‑W102 de pe placă (legătura SPI Wi-Fi/BLE); nu îl folosiți direct.

ADC

RP2040 are patru canale ADC pe 12 biți expuse pe A0–A3, toate raportate la 3.3 V — read_u16 returnează 0–65535 pe intervalul 0–3.3 V la pin. Pinul AREF al plăcii nu este conectat, deci referința este întotdeauna 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 / canal

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

Controlați oricare dintre ele prin machine.PWM

from machine import Pin, PWM

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

Notă

Mai mulți pini partajează canale de slice PWM:

  • PWM0 A se află pe TX și D4.

  • PWM0 B se află pe RX și D5.

  • PWM2 A se află pe D8 și D12.

  • PWM2 B se află pe D9 și D10.

  • PWM6 A se află pe D16/A2 și D18/A4/SDA.

  • PWM6 B se află pe D17/A3 și D19/A5/SCL.

Alegeți un singur consumator pe canal de slice. Canalele A și B din cadrul aceluiași slice partajează perioada (frecvența), dar fiecare are propriul ciclu de funcționare.

Magistrale emulate software (bit‑banged)

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

Senzor termic (extern)

Firmware-ul include driverul fir — driver pentru senzori termici (fir == far infrared) pentru un imager termic AMG8833 8×8 conectat extern. Conectați modulul la magistrala I²C listată mai jos, apoi 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 0 — conectați modulul la pad-urile serigrafiate SCL / SDA. Adresa pe 7 biți a senzorului (0x69) nu trebuie folosită de niciun alt dispozitiv de pe acea magistrală.

Sincronizare

time

Modulul time acoperă întârzierile blocante, ticurile 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 unice 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 exprimate în milisecunde. Apelați deinit() pentru a opri și a elibera slotul.

Ceas în timp real

machine.RTC păstrează ora de perete între resetări. RTC-ul RP2040 este legat de oscilatorul de pe cip și nu supraviețuiește unei pierderi totale de alimentare — setați ora la fiecare pornire la rece dacă acest lucru contează pentru aplicația dvs.:

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 — alimentaț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 execuție

Actualizare firmware (UF2)

Placa Nano RP2040 Connect utilizează resetarea standard prin dublu apăs a Arduino pentru a intra în bootloaderul Arduino. Apăsați rapid butonul de resetare de două ori — placa se reenumerează prin USB ca dispozitiv UF2 și OpenMV IDE poate scrie o nouă imagine de firmware.

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

import machine

machine.bootloader()

Sistem de fișiere și ordinea de boot

Firmware-ul Nano RP2040 Connect montează un singur sistem de fișiere la boot:

  • Memoria flash internă — întotdeauna montată la /flash și folosită ca director de lucru. Conține în mod implicit main.py și README.txt; creată la prima pornire.

După montare, interpretorul rulează apoi scripturile din /flash:

  • boot.py este executat la fiecare resetare soft.

  • main.py este executat doar la pornirea la rece, imediat după boot.py.

Fișierul main.py implicit livrat pe o placă proaspăt programată doar face să clipească canalul albastru al LED-ului RGB de utilizator ca un puls de stare (două impulsuri scurte, pauză scurtă), astfel încât să puteți observa că firmware-ul a pornit corect fără niciun host conectat.

Când este conectat prin USB, /flash se enumeră ca o unitate de stocare 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 pentru ca host-ul să golească scrierile sale din cache.

Notă

Deoarece sistemul de operare tratează unitatea ca un dispozitiv bloc pasiv, fișierele create sau modificate de codul care rulează pe cameră nu vor apărea decât după ce host-ul remontează unitatea. Dacă atât sistemul de operare, cât și camera scriu 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ă. Folosiți cardul SD pentru orice date pe care scriptul le scrie înapoi și remontați înainte de a citi acele fișiere de pe host.

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 USB — acesta este un indicator de activitate controlat de firmware, nu o defecțiune.

Dimensiuni de stocare

Placa Nano RP2040 Connect este livrată cu:

  • /flash — sistem de fișiere FAT de 14 MB, citire/scriere.

Build-ul Nano RP2040 nu include un ROMFS; livrați modulele Python și modelele ML direct pe /flash.

Biblioteci software

Consultați indexul bibliotecii pentru lista completă de module — inclusiv cele care sunt specifice build-ului Nano RP2040 Connect.