Arduino Nano RP2040 Connect

Figyelem

Ez a panel már nem támogatott. Az Arduino Nano RP2040 Connecthez kiadott utolsó OpenMV firmware a 4.7.0. Ehhez a célhoz nem jelenik meg több firmware-frissítés, hibajavítás vagy új funkció. Az alábbi információkat a 4.7.0-s vagy korábbi verziót használók kedvéért őriztük meg.

Az Arduino Nano RP2040 Connect egy 45 × 18 mm-es, Arduino-Nano-formátumú panel, amely a Raspberry Pi RP2040 köré épül — ez egy 133 MHz-en futó, kétmagos ARM Cortex-M0+ processzor 264 KB belső SRAM-mal. A WiFi és a BLE egy U-blox NINA-W102 modultól származik, a panel pedig egy LSM6DSOX 6 tengelyű IMU-t és egy MP34DT06 PDM mikrofont hordoz. Az OpenMV firmware mindezeket MicroPythonból vezérli.

Arduino Nano RP2040 Connect

A teljes adatlapért, fényképekért és méretekért lásd az Arduino Nano RP2040 Connect termékoldalt.

Kiemelt jellemzők

  • Raspberry Pi RP2040 kétmagos ARM Cortex-M0+ 133 MHz-en, 264 KB belső SRAM-mal.

  • 16 MB külső QSPI flash memória.

  • U-blox NINA-W102 modul, amely 2,4 GHz-es Wi-Fi b/g/n és Bluetooth 4.2 (BR/EDR + LE) kapcsolatot biztosít.

  • LSM6DSOX 6 tengelyű IMU és MP34DT06 PDM mikrofon.

  • Micro USB csatlakozó a tápellátáshoz, programozáshoz és a CDC REPL-hez.

  • 22 felhasználói I/O láb a szabványos Nano fejléceken — TX/RX, D2–D13 (digitális), A0–A7 (analóg).

Lábkiosztás

Arduino Nano RP2040 Connect lábkiosztása

Láb-referencia

Láb neve

Referencia

Funkció

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

nyomd meg a panelen lévő RESET gombot, vagy húzd GND-re a visszaállításhoz

REC

3.3 V

BOOTSEL — bekapcsoláskor húzd magasra az RP2040 ROM rendszerbetöltőjébe lépéshez

LED_BUILTIN

—

Narancssárga felhasználói LED a D13 lábon

LED_RED

—

Az RGB LED piros csatornája

LED_GREEN

—

Az RGB LED zöld csatornája

LED_BLUE

—

Az RGB LED kék csatornája

Figyelem

A Nano RP2040 Connect I/O lábai kizárólag 3,3 V-osak — nem 5 V-tűrők. 5 V rájuk kapcsolása károsítja az RP2040-et.

Tápláblak

  • VIN — 4 – 20 V bemenet. A panelt a beépített kapcsolóüzemű szabályozón keresztül táplálja. Egy diódán át az USB 5 V-os sínjéről is kap táplálást, így az USB és a VIN egyszerre is jelen lehet anélkül, hogy visszatáplálnák egymást.

  • +5V — alapértelmezetten nincs bekötve.

  • +3V3 — a 3,3 V-os szabályozó kimenete.

  • AREF — analóg referencialáb. Ezen a panelen nincs az RP2040-hez kötve — az ADC mindig a 3,3 V-hoz van viszonyítva.

  • GND — közös föld.

A Nano RP2040 Connect bármelyik útvonalon táplálható:

  • Micro USB — 5 V-ot ad a beépített szabályozónak.

  • VIN láb — szabályozott 4 – 20 V-os tápforrással hajtsd meg.

Megjegyzés

A panel alján egy forrasztással záródó áthidalás köti a +5V lábat az USB 5 V-os sínjéhez. Zárd le, hogy a +5V fejlécláb ténylegesen 5 V-ot vezessen.

Megjegyzés

A beépített 4–20 V-os kapcsolóüzemű szabályozó kimenetén lévő, alaphelyzetben zárt forrasztott áthidalás elvágható a szabályozó kikapcsolásához, így a panel közvetlenül egy külső 3,3 V-os tápforrásról is táplálható a +3V3 lábon.

Helyreállító és hibakereső lábak

  • RESET — egy kivezetett pad és egy pillanatkapcsoló RESET gomb a panel tetején, amely az RP2040 NRST vonalához van kötve. Húzd GND-re vagy nyomd meg a gombot a visszaállításhoz.

  • REC — kivezetett pad. A REC magasan tartása bekapcsoláskor (vagy a RESET megnyomása közben) az RP2040-et a ROM rendszerbetöltőjébe viszi; a panel RPI-RP2 nevű USB-háttértárként újraregisztrál, és elfogad egy .uf2 firmware-képet.

A Nano RP2040 Connect az Arduino szabványos dupla koppintásos visszaállítását használja az Arduino rendszerbetöltőjébe lépéshez. Nyomd meg gyorsan kétszer a RESET gombot — a panel UF2 eszközként újraregisztrál az USB-n, és az OpenMV IDE új firmware-képet flashelhet.

Az RP2040 SWD jelei a panel hátoldalán, közvetlenül a NINA modul alatt lévő bevont padokon érhetők el. Minden hibakereső jel 3,3 V-hoz viszonyított.

Beépített perifériák

LED-ek

A Nano RP2040 Connect rendelkezik egy felhasználói RGB LED-del — a szitanyomott LED_RED, LED_GREEN és LED_BLUE csatornákon keresztül vezérelve — valamint egy külön narancssárga LED_BUILTIN LED-del a D13 lábon. Mind a négy szoftveresen vezérelhető a machine.LED segítségével:

from machine import LED

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

A panelen lévő külön zöld tápellátás LED mindig világít, amíg a +3,3 V-os sín él, és nem vezérelhető a felhasználó által.

Kameraérzékelő

A Nano RP2040 Connecten futó OpenMV firmware támogatja az OmniVision OV7670 párhuzamos CMOS érzékelőt. A panelen nincs beépített képérzékelő — kösd be egy OV7670 modult az alább felsorolt szitanyomott fejléclábakhoz, és vezéreld a csi — kameraérzékelők modulon keresztül:

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

Megjegyzés

Az OV7670 14 lábat igényel. A firmware a következőképpen köti be őket:

Érzékelő jele

Nano RP2040 láb

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)

Az OV7670 I²C vezérlőbusza meg van osztva a beépített IMU-val és az ATECC608A-val az I²C 0-n. Az érzékelő a 0x21 7 bites címen helyezkedik el — a 0-s buszon lévő felhasználói eszközöknek is el kell kerülniük ezt a címet, ha a kamera be van kötve.

IMU

A beépített LSM6DSOX 6 tengelyű gyorsulásmérő + giroszkóp az I2C0-n helyezkedik el. Az rp2 port machine.I2C(0) alapértelmezetten egy másik lábkészletre mutat, ezért add át kifejezetten a szitanyomott SDA/SCL padokat. Használd a beágyazott lsm6dsox.LSM6DSOX illesztőprogramot:

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)

Mikrofon

A beépített MP34DT06 PDM mikrofont a audio — Audio modul rögzíti az RP2040 egyik PIO blokkjának használatával:

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

A beépített NINA-W102 modul a network — hálózati konfiguráció modulon keresztül állomás-interfészként érhető el:

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

Ugyanaz a NINA modul Bluetooth 4.2 LE-t is biztosít. Használd a aioble — Aszinkron BLE modult az asyncio-barát BLE-hez — például hirdesd magad perifériaként, és várd, hogy egy központ csatlakozzon:

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

Busz-referencia

GPIO

Használd a machine.Pin osztályt bármelyik szitanyomott láb olvasásához vagy meghajtásához. A kimenetek 3,3 V-os CMOS-ok, összesen 50 mA nyelőárammal az összes GPIO-n.

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

Bármely bemeneti láb megszakítást is kiválthat élátmenetekkor:

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

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

UART

Busz

TX

RX

UART0

TX

RX

Használd a szitanyomott TX/RX neveket a machine.UART osztállyal:

from machine import UART

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

Megjegyzés

A machine.UART(1) létezik, de a beépített NINA-W102 modul (a BLE kapcsolat) számára van fenntartva; ne használd közvetlenül.

I²C

Busz

SDA

SCL

I2C0

SDA / A4

SCL / A5

I2C1

A0

A1

Mindkét buszhoz kifejezetten át kell adni a lábaikat a machine.I2C osztálynak:

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

Megjegyzés

Két beépített chip osztozik a 0-s buszon — az ezen a buszon lévő felhasználói eszközöknek el kell kerülniük a címeiket:

  • 0x6A — LSM6DSOX IMU

  • 0x60 — ATECC608A-MAHDA-T

Az A0/A1 I²C-ként való használata lefoglalja őket a buszhoz, így nem lehetnek egyidejűleg ADC bemenetek is.

Megjegyzés

Az SDA / SCL padok (0-s busz) beépített felhúzó ellenállásokkal rendelkeznek 3,3 V-ra, így nincs szükség külső felhúzókra az adott busz eszközeihez. Az A0 / A1 (1-es busz) nem — adj hozzá külső felhúzókat az 1-es busz használatakor.

Ugyanaz a hardver cél (slave) módban is használható a machine.I2CTarget segítségével, hogy egy memóriaterületet tegyen elérhetővé egy másik I²C vezérlő számára:

from machine import I2CTarget

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

SPI

Busz

MOSI

MISO

SCK

CS

SPI0

D11

D12

D13

D10

Az rp2 port ezen a panelen nem konfigurálja előre az SPI0 lábait, ezért add át kifejezetten a szitanyomott padokat a busz létrehozásakor:

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)

Megjegyzés

A D13 egyúttal a narancssárga LED_BUILTIN is — az SPI meghajtása ezen a buszon a busz órajelével együtt villogtatja a LED-et.

Megjegyzés

A machine.SPI(1) létezik, de a beépített NINA-W102 modul (a Wi-Fi/BLE SPI kapcsolat) számára van fenntartva; ne használd közvetlenül.

ADC

Az RP2040-nek négy 12 bites ADC csatornája van, amelyek az A0–A3 lábakon érhetők el, mindegyik 3,3 V-hoz viszonyított — a read_u16 0–65535 értéket ad vissza a láb 0–3,3 V tartományában. A panel AREF lába nincs bekötve, így a referencia mindig 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

Láb

Szelet / csatorna

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

Hajtsd meg bármelyiket a machine.PWM segítségével:

from machine import Pin, PWM

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

Megjegyzés

Több láb is osztozik PWM-szeletcsatornákon:

  • A PWM0 A a TX és a D4 lábon van.

  • A PWM0 B a RX és a D5 lábon van.

  • A PWM2 A a D8 és a D12 lábon van.

  • A PWM2 B a D9 és a D10 lábon van.

  • A PWM6 A a D16/A2 és a D18/A4/SDA lábon van.

  • A PWM6 B a D17/A3 és a D19/A5/SCL lábon van.

Szeletcsatornánként egy fogyasztót válassz. Ugyanazon szeleten belül az A és B csatorna osztozik a perióduson (frekvencián), de mindegyiknek saját kitöltési tényezője van.

Szoftveresen bitléptetett buszok

A machine.SoftI2C és a machine.SoftSPI bármely GPIO-n működik, ha extra buszra van szükséged.

Hőérzékelő (külső)

A firmware tartalmazza a fir — hőérzékelő-meghajtó (fir == far infrared, távoli infravörös) illesztőprogramot egy külsőleg bekötött AMG8833 8×8-as hőkamerához. Csatlakoztasd a modult az alább felsorolt I²C buszra, majd olvasd a képkockákat a fir.init() + fir.snapshot() hívásokkal:

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

A fir illesztőprogram csak az I²C 0-n keresztül kommunikál az érzékelővel — kösd a modult a szitanyomott SCL / SDA padokhoz. Az érzékelő 7 bites címét (0x69) az adott buszon lévő más eszközök nem használhatják.

Időzítés

time

A time modul lefedi a blokkoló késleltetéseket, a monoton ütemjeleket és az eltelt idő mérését:

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)

Virtuális időzítők

A machine.Timer periodikus vagy egyszeri visszahívásokat ütemez anélkül, hogy hardveres időzítő helyet foglalna el. Add át a -1 értéket azonosítóként virtuális (szoftveres) időzítő használatához:

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

A periódusértékek milliszekundumban értendők. Hívd meg a deinit() metódust a leállításhoz és a hely felszabadításához.

Valós idejű óra

A machine.RTC a visszaállításokon át megőrzi a faliórát. Az RP2040 RTC-je a chipen lévő oszcillátorhoz van kötve, és nem éli túl a teljes áramszünetet — állítsd be az időt minden hidegindításkor, ha ez fontos az alkalmazásod számára:

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

A machine.WDT visszaállítja a panelt, ha az alkalmazás lefagy. Indítás után nem állítható le és nem konfigurálható újra — tápláld periodikusan a fő ciklusodon belül:

from machine import WDT

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

Indítási és futásidejű információk

Firmware-frissítés (UF2)

A Nano RP2040 Connect az Arduino szabványos dupla koppintásos visszaállítását használja az Arduino rendszerbetöltőjébe lépéshez. Nyomd meg gyorsan kétszer a reset gombot — a panel UF2 eszközként újraregisztrál az USB-n, és az OpenMV IDE új firmware-képet flashelhet.

Egy futó szkript igény szerint újra beléphet a rendszerbetöltőbe a machine.bootloader() hívásával:

import machine

machine.bootloader()

Fájlrendszer és indítási sorrend

A Nano RP2040 Connect firmware indításkor egyetlen fájlrendszert csatol:

  • Belső flash memória — mindig a /flash ponton van csatolva, és munkakönyvtárként szolgál. Alapértelmezetten a main.py és a README.txt fájlokat tartalmazza; az első indításkor jön létre.

A csatolás után az interpreter a /flash-ről futtatja a szkripteket:

  • A boot.py minden szoftveres visszaállításkor lefut.

  • A main.py csak hidegindításkor fut le, közvetlenül a boot.py után.

A frissen flashelt panelen szállított alapértelmezett main.py csak a felhasználói RGB LED kék csatornáját villogtatja szívverésként (két rövid impulzus, rövid szünet), így csatlakoztatott gazdagép nélkül is megállapíthatod, hogy a firmware tisztán elindult.

USB-n keresztül csatlakoztatva a /flash USB-háttértárként jelenik meg a gazdagépen, lehetővé téve a boot.py, a main.py és bármely más fájl közvetlen szerkesztését. Vesd ki a meghajtót, mielőtt visszaállítanád a panelt, hogy a gazdagép kiírja a gyorsítótárazott írásokat.

Megjegyzés

Mivel az operációs rendszer a meghajtót passzív blokkeszközként kezeli, a kamerán futó kód által létrehozott vagy módosított fájlok nem jelennek meg, amíg a gazdagép újra nem csatolja a meghajtót. Ha az operációs rendszer és a kamera egyszerre írja ugyanazt a fájlrendszert, az operációs rendszer nyer, és felülírja a kamera által végzett módosításokat. Használd az SD-kártyát minden olyan adathoz, amelyet a szkript visszaír, és csatold újra, mielőtt ezeket a fájlokat a gazdagépről olvasnád.

Megjegyzés

A felhasználói RGB LED piros csatornája röviden felvillanhat, amíg a gazdagép olvas az USB-háttértárról vagy ír rá — ez egy firmware-vezérelt tevékenységjelző, nem hiba.

Tárhelyméretek

A Nano RP2040 Connect a következőkkel érkezik:

  • /flash — 14 MB FAT fájlrendszer, írható/olvasható.

A Nano RP2040 build nem tartalmaz ROMFS-t; a Python modulokat és az ML modelleket közvetlenül a /flash-en szállítsd.

Szoftverkönyvtárak

A modulok teljes listájáért lásd a könyvtárindexet — beleértve azokat is, amelyek csak a Nano RP2040 Connect buildjében egyediek.