Arduino Nano RP2040 Connect

Varning

Detta kort stöds inte längre. Den sista OpenMV-firmwareutgåvan för Arduino Nano RP2040 Connect är 4.7.0. Inga ytterligare firmwareuppdateringar, buggfixar eller nya funktioner kommer att ges ut för denna målplattform. Informationen nedan bevaras för användare som kör 4.7.0 eller tidigare.

Arduino Nano RP2040 Connect är ett 45 × 18 mm stort kort i Arduino-Nano-formfaktor byggt kring Raspberry Pi RP2040 — en dubbel ARM Cortex‑M0+ som körs på 133 MHz med 264 KB internt SRAM. WiFi och BLE kommer från en U‑blox NINA‑W102-modul, och kortet bär en LSM6DSOX 6‑axlig IMU och en MP34DT06 PDM-mikrofon. OpenMV-firmware driver alla dessa från MicroPython.

Arduino Nano RP2040 Connect

För fullständigt datablad, foton och mått, se produktsidan för Arduino Nano RP2040 Connect.

Höjdpunkter

  • Raspberry Pi RP2040 dubbel ARM Cortex‑M0+ på 133 MHz med 264 KB internt SRAM.

  • 16 MB externt QSPI-flashminne.

  • U‑blox NINA‑W102-modul som tillhandahåller 2,4 GHz Wi‑Fi b/g/n och Bluetooth 4.2 (BR/EDR + LE).

  • LSM6DSOX 6‑axlig IMU och MP34DT06 PDM-mikrofon.

  • Micro USB-kontakt för ström, programmering och en CDC-REPL.

  • 22 användar-I/O-stift på de vanliga Nano-listerna — TX/RX, D2–D13 (digitala), A0–A7 (analoga).

Stiftutgång

Stiftutgång för Arduino Nano RP2040 Connect

Stiftreferens

Stiftnamn

Referens

Funktion

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

tryck på den inbyggda RESET-knappen eller dra till GND för att återställa

REC

3,3 V

BOOTSEL — dra hög vid påslagning för att gå in i RP2040:s ROM-startladdare

LED_BUILTIN

—

Orange användar-LED på D13

LED_RED

—

RGB-LED:ns röda kanal

LED_GREEN

—

RGB-LED:ns gröna kanal

LED_BLUE

—

RGB-LED:ns blåa kanal

Varning

Nano RP2040 Connects I/O-stift är endast 3,3 V — de är inte 5 V-toleranta. Att driva 5 V in i dem kommer att skada RP2040.

Strömstift

  • VIN — 4 – 20 V ingång. Driver kortet genom den inbyggda switchregulatorn. Matas även via en diod från USB:s 5 V-skena, så USB och VIN kan vara närvarande samtidigt utan att backmata varandra.

  • +5V — ej ansluten som standard.

  • +3V3 — 3,3 V regulatorutgång.

  • AREF — analog referensstift. Inte kopplad till RP2040 på detta kort — ADC:n refereras alltid till 3,3 V.

  • GND — gemensam jord.

Nano RP2040 Connect kan drivas via endera vägen:

  • Micro USB — levererar 5 V till den inbyggda regulatorn.

  • VIN-stift — driv en reglerad matning på 4 – 20 V.

Anteckning

En lödbygel på kortets undersida förbinder +5V med USB:s 5 V-skena. Slut den för att få +5V-listens stift att faktiskt föra 5 V.

Anteckning

En normalt sluten lödbygel på utgången av den inbyggda 4–20 V switchregulatorn kan kapas för att inaktivera regulatorn, så att kortet kan drivas direkt från en extern 3,3 V-matning på +3V3.

Återställnings- och felsökningsstift

  • RESET — både en exponerad lödyta och en momentan RESET-knapp på kortets ovansida, kopplad till RP2040:s NRST-linje. Dra till GND eller tryck på knappen för att återställa.

  • REC — exponerad lödyta. Att hålla REC hög vid påslagning (eller medan RESET trycks) försätter RP2040 i dess ROM-startladdare; kortet räknas om som en USB-masslagringsenhet vid namn RPI-RP2 och accepterar en .uf2-firmwareavbild.

Nano RP2040 Connect använder Arduinos standardmässiga dubbeltrycks-återställning för att gå in i Arduinos startladdare. Tryck snabbt på RESET-knappen två gånger — kortet räknas om över USB som en UF2-enhet och OpenMV IDE kan flasha en ny firmwareavbild.

RP2040:s SWD-signaler är exponerade på pläterade lödytor på kortets baksida, strax under NINA-modulen. Alla felsökningssignaler är 3,3 V-refererade.

Inbyggd kringutrustning

LED:ar

Nano RP2040 Connect har en användar-RGB-LED — driven genom de silktryckta kanalerna LED_RED, LED_GREEN och LED_BLUE — plus en separat orange LED_BUILTIN på D13. Alla fyra är mjukvarustyrbara genom machine.LED

from machine import LED

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

En separat grön ström-LED på kortet lyser närhelst +3,3 V-skenan är uppe och är inte användarstyrbar.

Kamerasensor

OpenMV-firmware på Nano RP2040 Connect stöder den parallella CMOS-sensorn OmniVision OV7670. Kortet har ingen inbyggd bildsensor — koppla en OV7670-modul till de silktryckta liststiften som listas nedan och driv den genom modulen csi — kamerasensorer

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

Anteckning

OV7670 tar 14 stift. Firmware kopplar dem enligt följande:

Sensorsignal

Nano RP2040-stift

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)

OV7670:s I²C-styrbuss delas med den inbyggda IMU:n och ATECC608A på I²C 0. Sensorn sitter på 7‑bitarsadressen 0x21 — användarenheter på buss 0 måste också undvika denna adress när kameran är inkopplad.

IMU

Den inbyggda LSM6DSOX 6‑axliga accelerometern + gyroskopet sitter på I2C0. rp2-portens machine.I2C(0) använder som standard en annan uppsättning stift, så ange de silktryckta SDA/SCL-lödytorna explicit. Använd den frusna drivrutinen 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

Den inbyggda MP34DT06 PDM-mikrofonen fångas genom audio — Ljudmodul med hjälp av ett av RP2040:s PIO-block:

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

Den inbyggda NINA‑W102-modulen exponeras via network — nätverkskonfiguration som ett stationsgränssnitt:

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

Samma NINA-modul exponerar även Bluetooth 4.2 LE. Använd aioble — Asynkron BLE för asyncio-vänlig BLE — exempelvis att annonsera som en kringutrustning och vänta på att en central ansluter:

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

Bussreferens

GPIO

Använd machine.Pin för att läsa eller driva något av de silktryckta stiften. Utgångar är 3,3 V CMOS, totalt 50 mA sänkning över alla GPIO:er.

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

Vilket ingångsstift som helst kan också utlösa ett avbrott vid flanktransitioner:

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

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

UART

Buss

TX

RX

UART0

TX

RX

Använd silktrycksnamnen TX/RX med machine.UART

from machine import UART

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

Anteckning

machine.UART(1) finns men är reserverad för den inbyggda NINA‑W102-modulen (BLE-länken); använd den inte direkt.

I²C

Buss

SDA

SCL

I2C0

SDA / A4

SCL / A5

I2C1

A0

A1

Båda bussarna behöver sina stift angivna explicit till 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()

Anteckning

Två inbyggda chip delar buss 0 — användarenheter på denna buss måste undvika deras adresser:

  • 0x6A — LSM6DSOX IMU

  • 0x60 — ATECC608A‑MAHDA‑T

Att använda A0/A1 som I²C upptar dem för bussen, så de kan inte samtidigt vara ADC-ingångar.

Anteckning

SDA / SCL-lödytorna (buss 0) har inbyggda pull-up-motstånd till 3,3 V, så inga externa pull-ups behövs för enheter på den bussen. A0 / A1 (buss 1) har det inte — lägg till externa pull-ups vid användning av buss 1.

Samma hårdvara kan också användas i mål-läge (slav) genom machine.I2CTarget för att exponera ett minnesområde för en annan I²C-styrenhet:

from machine import I2CTarget

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

SPI

Buss

MOSI

MISO

SCK

CS

SPI0

D11

D12

D13

D10

rp2-porten förkonfigurerar inte SPI0:s stift på detta kort, så ange de silktryckta lödytorna explicit när du skapar bussen:

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)

Anteckning

D13 fungerar även som den orange LED_BUILTIN — att driva SPI på denna buss kommer att blinka LED:n i takt med bussklockan.

Anteckning

machine.SPI(1) finns men är reserverad för den inbyggda NINA‑W102-modulen (Wi-Fi/BLE-SPI-länken); använd den inte direkt.

ADC

RP2040 har fyra 12‑bitars ADC-kanaler exponerade på A0–A3, alla 3,3 V-refererade — read_u16 returnerar 0–65535 över 0–3,3 V vid stiftet. Kortets AREF-stift är inte kopplat, så referensen är alltid 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

Stift

Skiva / kanal

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

Driv vilken som helst av dem via machine.PWM

from machine import Pin, PWM

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

Anteckning

Flera stift delar PWM-skivkanaler:

  • PWM0 A finns på TX och D4.

  • PWM0 B finns på RX och D5.

  • PWM2 A finns på D8 och D12.

  • PWM2 B finns på D9 och D10.

  • PWM6 A finns på D16/A2 och D18/A4/SDA.

  • PWM6 B finns på D17/A3 och D19/A5/SCL.

Välj en konsument per skivkanal. Kanal A och B inom samma skiva delar sin period (frekvens) men var och en har sin egen pulskvot.

Mjukvaru-bitknackade bussar

machine.SoftI2C och machine.SoftSPI fungerar på vilken GPIO som helst om du behöver en extra buss.

Termisk sensor (extern)

Firmware inkluderar drivrutinen fir — drivrutin för värmesensor (fir == far infrared) för en externt kopplad AMG8833 8×8 termisk bildtagare. Anslut modulen till I²C-bussen som listas nedan, läs sedan bildrutor med 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())

fir-drivrutinen talar bara med sensorn över I²C 0 — koppla modulen till de silktryckta SCL / SDA-lödytorna. Sensorns 7‑bitarsadress (0x69) får inte användas av någon annan enhet på den bussen.

Tidshantering

time

Modulen time täcker blockerande fördröjningar, monotona tick och mätning av förfluten tid:

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)

Virtuella timers

machine.Timer schemalägger periodiska eller engångs-återanrop utan att förbruka en hårdvarutimer-plats. Skicka -1 som id för att använda en virtuell (mjukvaru-)timer:

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

Periodvärden anges i millisekunder. Anropa deinit() för att stoppa och frigöra platsen.

Realtidsklocka

machine.RTC håller väggklockstid över återställningar. RP2040:s RTC är knuten till den inbyggda oscillatorn och överlever inte fullständigt strömbortfall — ställ in tiden vid varje kallstart om det är viktigt för din applikation:

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

Vakthund

machine.WDT återställer kortet om applikationen hänger sig. När den väl startats kan den inte stoppas eller omkonfigureras — mata den periodiskt inuti din huvudloop:

from machine import WDT

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

Start- och körtidsinformation

Firmwareuppdatering (UF2)

Nano RP2040 Connect använder Arduinos standardmässiga dubbeltrycks-återställning för att gå in i Arduinos startladdare. Tryck snabbt på reset-knappen två gånger — kortet räknas om över USB som en UF2-enhet och OpenMV IDE kan flasha en ny firmwareavbild.

Ett körande skript kan gå in i startladdaren på begäran genom att anropa machine.bootloader()

import machine

machine.bootloader()

Filsystem och startordning

Nano RP2040 Connect-firmware monterar ett enda filsystem vid start:

  • Internt flashminne — alltid monterat på /flash och används som arbetskatalog. Innehåller main.py och README.txt som standard; skapas vid allra första starten.

Efter montering kör tolken sedan skript från /flash:

  • boot.py körs vid varje mjuk återställning.

  • main.py körs endast vid kallstart, omedelbart efter boot.py.

Den standardmässiga main.py som levereras på ett nyligen flashat kort blinkar bara användar-RGB-LED:ns blåa kanal som ett hjärtslag (två korta pulser, kort paus), så att du kan se att firmware startade rent utan någon ansluten värd.

När den är ansluten över USB räknas /flash upp som en USB-masslagringsenhet på värden, vilket låter dig redigera boot.py, main.py och alla andra filer direkt. Mata ut enheten innan du återställer kortet så att värden tömmer sina cachade skrivningar.

Anteckning

Eftersom operativsystemet behandlar enheten som en passiv blockenhet kommer filer som skapats eller ändrats av kod som körs på kameran inte att visas förrän värden monterar om enheten. Om både operativsystemet och kameran skriver till samma filsystem samtidigt kommer operativsystemet att vinna och skriva över ändringar gjorda av kameran. Använd SD-kortet för all data som skriptet skriver tillbaka, och montera om innan du läser dessa filer från värden.

Anteckning

Användar-RGB-LED:ns röda kanal kan tändas kortvarigt medan värden läser från eller skriver till USB-masslagringsenheten — detta är en firmware-driven aktivitetsindikator, inte ett fel.

Lagringsstorlekar

Nano RP2040 Connect levereras med:

  • /flash — 14 MB FAT-filsystem, läs/skriv.

Nano RP2040-bygget inkluderar inte en ROMFS; leverera Python-moduler och ML-modeller direkt på /flash.

Programvarubibliotek

Se biblioteksindexet för den fullständiga listan över moduler — inklusive vilka som är unika för Nano RP2040 Connect-bygget.