Arduino Nano RP2040 Connect

Aviso

Esta placa já não tem suporte. A última versão do firmware OpenMV para o Arduino Nano RP2040 Connect é a 4.7.0. Não serão lançadas mais atualizações de firmware, correções de erros ou novas funcionalidades para este alvo. A informação abaixo é preservada para utilizadores que executem a versão 4.7.0 ou anterior.

O Arduino Nano RP2040 Connect é uma placa no formato Arduino Nano de 45 × 18 mm construída em torno do Raspberry Pi RP2040 — um processador ARM Cortex‑M0+ duplo a 133 MHz com 264 KB de SRAM interna. O Wi‑Fi e BLE são fornecidos por um módulo U‑blox NINA‑W102, e a placa inclui um IMU LSM6DSOX de 6 eixos e um microfone PDM MP34DT06. O firmware OpenMV gere todos estes componentes a partir do MicroPython.

Arduino Nano RP2040 Connect

Para a ficha técnica completa, fotografias e dimensões, consulte a página do produto Arduino Nano RP2040 Connect.

Destaques

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

  • 16 MB de flash QSPI externa.

  • Módulo U‑blox NINA‑W102 que fornece Wi‑Fi 2.4 GHz b/g/n e Bluetooth 4.2 (BR/EDR + LE).

  • IMU LSM6DSOX de 6 eixos e microfone PDM MP34DT06.

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

  • 22 pinos de E/S de utilizador nos cabeçalhos Nano padrão — TX/RX, D2–D13 (digitais), A0–A7 (analógicos).

Pinout

Arduino Nano RP2040 Connect Pinout

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

prima o botão RESET da placa ou ligue a GND para reiniciar

REC

3.3 V

BOOTSEL — ligue a alto na ligação à corrente para entrar no bootloader ROM do RP2040

LED_BUILTIN

—

LED de utilizador cor de 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 E/S do Nano RP2040 Connect são apenas 3.3 V — não são tolerantes a 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 de comutação integrado. Também recebe alimentação via díodo a partir do rail USB de 5 V, pelo que USB e VIN podem estar presentes ao mesmo tempo sem se retroalimentarem.

  • +5V — não ligado por defeito.

  • +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 — massa comum.

O Nano RP2040 Connect pode ser alimentado por qualquer um dos caminhos:

  • Micro USB — fornece 5 V ao regulador integrado.

  • Pino VIN — aplique uma tensão regulada de 4 – 20 V.

Nota

Uma ponte de solda na parte inferior da placa liga +5V ao rail USB de 5 V. Feche-a para que o pino de cabeçalho +5V transporte efetivamente 5 V.

Nota

Uma ponte de solda normalmente fechada na saída do regulador de comutação 4–20 V integrado pode ser cortada para desativar o regulador, permitindo que a placa seja alimentada diretamente a partir de uma fonte externa de 3.3 V em +3V3.

Pinos de recuperação e depuração

  • RESET — tanto um pad exposto como um botão RESET momentâneo na parte superior da placa, ligados à linha NRST do RP2040. Ligue a GND ou prima o botão para reiniciar.

  • REC — pad exposto. Manter REC em alto ao ligar à corrente (ou enquanto pressiona RESET) coloca o RP2040 no seu bootloader ROM; a placa reenumera como um dispositivo de armazenamento USB de massa com o nome RPI-RP2 e aceita uma imagem de firmware .uf2.

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

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

Periféricos integrados

LEDs

O Nano RP2040 Connect tem um LED RGB de utilizador — controlado através dos canais LED_RED, LED_GREEN e LED_BLUE serigrafados — mais um LED_BUILTIN cor de laranja separado em D13. 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 rail de +3.3 V está ativo e não é controlável pelo utilizador.

Sensor de câmara

O firmware OpenMV no Nano RP2040 Connect suporta o sensor CMOS paralelo OmniVision OV7670. A placa não tem sensor de imagem integrado — ligue um módulo OV7670 aos pinos de cabeçalho serigrafados indicados abaixo e controle-o através do módulo csi — sensores de câmara

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 liga-os da seguinte forma:

Sinal do sensor

Pino 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 controlo I²C do OV7670 é partilhado com o IMU integrado e o ATECC608A no I²C 0. O sensor encontra-se no endereço de 7 bits 0x21 — os dispositivos do utilizador no barramento 0 também devem evitar este endereço quando a câmara está ligada.

IMU

O LSM6DSOX integrado de 6 eixos (acelerómetro + giroscópio) encontra-se em I2C0. O machine.I2C(0) do port rp2 usa por defeito um conjunto de pinos diferente, por isso passe explicitamente os pads SDA/SCL serigrafados. Utilize o controlador frozen 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 integrado é 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 integrado é exposto via network — configuração de rede como 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 Bluetooth 4.2 LE. Utilize aioble — BLE Assíncrono para BLE compatível com asyncio — por exemplo, anuncie como periférico e aguarde a ligação de um 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

Utilize machine.Pin para ler ou controlar qualquer um dos pinos serigrafados. As saídas são CMOS de 3.3 V, com 50 mA de sink 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 pode também disparar uma interrupção em transições de aresta:

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

Utilize os nomes serigrafados TX/RX com machine.UART

from machine import UART

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

Nota

machine.UART(1) existe mas está reservado para o módulo NINA‑W102 integrado (o link BLE); não o utilize diretamente.

I²C

Barramento

SDA

SCL

I2C0

SDA / A4

SCL / A5

I2C1

A0

A1

Ambos os barramentos necessitam que os seus pinos sejam passados explicitamente a 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 integrados partilham o barramento 0 — os dispositivos do utilizador neste barramento devem evitar os seus endereços:

  • 0x6A — IMU LSM6DSOX

  • 0x60 — ATECC608A‑MAHDA‑T

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

Nota

Os pads SDA / SCL (barramento 0) têm resistências de pull-up integradas para 3.3 V, pelo que não são necessárias resistências de pull-up externas para dispositivos nesse barramento. A0 / A1 (barramento 1) não as têm — adicione pull-ups externas quando utilizar o barramento 1.

O mesmo hardware também pode ser utilizado 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

O port rp2 não pré-configura os pinos do SPI0 nesta placa, por isso 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

D13 funciona também como o LED_BUILTIN cor de laranja — ao conduzir SPI neste barramento, o LED piscará em sincronia com o relógio do barramento.

Nota

machine.SPI(1) existe mas está reservado para o módulo NINA‑W102 integrado (o link SPI Wi-Fi/BLE); não o utilize diretamente.

ADC

O RP2040 tem quatro canais ADC de 12 bits expostos em A0–A3, todos referenciados a 3.3 V — read_u16 devolve 0–65535 para 0–3.3 V no pino. O pino AREF da placa não está ligado, pelo que 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

Fatia / 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

Controle 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 partilham canais de fatia PWM:

  • PWM0 A está em TX e em D4.

  • PWM0 B está em RX e em D5.

  • PWM2 A está em D8 e em D12.

  • PWM2 B está em D9 e em D10.

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

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

Escolha um consumidor por canal de fatia. Os canais A e B dentro da mesma fatia partilham o período (frequência), mas cada um tem o seu próprio ciclo de trabalho.

Barramentos por software (bit‑banging)

machine.SoftI2C e machine.SoftSPI funcionam em qualquer GPIO se precisar de um barramento adicional.

Sensor térmico (externo)

O firmware inclui o controlador fir — driver de sensor térmico (fir == infravermelho longínquo) para um imagiador térmico AMG8833 8×8 ligado externamente. Ligue o módulo ao barramento I²C indicado abaixo e, em seguida, leia fotogramas 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 controlador fir comunica com o sensor apenas via I²C 0 — ligue o módulo aos pads SCL / SDA serigrafados. O endereço de 7 bits do sensor (0x69) não deve ser utilizado por nenhum outro dispositivo nesse barramento.

Temporização

time

O módulo time abrange atrasos bloqueantes, ticks monotónicos e medição do 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)

Temporizadores virtuais

machine.Timer agenda callbacks periódicos ou únicos sem consumir um slot de temporizador de hardware. Passe -1 como id para utilizar um temporizador virtual (por 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 libertar o slot.

Relógio de tempo real

machine.RTC mantém a hora do relógio entre reinicializações. O RTC do RP2040 está ligado ao oscilador interno e não sobrevive a uma perda total de energia — defina a hora em cada arranque a frio se isso for relevante para a 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 reinicia a placa se a aplicação ficar bloqueada. Uma vez iniciado, não pode ser parado nem reconfigurado — alimente-o periodicamente dentro do seu ciclo principal:

from machine import WDT

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

Informações de arranque e runtime

Atualização de firmware (UF2)

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

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

import machine

machine.bootloader()

Sistema de ficheiros e ordem de arranque

O firmware do Nano RP2040 Connect monta um único sistema de ficheiros no arranque:

  • Flash interna — sempre montada em /flash e utilizada como diretório de trabalho. Contém main.py e README.txt por defeito; criada no primeiro arranque.

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

  • boot.py é executado em cada reinicialização soft.

  • main.py é executado apenas no arranque a frio, imediatamente após boot.py.

O main.py predefinido fornecido numa placa recém-flashada faz piscar o canal azul do LED RGB de utilizador como batimento cardíaco (dois pulsos curtos, pausa curta), para que possa verificar que o firmware arrancou corretamente sem qualquer host ligado.

Quando ligada via USB, /flash enumera como uma unidade de armazenamento USB de massa no host, permitindo editar boot.py, main.py e quaisquer outros ficheiros diretamente. Ejete a unidade antes de reiniciar a placa para que o host liberte as suas escritas em cache.

Nota

Como o sistema operativo trata a unidade como um dispositivo de blocos passivo, os ficheiros criados ou modificados por código em execução na câmara não aparecem até que o host remonte a unidade. Se tanto o sistema operativo como a câmara escreverem no mesmo sistema de ficheiros ao mesmo tempo, o sistema operativo prevalece e substitui as alterações feitas pela câmara. Utilize o cartão SD para quaisquer dados que o script escreva, e remonte antes de ler esses ficheiros a partir do host.

Nota

O canal vermelho do LED RGB de utilizador pode acender brevemente enquanto o host está a ler ou a escrever na unidade de armazenamento USB de massa — trata-se de um indicador de atividade controlado pelo firmware, não de uma falha.

Tamanhos de armazenamento

O Nano RP2040 Connect é fornecido com:

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

A compilação do Nano RP2040 não inclui ROMFS; distribua módulos Python e modelos ML diretamente em /flash.

Bibliotecas de software

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