Arduino Nano RP2040 Connect

Ostrzeżenie

Ta płytka nie jest już wspierana. Ostatnim wydaniem oprogramowania układowego OpenMV dla Arduino Nano RP2040 Connect jest wersja 4.7.0. Dla tego celu nie będą wydawane żadne dalsze aktualizacje oprogramowania układowego, poprawki błędów ani nowe funkcje. Poniższe informacje zachowano dla użytkowników korzystających z wersji 4.7.0 lub wcześniejszej.

Arduino Nano RP2040 Connect to płytka o wymiarach 45 × 18 mm w formacie Arduino Nano, zbudowana wokół układu Raspberry Pi RP2040 — dwurdzeniowego ARM Cortex‑M0+ taktowanego zegarem 133 MHz z 264 KB wewnętrznej pamięci SRAM. WiFi i BLE zapewnia moduł U‑blox NINA‑W102, a płytka jest wyposażona w 6‑osiowy IMU LSM6DSOX oraz mikrofon PDM MP34DT06. Oprogramowanie układowe OpenMV obsługuje je wszystkie z poziomu MicroPython.

Arduino Nano RP2040 Connect

Pełną dokumentację techniczną, zdjęcia i wymiary znajdziesz na stronie produktu Arduino Nano RP2040 Connect.

Najważniejsze cechy

  • Raspberry Pi RP2040 dwurdzeniowy ARM Cortex‑M0+ taktowany zegarem 133 MHz z 264 KB wewnętrznej pamięci SRAM.

  • 16 MB zewnętrznej pamięci flash QSPI.

  • Moduł U‑blox NINA‑W102 zapewniający Wi‑Fi 2,4 GHz b/g/n oraz Bluetooth 4.2 (BR/EDR + LE).

  • 6‑osiowy IMU LSM6DSOX oraz mikrofon PDM MP34DT06.

  • Złącze Micro USB do zasilania, programowania i obsługi REPL przez CDC.

  • 22 piny I/O użytkownika na standardowych złączach Nano — TX/RX, D2–D13 (cyfrowe), A0–A7 (analogowe).

Rozkład wyprowadzeń

Rozkład wyprowadzeń Arduino Nano RP2040 Connect

Opis wyprowadzeń

Nazwa pinu

Odniesienie

Funkcja

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

naciśnij przycisk RESET na płytce lub zewrzyj do GND, aby zresetować

REC

3,3 V

BOOTSEL — podciągnij do stanu wysokiego przy włączaniu zasilania, aby wejść do bootloadera ROM układu RP2040

LED_BUILTIN

—

Pomarańczowa dioda LED użytkownika na D13

LED_RED

—

Czerwony kanał diody RGB

LED_GREEN

—

Zielony kanał diody RGB

LED_BLUE

—

Niebieski kanał diody RGB

Ostrzeżenie

Piny I/O płytki Nano RP2040 Connect pracują wyłącznie przy 3,3 V — nie są tolerancyjne na 5 V. Podanie na nie 5 V uszkodzi układ RP2040.

Piny zasilania

  • VIN — wejście 4 – 20 V. Zasila płytkę poprzez wbudowany przetwornik impulsowy. Jest również podawane przez diodę z szyny USB 5 V, więc USB i VIN mogą być obecne jednocześnie bez wzajemnego wstecznego zasilania.

  • +5V — domyślnie niepodłączone.

  • +3V3 — wyjście stabilizatora 3,3 V.

  • AREF — pin analogowego napięcia odniesienia. Na tej płytce nie jest połączony z RP2040 — ADC zawsze odnosi się do 3,3 V.

  • GND — wspólna masa.

Płytkę Nano RP2040 Connect można zasilać jedną z dwóch ścieżek:

  • Micro USB — dostarcza 5 V do wbudowanego stabilizatora.

  • Pin VIN — podaj stabilizowane zasilanie 4 – 20 V.

Informacja

Zworka lutownicza na spodzie płytki łączy +5V z szyną USB 5 V. Zamknij ją, aby pin złącza +5V faktycznie przewodził 5 V.

Informacja

Normalnie zamkniętą zworkę lutowniczą na wyjściu wbudowanego przetwornika impulsowego 4–20 V można przeciąć, aby wyłączyć stabilizator, dzięki czemu płytkę można zasilać bezpośrednio z zewnętrznego źródła 3,3 V na +3V3.

Piny do odzyskiwania i debugowania

  • RESET — zarówno wyprowadzony pad, jak i chwilowy przycisk RESET na górze płytki, połączony z linią NRST układu RP2040. Zewrzyj do GND lub naciśnij przycisk, aby zresetować.

  • REC — wyprowadzony pad. Przytrzymanie REC w stanie wysokim przy włączaniu zasilania (lub podczas naciskania RESET) wprowadza RP2040 do bootloadera ROM; płytka ponownie wykrywa się jako napęd pamięci masowej USB o nazwie RPI-RP2 i akceptuje obraz oprogramowania układowego .uf2.

Płytka Nano RP2040 Connect używa standardowego mechanizmu podwójnego naciśnięcia reset Arduino, aby wejść do bootloadera Arduino. Naciśnij szybko dwukrotnie przycisk RESET — płytka ponownie wykrywa się przez USB jako urządzenie UF2, a OpenMV IDE może wgrać nowy obraz oprogramowania układowego.

Sygnały SWD układu RP2040 są wyprowadzone na powlekane pady z tyłu płytki, tuż pod modułem NINA. Wszystkie sygnały debugowania mają napięcie odniesienia 3,3 V.

Wbudowane urządzenia peryferyjne

Diody LED

Płytka Nano RP2040 Connect ma diodę RGB użytkownika — sterowaną przez opisane na nadruku kanały LED_RED, LED_GREEN i LED_BLUE — oraz osobną pomarańczową diodę LED_BUILTIN na D13. Wszystkie cztery można sterować programowo poprzez machine.LED

from machine import LED

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

Osobna zielona dioda zasilania na płytce świeci się, gdy tylko szyna +3,3 V jest aktywna, i nie jest sterowana przez użytkownika.

Sensor kamery

Oprogramowanie układowe OpenMV na płytce Nano RP2040 Connect obsługuje równoległy sensor CMOS OmniVision OV7670. Płytka nie ma wbudowanego sensora obrazu — podłącz moduł OV7670 do opisanych na nadruku pinów złącza wymienionych poniżej i steruj nim poprzez moduł csi — sensory kamery

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

Informacja

OV7670 zajmuje 14 pinów. Oprogramowanie układowe łączy je następująco:

Sygnał sensora

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 sterująca I²C układu OV7670 jest współdzielona z wbudowanym IMU oraz ATECC608A na I²C 0. Sensor znajduje się pod 7‑bitowym adresem 0x21 — urządzenia użytkownika na magistrali 0 muszą również unikać tego adresu, gdy kamera jest podłączona.

IMU

Wbudowany 6‑osiowy akcelerometr + żyroskop LSM6DSOX znajduje się na I2C0. Domyślnie machine.I2C(0) portu rp2 używa innego zestawu pinów, więc przekaż jawnie opisane na nadruku pady SDA/SCL. Użyj wbudowanego sterownika 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)

Mikrofon

Wbudowany mikrofon PDM MP34DT06 jest przechwytywany przez audio — Moduł Audio z użyciem jednego z bloków PIO układu 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

Wbudowany moduł NINA‑W102 jest udostępniany poprzez network — konfiguracja sieci jako interfejs stacji:

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

Ten sam moduł NINA udostępnia również Bluetooth 4.2 LE. Użyj aioble — Asynchroniczne BLE do obsługi BLE w stylu asyncio — na przykład, aby rozgłaszać się jako urządzenie peryferyjne i czekać na połączenie urządzenia centralnego:

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

Opis magistral

GPIO

Użyj machine.Pin, aby odczytywać lub sterować dowolnym z opisanych na nadruku pinów. Wyjścia to 3,3 V CMOS, łączny prąd zatapiający 50 mA na wszystkich 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())

Każdy pin wejściowy może również wyzwalać przerwanie przy zboczach sygnału:

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

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

UART

Magistrala

TX

RX

UART0

TX

RX

Użyj nazw z nadruku TX/RX z machine.UART

from machine import UART

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

Informacja

machine.UART(1) istnieje, ale jest zarezerwowany dla wbudowanego modułu NINA‑W102 (łącze BLE); nie używaj go bezpośrednio.

I²C

Magistrala

SDA

SCL

I2C0

SDA / A4

SCL / A5

I2C1

A0

A1

Obie magistrale wymagają jawnego przekazania swoich pinów do 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()

Informacja

Dwa wbudowane układy współdzielą magistralę 0 — urządzenia użytkownika na tej magistrali muszą unikać ich adresów:

  • 0x6A — IMU LSM6DSOX

  • 0x60 — ATECC608A‑MAHDA‑T

Użycie A0/A1 jako I²C zajmuje je na potrzeby magistrali, więc nie mogą jednocześnie być wejściami ADC.

Informacja

Pady SDA / SCL (magistrala 0) mają wbudowane rezystory podciągające do 3,3 V, więc dla urządzeń na tej magistrali nie są potrzebne zewnętrzne rezystory podciągające. A0 / A1 (magistrala 1) ich nie mają — dodaj zewnętrzne rezystory podciągające przy korzystaniu z magistrali 1.

Ten sam sprzęt można również wykorzystać w trybie celu (slave) poprzez machine.I2CTarget, aby udostępnić obszar pamięci innemu kontrolerowi I²C:

from machine import I2CTarget

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

SPI

Magistrala

MOSI

MISO

SCK

CS

SPI0

D11

D12

D13

D10

Port rp2 nie konfiguruje wstępnie pinów SPI0 na tej płytce, więc przy tworzeniu magistrali przekaż jawnie opisane na nadruku pady:

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)

Informacja

D13 pełni jednocześnie rolę pomarańczowej diody LED_BUILTIN — sterowanie SPI na tej magistrali będzie migać diodą w rytm zegara magistrali.

Informacja

machine.SPI(1) istnieje, ale jest zarezerwowany dla wbudowanego modułu NINA‑W102 (łącze SPI Wi-Fi/BLE); nie używaj go bezpośrednio.

ADC

RP2040 ma cztery 12‑bitowe kanały ADC wyprowadzone na A0–A3, wszystkie z napięciem odniesienia 3,3 V — read_u16 zwraca 0–65535 w zakresie 0–3,3 V na pinie. Pin AREF płytki nie jest połączony, więc napięciem odniesienia jest zawsze 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

Wycinek / kanał

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

Steruj dowolnym z nich poprzez machine.PWM

from machine import Pin, PWM

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

Informacja

Kilka pinów współdzieli kanały wycinków PWM:

  • PWM0 A jest na TX oraz D4.

  • PWM0 B jest na RX oraz D5.

  • PWM2 A jest na D8 oraz D12.

  • PWM2 B jest na D9 oraz D10.

  • PWM6 A jest na D16/A2 oraz D18/A4/SDA.

  • PWM6 B jest na D17/A3 oraz D19/A5/SCL.

Wybierz jednego odbiorcę na kanał wycinka. Kanały A i B w obrębie tego samego wycinka współdzielą okres (częstotliwość), ale każdy ma własny współczynnik wypełnienia.

Programowo emulowane magistrale (bit‑banging)

machine.SoftI2C i machine.SoftSPI działają na dowolnym GPIO, jeśli potrzebujesz dodatkowej magistrali.

Sensor termiczny (zewnętrzny)

Oprogramowanie układowe zawiera sterownik fir — sterownik sensora termicznego (fir == far infrared, daleka podczerwień) dla zewnętrznie podłączonego kamery termowizyjnej AMG8833 8×8. Podłącz moduł do magistrali I²C wymienionej poniżej, a następnie odczytuj ramki za pomocą 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())

Sterownik fir komunikuje się z sensorem wyłącznie przez I²C 0 — podłącz moduł do opisanych na nadruku padów SCL / SDA. 7‑bitowy adres sensora (0x69) nie może być używany przez żadne inne urządzenie na tej magistrali.

Czasowanie

time

Moduł time obejmuje blokujące opóźnienia, monotoniczne takty oraz pomiar upływającego czasu:

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)

Wirtualne liczniki czasu

machine.Timer planuje okresowe lub jednorazowe wywołania zwrotne bez zajmowania sprzętowego slotu licznika czasu. Przekaż -1 jako id, aby użyć wirtualnego (programowego) licznika czasu:

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

Wartości okresu podawane są w milisekundach. Wywołaj deinit(), aby zatrzymać i zwolnić slot.

Zegar czasu rzeczywistego

machine.RTC utrzymuje czas zegarowy między resetami. RTC układu RP2040 jest powiązany z oscylatorem na chipie i nie przetrwa całkowitej utraty zasilania — ustawiaj czas przy każdym zimnym rozruchu, jeśli ma to znaczenie dla twojej aplikacji:

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 resetuje płytkę, jeśli aplikacja się zawiesi. Po uruchomieniu nie można go zatrzymać ani przekonfigurować — karm go okresowo wewnątrz głównej pętli:

from machine import WDT

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

Informacje o rozruchu i działaniu

Aktualizacja oprogramowania układowego (UF2)

Płytka Nano RP2040 Connect używa standardowego mechanizmu podwójnego naciśnięcia reset Arduino, aby wejść do bootloadera Arduino. Naciśnij szybko dwukrotnie przycisk reset — płytka ponownie wykrywa się przez USB jako urządzenie UF2, a OpenMV IDE może wgrać nowy obraz oprogramowania układowego.

Działający skrypt może na żądanie ponownie wejść do bootloadera, wywołując machine.bootloader()

import machine

machine.bootloader()

System plików i kolejność rozruchu

Oprogramowanie układowe Nano RP2040 Connect montuje podczas rozruchu pojedynczy system plików:

  • Wewnętrzna pamięć flash — zawsze montowana w /flash i używana jako katalog roboczy. Domyślnie zawiera main.py i README.txt; tworzona przy samym pierwszym rozruchu.

Po zamontowaniu interpreter uruchamia następnie skrypty z /flash:

  • boot.py jest wykonywany przy każdym miękkim resecie.

  • main.py jest wykonywany tylko przy zimnym rozruchu, bezpośrednio po boot.py.

Domyślny main.py dostarczany na świeżo zaprogramowanej płytce po prostu miga niebieskim kanałem diody RGB użytkownika jako sygnałem życia (dwa krótkie impulsy, krótka przerwa), dzięki czemu można rozpoznać, że oprogramowanie układowe uruchomiło się prawidłowo bez podłączonego hosta.

Po podłączeniu przez USB /flash wykrywa się na hoście jako napęd pamięci masowej USB, co pozwala bezpośrednio edytować boot.py, main.py i wszelkie inne pliki. Wysuń napęd przed zresetowaniem płytki, aby host opróżnił buforowane zapisy.

Informacja

Ponieważ system operacyjny traktuje napęd jako pasywne urządzenie blokowe, pliki utworzone lub zmodyfikowane przez kod działający na kamerze nie pojawią się, dopóki host ponownie nie zamontuje napędu. Jeśli zarówno system operacyjny, jak i kamera zapisują w tym samym systemie plików w tym samym czasie, system operacyjny wygra i nadpisze zmiany wprowadzone przez kamerę. Używaj karty SD do wszelkich danych zapisywanych przez skrypt i montuj ponownie przed odczytaniem tych plików z hosta.

Informacja

Czerwony kanał diody RGB użytkownika może na krótko zaświecić się, gdy host odczytuje dane z napędu pamięci masowej USB lub zapisuje na nim — jest to wskaźnik aktywności sterowany przez oprogramowanie układowe, a nie awaria.

Rozmiary pamięci masowej

Płytka Nano RP2040 Connect jest dostarczana z:

  • /flash — system plików FAT o pojemności 14 MB, do odczytu/zapisu.

Kompilacja Nano RP2040 nie zawiera ROMFS; dostarczaj moduły Python i modele ML bezpośrednio na /flash.

Biblioteki programowe

Pełną listę modułów znajdziesz w indeksie bibliotek — w tym informacje o tym, które z nich są unikalne dla kompilacji Nano RP2040 Connect.