Arduino Nano RP2040 Connect

Waarschuwing

Dit board wordt niet langer ondersteund. De laatste OpenMV-firmwarerelease voor de Arduino Nano RP2040 Connect is 4.7.0. Er worden geen verdere firmware-updates, bugfixes of nieuwe functies meer uitgebracht voor dit doel. De onderstaande informatie is bewaard voor gebruikers die 4.7.0 of eerder draaien.

De Arduino Nano RP2040 Connect is een 45 × 18 mm board in de Arduino-Nano-vormfactor, gebouwd rond de Raspberry Pi RP2040 — een dual ARM Cortex‑M0+ die op 133 MHz draait met 264 KB intern SRAM. WiFi en BLE komen van een U‑blox NINA‑W102-module, en het board bevat een LSM6DSOX 6-assige IMU en een MP34DT06 PDM-microfoon. De OpenMV-firmware bestuurt al deze onderdelen vanuit MicroPython.

Arduino Nano RP2040 Connect

Voor de volledige datasheet, foto’s en afmetingen, zie de Arduino Nano RP2040 Connect productpagina.

Hoogtepunten

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

  • 16 MB extern QSPI-flashgeheugen.

  • U‑blox NINA‑W102-module die 2,4 GHz Wi‑Fi b/g/n en Bluetooth 4.2 (BR/EDR + LE) biedt.

  • LSM6DSOX 6-assige IMU en MP34DT06 PDM-microfoon.

  • Micro USB-connector voor voeding, programmeren en een CDC-REPL.

  • 22 gebruikers-I/O-pinnen op de standaard Nano-headers — TX/RX, D2–D13 (digitaal), A0–A7 (analoog).

Pinout

Arduino Nano RP2040 Connect Pinout

Pinreferentie

Pinnaam

Referentie

Functie

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

druk op de RESET-knop op het board of trek naar GND om te resetten

REC

3,3 V

BOOTSEL — trek hoog bij inschakelen om de RP2040 ROM-bootloader te betreden

LED_BUILTIN

—

Oranje gebruikers-LED op D13

LED_RED

—

RGB-LED rood kanaal

LED_GREEN

—

RGB-LED groen kanaal

LED_BLUE

—

RGB-LED blauw kanaal

Waarschuwing

De I/O-pinnen van de Nano RP2040 Connect zijn alleen 3,3 V — ze zijn niet 5 V-bestendig. 5 V op deze pinnen zetten beschadigt de RP2040.

Voedingspinnen

  • VIN — 4 – 20 V ingang. Voedt het board via de switching-regelaar op het board. Wordt ook via een diode gevoed vanaf de USB 5 V-rail, zodat USB en VIN tegelijk aanwezig kunnen zijn zonder elkaar terug te voeden.

  • +5V — standaard niet aangesloten.

  • +3V3 — 3,3 V regelaaruitgang.

  • AREF — analoge referentiepin. Niet aangesloten op de RP2040 op dit board — de ADC wordt altijd gerefereerd aan 3,3 V.

  • GND — gemeenschappelijke massa.

De Nano RP2040 Connect kan via beide paden gevoed worden:

  • Micro USB — levert 5 V aan de regelaar op het board.

  • VIN-pin — voer een gestabiliseerde 4 – 20 V voeding aan.

Notitie

Een soldeerjumper aan de onderkant van het board verbindt +5V met de USB 5 V-rail. Sluit deze om de +5V-headerpin daadwerkelijk 5 V te laten voeren.

Notitie

Een normaal-gesloten soldeerjumper op de uitgang van de 4–20 V switching-regelaar op het board kan worden doorgesneden om de regelaar uit te schakelen, zodat het board direct gevoed kan worden vanaf een externe 3,3 V-voeding op +3V3.

Herstel- en debugpinnen

  • RESET — zowel een blootliggende pad als een momentane RESET-knop aan de bovenkant van het board, verbonden met de NRST-lijn van de RP2040. Trek naar GND of druk op de knop om te resetten.

  • REC — blootliggende pad. REC hoog houden bij inschakelen (of tijdens het indrukken van RESET) zet de RP2040 in zijn ROM-bootloader; het board meldt zich opnieuw aan als een USB-massaopslagschijf met de naam RPI-RP2 en accepteert een .uf2 firmware-image.

De Nano RP2040 Connect gebruikt de standaard double-tap reset van Arduino om de bootloader van Arduino te betreden. Druk twee keer snel op de RESET-knop — het board meldt zich opnieuw aan via USB als een UF2-apparaat en OpenMV IDE kan een nieuw firmware-image flashen.

De SWD-signalen van de RP2040 liggen blootliggend op verzilverde pads aan de achterkant van het board, net onder de NINA-module. Alle debugsignalen zijn gerefereerd aan 3,3 V.

Randapparaten op het board

LEDs

De Nano RP2040 Connect heeft een RGB-gebruikers-LED — aangestuurd via de op de silkscreen aangeduide kanalen LED_RED, LED_GREEN en LED_BLUE — plus een aparte oranje LED_BUILTIN op D13. Alle vier zijn softwarematig bestuurbaar via machine.LED

from machine import LED

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

Een aparte groene voedings-LED op het board brandt zodra de +3,3 V-rail actief is en is niet door de gebruiker bestuurbaar.

Camerasensor

De OpenMV-firmware op de Nano RP2040 Connect ondersteunt de OmniVision OV7670 parallelle CMOS-sensor. Het board heeft geen ingebouwde beeldsensor — sluit een OV7670-module aan op de op de silkscreen aangeduide headerpinnen hieronder en bestuur deze via de csi — camerasensoren-module:

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

Notitie

De OV7670 gebruikt 14 pinnen. De firmware bedraadt ze als volgt:

Sensorsignaal

Nano RP2040-pin

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)

De I²C-besturingsbus van de OV7670 wordt gedeeld met de IMU en de ATECC608A op het board op I²C 0. De sensor bevindt zich op het 7-bits adres 0x21 — gebruikersapparaten op bus 0 moeten dit adres ook vermijden wanneer de camera aangesloten is.

IMU

De LSM6DSOX 6-assige versnellingsmeter + gyroscoop op het board zit op I2C0. De machine.I2C(0) van de rp2-port gebruikt standaard een andere pinset, geef dus de op de silkscreen aangeduide SDA/SCL-pads expliciet door. Gebruik de ingebakken lsm6dsox.LSM6DSOX-driver:

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)

Microfoon

De MP34DT06 PDM-microfoon op het board wordt opgenomen via audio — Audio Module met behulp van een van de PIO-blokken van de 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

De NINA‑W102-module op het board is via network — netwerkconfiguratie beschikbaar als een station-interface:

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

Dezelfde NINA-module biedt ook Bluetooth 4.2 LE. Gebruik aioble — Async BLE voor asyncio-vriendelijke BLE — adverteer bijvoorbeeld als randapparaat en wacht tot een central verbinding maakt:

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

Busreferentie

GPIO

Gebruik machine.Pin om een van de op de silkscreen aangeduide pinnen te lezen of aan te sturen. Uitgangen zijn 3,3 V CMOS, 50 mA totale sink over alle GPIO’s.

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

Elke ingangspin kan ook een interrupt activeren bij randovergangen:

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

Gebruik de silkscreen-namen TX/RX met machine.UART

from machine import UART

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

Notitie

machine.UART(1) bestaat, maar is gereserveerd voor de NINA‑W102-module op het board (de BLE-verbinding); gebruik deze niet rechtstreeks.

I²C

Bus

SDA

SCL

I2C0

SDA / A4

SCL / A5

I2C1

A0

A1

Voor beide bussen moeten hun pinnen expliciet aan machine.I2C worden doorgegeven:

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

Notitie

Twee chips op het board delen bus 0 — gebruikersapparaten op deze bus moeten hun adressen vermijden:

  • 0x6A — LSM6DSOX IMU

  • 0x60 — ATECC608A‑MAHDA‑T

A0/A1 als I²C gebruiken claimt ze voor de bus, zodat ze niet tegelijkertijd ADC-ingangen kunnen zijn.

Notitie

De SDA / SCL-pads (bus 0) hebben pull-upweerstanden naar 3,3 V op het board, dus er zijn geen externe pull-ups nodig voor apparaten op die bus. A0 / A1 (bus 1) hebben deze niet — voeg externe pull-ups toe bij gebruik van bus 1.

Dezelfde hardware kan ook in target- (slave-)modus worden gebruikt via machine.I2CTarget om een geheugengebied beschikbaar te stellen aan een andere I²C-controller:

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

De rp2-port configureert de pinnen van SPI0 niet vooraf op dit board, geef dus de op de silkscreen aangeduide pads expliciet door bij het aanmaken van de 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)

Notitie

D13 doet ook dienst als de oranje LED_BUILTIN — SPI op deze bus aansturen laat de LED knipperen op het ritme van de busklok.

Notitie

machine.SPI(1) bestaat, maar is gereserveerd voor de NINA‑W102-module op het board (de Wi-Fi/BLE SPI-verbinding); gebruik deze niet rechtstreeks.

ADC

De RP2040 heeft vier 12-bits ADC-kanalen beschikbaar op A0–A3, allemaal gerefereerd aan 3,3 V — read_u16 geeft 0–65535 terug over 0–3,3 V op de pin. De AREF-pin van het board is niet aangesloten, dus de referentie is altijd 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 / kanaal

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

Stuur er een van aan via machine.PWM

from machine import Pin, PWM

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

Notitie

Verschillende pinnen delen PWM-slice-kanalen:

  • PWM0 A zit op TX en D4.

  • PWM0 B zit op RX en D5.

  • PWM2 A zit op D8 en D12.

  • PWM2 B zit op D9 en D10.

  • PWM6 A zit op D16/A2 en D18/A4/SDA.

  • PWM6 B zit op D17/A3 en D19/A5/SCL.

Kies één gebruiker per slice-kanaal. De kanalen A en B binnen dezelfde slice delen hun periode (frequentie), maar elk heeft zijn eigen duty cycle.

Softwarematig bit-banged bussen

machine.SoftI2C en machine.SoftSPI werken op elke GPIO als je een extra bus nodig hebt.

Thermische sensor (extern)

De firmware bevat de fir — thermische sensor-driver (fir == far infrared)-driver voor een extern bedrade AMG8833 8×8 thermische beeldsensor. Sluit de module aan op de hieronder vermelde I²C-bus en lees vervolgens frames met 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())

De fir-driver communiceert alleen met de sensor via I²C 0 — sluit de module aan op de op de silkscreen aangeduide SCL / SDA-pads. Het 7-bits adres van de sensor (0x69) mag niet door een ander apparaat op die bus worden gebruikt.

Timing

time

De time-module behandelt blokkerende vertragingen, monotone ticks en het meten van verstreken tijd:

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)

Virtuele timers

machine.Timer plant periodieke of eenmalige callbacks zonder een hardware-timerslot te verbruiken. Geef -1 als id door om een virtuele (software)timer te gebruiken:

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

Periodewaarden zijn in milliseconden. Roep deinit() aan om het slot te stoppen en vrij te geven.

Realtimeklok

machine.RTC houdt de kloktijd bij over resets heen. De RTC van de RP2040 is gekoppeld aan de on-chip-oscillator en overleeft geen volledig stroomverlies — stel de tijd in bij elke koude start als dat belangrijk is voor je toepassing:

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 reset het board als de toepassing vastloopt. Eenmaal gestart kan deze niet worden gestopt of opnieuw geconfigureerd — voed hem periodiek binnen je hoofdlus:

from machine import WDT

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

Boot- en runtime-informatie

Firmware-update (UF2)

De Nano RP2040 Connect gebruikt de standaard double-tap reset van Arduino om de bootloader van Arduino te betreden. Druk twee keer snel op de resetknop — het board meldt zich opnieuw aan via USB als een UF2-apparaat en OpenMV IDE kan een nieuw firmware-image flashen.

Een draaiend script kan op verzoek de bootloader opnieuw betreden door machine.bootloader() aan te roepen:

import machine

machine.bootloader()

Bestandssysteem en bootvolgorde

De firmware van de Nano RP2040 Connect mount bij het opstarten één bestandssysteem:

  • Intern flashgeheugen — altijd gemount op /flash en gebruikt als de werkmap. Bevat standaard main.py en README.txt; aangemaakt bij de allereerste boot.

Na het mounten draait de interpreter vervolgens scripts vanaf /flash:

  • boot.py wordt uitgevoerd bij elke soft reset.

  • main.py wordt alleen bij een koude start uitgevoerd, direct na boot.py.

De standaard main.py die op een vers geflasht board wordt meegeleverd, laat alleen het blauwe kanaal van de RGB-gebruikers-LED knipperen als een hartslag (twee korte pulsen, korte pauze), zodat je kunt zien dat de firmware netjes is opgestart zonder een aangesloten host.

Wanneer verbonden via USB, meldt /flash zich aan als een USB-massaopslagschijf op de host, zodat je boot.py, main.py en alle andere bestanden direct kunt bewerken. Werp de schijf uit voordat je het board reset zodat de host zijn gecachete schrijfacties wegschrijft.

Notitie

Omdat het besturingssysteem de schijf als een passief blokapparaat behandelt, verschijnen bestanden die zijn aangemaakt of gewijzigd door code die op de camera draait pas wanneer de host de schijf opnieuw mount. Als zowel het besturingssysteem als de camera tegelijkertijd naar hetzelfde bestandssysteem schrijven, wint het besturingssysteem en overschrijft het de wijzigingen die door de camera zijn gemaakt. Gebruik de SD-kaart voor alle gegevens die het script terugschrijft, en mount opnieuw voordat je die bestanden vanaf de host leest.

Notitie

Het rode kanaal van de RGB-gebruikers-LED kan kort oplichten terwijl de host van de USB-massaopslagschijf leest of ernaar schrijft — dit is een door de firmware aangestuurde activiteitsindicator, geen fout.

Opslaggroottes

De Nano RP2040 Connect wordt geleverd met:

  • /flash — 14 MB FAT-bestandssysteem, lezen/schrijven.

De Nano RP2040-build bevat geen ROMFS; lever Python-modules en ML-modellen direct op /flash.

Softwarebibliotheken

Zie de bibliotheekindex voor de volledige lijst met modules — inclusief welke uniek zijn voor de Nano RP2040 Connect-build.