Arduino Nano RP2040 Connect

Aviso

Esta placa não é mais suportada. A última versão do firmware OpenMV para a Arduino Nano RP2040 Connect é a 4.7.0. Nenhuma atualização de firmware, correção de bugs ou novo recurso será lançado para este alvo. As informações abaixo são preservadas para usuários que executam a 4.7.0 ou anterior.

A Arduino Nano RP2040 Connect é uma placa de 45 × 18 mm no fator de forma Arduino‑Nano construída em torno do Raspberry Pi RP2040 — um ARM Cortex‑M0+ dual‑core rodando a 133 MHz com 264 KB de SRAM interna. O WiFi e o BLE vêm de um módulo U‑blox NINA‑W102, e a placa traz uma IMU de 6 eixos LSM6DSOX e um microfone PDM MP34DT06. O firmware OpenMV controla todos eles a partir do MicroPython.

Arduino Nano RP2040 Connect

Para o datasheet completo, fotos e dimensões, consulte a página do produto Arduino Nano RP2040 Connect.

Destaques

  • Raspberry Pi RP2040 ARM Cortex‑M0+ dual‑core a 133 MHz com 264 KB de SRAM interna.

  • 16 MB de flash QSPI externa.

  • Módulo U‑blox NINA‑W102 fornecendo Wi‑Fi b/g/n de 2,4 GHz e Bluetooth 4.2 (BR/EDR + LE).

  • IMU de 6 eixos LSM6DSOX e microfone PDM MP34DT06.

  • Conector Micro USB para alimentação, programação e um REPL CDC.

  • 22 pinos de I/O de usuário nos headers padrão Nano — TX/RX, D2–D13 (digitais), A0–A7 (analógicos).

Pinagem

Pinagem da Arduino Nano RP2040 Connect

Referência de pinos

Nome do pino

Referência

Função

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

pressione o botão RESET embarcado ou puxe para o GND para resetar

REC

3,3 V

BOOTSEL — puxe para nível alto na energização para entrar no bootloader da ROM do RP2040

LED_BUILTIN

—

LED de usuário laranja em D13

LED_RED

—

Canal vermelho do LED RGB

LED_GREEN

—

Canal verde do LED RGB

LED_BLUE

—

Canal azul do LED RGB

Aviso

Os pinos de I/O da Nano RP2040 Connect são apenas de 3,3 V — eles não toleram 5 V. Aplicar 5 V neles danificará o RP2040.

Pinos de alimentação

  • VIN — entrada de 4 – 20 V. Alimenta a placa através do regulador chaveado embarcado. Também é alimentado, via um diodo, a partir do barramento de 5 V do USB, de modo que o USB e o VIN podem estar presentes ao mesmo tempo sem retroalimentar um ao outro.

  • +5V — não conectado por padrão.

  • +3V3 — saída do regulador de 3,3 V.

  • AREF — pino de referência analógica. Não está ligado ao RP2040 nesta placa — o ADC sempre é referenciado a 3,3 V.

  • GND — terra comum.

A Nano RP2040 Connect pode ser alimentada por qualquer um dos caminhos:

  • Micro USB — fornece 5 V ao regulador embarcado.

  • Pino VIN — aplique uma fonte regulada de 4 – 20 V.

Nota

Um jumper de solda na parte inferior da placa conecta o +5V ao barramento de 5 V do USB. Feche-o para que o pino de header +5V realmente conduza 5 V.

Nota

Um jumper de solda normalmente fechado na saída do regulador chaveado de 4–20 V embarcado pode ser cortado para desabilitar o regulador, de modo que a placa possa ser alimentada diretamente a partir de uma fonte externa de 3,3 V no +3V3.

Pinos de recuperação e depuração

  • RESET — tanto um pad exposto quanto um botão RESET momentâneo na parte superior da placa, ligados à linha NRST do RP2040. Puxe para o GND ou pressione o botão para resetar.

  • REC — pad exposto. Manter o REC em nível alto na energização (ou enquanto pressiona o RESET) coloca o RP2040 em seu bootloader da ROM; a placa reenumera como uma unidade de armazenamento em massa USB chamada RPI-RP2 e aceita uma imagem de firmware .uf2.

A Nano RP2040 Connect usa o reset por toque duplo padrão do Arduino para entrar no bootloader do Arduino. Pressione rapidamente o botão RESET duas vezes — a placa reenumera via USB como um dispositivo UF2 e o OpenMV IDE pode gravar uma nova imagem de firmware.

Os sinais SWD do RP2040 estão expostos em pads metalizados na parte traseira da placa, logo abaixo do módulo NINA. Todos os sinais de depuração são referenciados a 3,3 V.

Periféricos embarcados

LEDs

A Nano RP2040 Connect possui um LED RGB de usuário — controlado pelos canais serigrafados LED_RED, LED_GREEN e LED_BLUE — além de um LED_BUILTIN laranja separado em D13. Todos os quatro são controláveis por software através de machine.LED

from machine import LED

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

Um LED verde de alimentação separado na placa acende sempre que o barramento de +3,3 V está ativo e não é controlável pelo usuário.

Sensor de câmera

O firmware OpenMV na Nano RP2040 Connect suporta o sensor CMOS paralelo OmniVision OV7670. A placa não possui sensor de imagem embarcado — conecte um módulo OV7670 aos pinos de header serigrafados listados abaixo e controle-o através do módulo csi — sensores de câmera

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

Nota

O OV7670 utiliza 14 pinos. O firmware os conecta da seguinte forma:

Sinal do sensor

Pino do 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)

O barramento de controle I²C do OV7670 é compartilhado com a IMU embarcada e o ATECC608A no I²C 0. O sensor fica no endereço de 7 bits 0x21 — os dispositivos de usuário no barramento 0 também devem evitar esse endereço quando a câmera estiver conectada.

IMU

O acelerômetro + giroscópio de 6 eixos LSM6DSOX embarcado fica no I2C0. O machine.I2C(0) da porta rp2 utiliza por padrão um conjunto de pinos diferente, então passe explicitamente os pads serigrafados SDA/SCL. Use o driver congelado 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)

Microfone

O microfone PDM MP34DT06 embarcado é capturado através de audio — Módulo de Áudio usando um dos blocos PIO do 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

O módulo NINA‑W102 embarcado é exposto via network — configuração de rede como uma interface de estação:

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

O mesmo módulo NINA também expõe o Bluetooth 4.2 LE. Use aioble — BLE Assíncrono para BLE compatível com asyncio — por exemplo, anuncie-se como periférico e aguarde a conexão de um dispositivo 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())

Referência de barramentos

GPIO

Use machine.Pin para ler ou acionar qualquer um dos pinos serigrafados. As saídas são CMOS de 3,3 V, com 50 mA de dreno total em todos os GPIOs.

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

Qualquer pino de entrada também pode disparar uma interrupção em transições de borda:

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

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

UART

Barramento

TX

RX

UART0

TX

RX

Use os nomes da serigrafia TX/RX com machine.UART

from machine import UART

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

Nota

O machine.UART(1) existe, mas é reservado para o módulo NINA‑W102 embarcado (o enlace BLE); não o use diretamente.

I²C

Barramento

SDA

SCL

I2C0

SDA / A4

SCL / A5

I2C1

A0

A1

Ambos os barramentos precisam que seus pinos sejam passados explicitamente para 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()

Nota

Dois chips embarcados compartilham o barramento 0 — os dispositivos de usuário neste barramento devem evitar seus endereços:

  • 0x6A — IMU LSM6DSOX

  • 0x60 — ATECC608A‑MAHDA‑T

Usar A0/A1 como I²C os consome para o barramento, de modo que não podem ser simultaneamente entradas ADC.

Nota

Os pads SDA / SCL (barramento 0) possuem resistores de pull‑up embarcados para 3,3 V, então não são necessários pull‑ups externos para dispositivos nesse barramento. Os pinos A0 / A1 (barramento 1) não possuem — adicione pull‑ups externos ao usar o barramento 1.

O mesmo hardware também pode ser usado em modo alvo (escravo) através de machine.I2CTarget para expor uma região de memória a outro controlador I²C:

from machine import I2CTarget

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

SPI

Barramento

MOSI

MISO

SCK

CS

SPI0

D11

D12

D13

D10

A porta rp2 não pré-configura os pinos do SPI0 nesta placa, então passe os pads serigrafados explicitamente ao criar o barramento:

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)

Nota

O D13 também funciona como o LED_BUILTIN laranja — acionar o SPI neste barramento fará o LED piscar em sincronia com o clock do barramento.

Nota

O machine.SPI(1) existe, mas é reservado para o módulo NINA‑W102 embarcado (o enlace SPI de Wi-Fi/BLE); não o use diretamente.

ADC

O RP2040 tem quatro canais ADC de 12 bits expostos em A0–A3, todos referenciados a 3,3 V — read_u16 retorna de 0 a 65535 ao longo de 0–3,3 V no pino. O pino AREF da placa não está ligado, então a referência é sempre 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

Pino

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

Acione qualquer um deles via machine.PWM

from machine import Pin, PWM

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

Nota

Vários pinos compartilham canais de slice PWM:

  • PWM0 A está em TX e D4.

  • PWM0 B está em RX e D5.

  • PWM2 A está em D8 e D12.

  • PWM2 B está em D9 e D10.

  • PWM6 A está em D16/A2 e D18/A4/SDA.

  • PWM6 B está em D17/A3 e D19/A5/SCL.

Escolha apenas um consumidor por canal de slice. Os canais A e B dentro do mesmo slice compartilham o período (frequência), mas cada um tem seu próprio ciclo de trabalho.

Barramentos por bit‑banging em software

machine.SoftI2C e machine.SoftSPI funcionam em qualquer GPIO caso você precise de um barramento extra.

Sensor térmico (externo)

O firmware inclui o driver fir — driver de sensor térmico (fir == far infrared) para um imageador térmico AMG8833 de 8×8 conectado externamente. Conecte o módulo ao barramento I²C listado abaixo e leia os quadros com 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())

O driver fir só se comunica com o sensor pelo I²C 0 — conecte o módulo aos pads serigrafados SCL / SDA. O endereço de 7 bits do sensor (0x69) não deve ser usado por nenhum outro dispositivo nesse barramento.

Temporização

time

O módulo time cobre atrasos bloqueantes, ticks monotônicos e medição de tempo decorrido:

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)

Timers virtuais

machine.Timer agenda callbacks periódicos ou únicos sem consumir um slot de timer de hardware. Passe -1 como id para usar um timer virtual (em 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"))

Os valores de período estão em milissegundos. Chame deinit() para parar e liberar o slot.

Relógio de tempo real

machine.RTC mantém o horário de relógio através de resets. O RTC do RP2040 está ligado ao oscilador interno do chip e não sobrevive a uma perda total de energia — ajuste o horário a cada inicialização a frio se isso for importante para sua aplicação:

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 reseta a placa se a aplicação travar. Uma vez iniciado, ele não pode ser parado ou reconfigurado — alimente-o periodicamente dentro do seu laço principal:

from machine import WDT

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

Informações de boot e tempo de execução

Atualização de firmware (UF2)

A Nano RP2040 Connect usa o reset por toque duplo padrão do Arduino para entrar no bootloader do Arduino. Pressione rapidamente o botão reset duas vezes — a placa reenumera via USB como um dispositivo UF2 e o OpenMV IDE pode gravar uma nova imagem de firmware.

Um script em execução pode reentrar no bootloader sob demanda chamando machine.bootloader()

import machine

machine.bootloader()

Sistema de arquivos e ordem de boot

O firmware da Nano RP2040 Connect monta um único sistema de arquivos no boot:

  • Flash interna — sempre montada em /flash e usada como diretório de trabalho. Contém main.py e README.txt por padrão; criada no primeiríssimo boot.

Após a montagem, o interpretador então executa scripts a partir de /flash:

  • O boot.py é executado em todo soft reset.

  • O main.py é executado somente no boot a frio, imediatamente após o boot.py.

O main.py padrão fornecido em uma placa recém-gravada apenas faz piscar o canal azul do LED RGB de usuário como um heartbeat (dois pulsos curtos, intervalo curto), para que você saiba que o firmware iniciou corretamente sem nenhum host conectado.

Quando conectado via USB, o /flash é enumerado como uma unidade de armazenamento em massa USB no host, permitindo que você edite boot.py, main.py e quaisquer outros arquivos diretamente. Ejete a unidade antes de resetar a placa para que o host descarregue suas gravações em cache.

Nota

Como o SO trata a unidade como um dispositivo de blocos passivo, os arquivos criados ou modificados pelo código em execução na câmera não aparecerão até que o host remonte a unidade. Se tanto o SO quanto a câmera gravarem no mesmo sistema de arquivos ao mesmo tempo, o SO vencerá e sobrescreverá as alterações feitas pela câmera. Use o cartão SD para quaisquer dados que o script grave de volta e remonte antes de ler esses arquivos a partir do host.

Nota

O canal vermelho do LED RGB de usuário pode acender brevemente enquanto o host está lendo ou gravando na unidade de armazenamento em massa USB — este é um indicador de atividade controlado pelo firmware, não uma falha.

Tamanhos de armazenamento

A Nano RP2040 Connect vem com:

  • /flash — sistema de arquivos FAT de 14 MB, leitura/escrita.

A build da Nano RP2040 não inclui um ROMFS; distribua os módulos Python e os modelos de ML diretamente em /flash.

Bibliotecas de software

Consulte o índice da biblioteca para a lista completa de módulos — incluindo quais são exclusivos da build da Nano RP2040 Connect.