Arduino Nano RP2040 Connect¶

אזהרה

לוח זה אינו נתמך עוד. גרסת הקושחה האחרונה של OpenMV עבור ה-Arduino Nano RP2040 Connect היא 4.7.0. לא יונפקו עדכוני קושחה נוספים, תיקוני באגים או מאפיינים חדשים עבור יעד זה. המידע שלהלן נשמר עבור משתמשים המריצים גרסה 4.7.0 או מוקדמת יותר.

ה-Arduino Nano RP2040 Connect הוא לוח במידות 45 × 18 מ“מ בפורמט Arduino Nano, הבנוי סביב ה-Raspberry Pi RP2040 — מעבד דו-ליבתי ARM Cortex‑M0+ הפועל ב-133 MHz עם 264 KB של SRAM פנימי. WiFi ו-BLE מסופקים על ידי מודול U‑blox NINA‑W102, והלוח נושא חיישן IMU בעל 6 צירים מסוג LSM6DSOX ומיקרופון PDM מסוג MP34DT06. קושחת OpenMV מנהלת את כל אלה מתוך MicroPython.

לעיון בגיליון הנתונים המלא, בתמונות ובמידות, ראו את עמוד המוצר Arduino Nano RP2040 Connect.

עיקרי הדברים¶

Raspberry Pi RP2040 דו-ליבתי ARM Cortex‑M0+ ב-133 MHz עם 264 KB SRAM פנימי.
זיכרון פלאש (flash) חיצוני QSPI בנפח 16 MB.
מודול U‑blox NINA‑W102 המספק Wi‑Fi b/g/n ב-2.4 GHz ו-Bluetooth 4.2 (BR/EDR + LE).
חיישן IMU בעל 6 צירים מסוג LSM6DSOX ומיקרופון PDM מסוג MP34DT06.
מחבר Micro USB עבור הזנת חשמל, תכנות ו-REPL מסוג CDC.
22 פיני קלט/פלט למשתמש על מחברי ה-Nano הסטנדרטיים — TX/RX, D2–D13 (דיגיטלי), A0–A7 (אנלוגי).

מפת פינים¶

סימוכין לפינים¶

שם הפין	ייחוס	פונקציה
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	לחצו על לחצן ה-RESET שעל הלוח או משכו ל-GND כדי לאפס
REC	3.3 V	BOOTSEL — משכו גבוה בעת הפעלת החשמל כדי להיכנס למאתחל (bootloader) ה-ROM של ה-RP2040
LED_BUILTIN	—	נורית LED כתומה למשתמש על `D13`
LED_RED	—	ערוץ אדום של נורית RGB LED
LED_GREEN	—	ערוץ ירוק של נורית RGB LED
LED_BLUE	—	ערוץ כחול של נורית RGB LED

אזהרה

פיני הקלט/פלט של ה-Nano RP2040 Connect הם 3.3 V בלבד — הם אינם סובלניים ל-5 V. הזנת 5 V לתוכם תגרום נזק ל-RP2040.

פיני חשמל¶

VIN — כניסת 4 – 20 V. מזינה את הלוח דרך מווסת המיתוג שעל הלוח. מוזנת גם דרך דיודה ממסילת ה-5 V של ה-USB, כך ש-USB ו-VIN יכולים להיות נוכחים בו-זמנית מבלי להזין זה את זה לאחור.
+5V — לא מחובר כברירת מחדל.
+3V3 — מוצא מווסת 3.3 V.
AREF — פין ייחוס אנלוגי. אינו מחווט ל-RP2040 בלוח זה — ה-ADC תמיד מיוחס ל-3.3 V.
GND — אדמה משותפת.

ניתן להזין חשמל ל-Nano RP2040 Connect דרך כל אחד מהמסלולים:

Micro USB — מספק 5 V למווסת שעל הלוח.
פין VIN — הזינו מקור מיוצב של 4 – 20 V.

הערה

מגשר הלחמה בתחתית הלוח מגשר בין +5V למסילת ה-5 V של ה-USB. סגרו אותו כדי שפין הכותרת +5V יישא בפועל 5 V.

הערה

ניתן לחתוך מגשר הלחמה סגור-כרגיל במוצא מווסת המיתוג של 4–20 V שעל הלוח כדי להשבית את המווסת, כך שניתן יהיה להזין את הלוח ישירות ממקור חיצוני של 3.3 V על +3V3.

פיני שחזור וניפוי שגיאות¶

RESET — גם רפידה חשופה וגם לחצן RESET רגעי בחלקו העליון של הלוח, המחוברים לקו ה-NRST של ה-RP2040. משכו ל-GND או לחצו על הלחצן כדי לאפס.
REC — רפידה חשופה. החזקת REC גבוה בעת הפעלת החשמל (או תוך כדי לחיצה על RESET) מכניסה את ה-RP2040 למאתחל (bootloader) ה-ROM שלו; הלוח מתאתחל מחדש כונן אחסון המוני של USB בשם RPI-RP2 ומקבל קובץ קושחה מסוג .uf2.

ה-Nano RP2040 Connect משתמש ב-איפוס בהקשה כפולה הסטנדרטי של Arduino כדי להיכנס למאתחל (bootloader) של Arduino. לחצו במהירות על לחצן ה-RESET פעמיים — הלוח מתאתחל מחדש דרך USB כהתקן UF2 ו-OpenMV IDE יכול לצרוב קובץ קושחה חדש.

אותות ה-SWD של ה-RP2040 חשופים על רפידות מצופות בגב הלוח, ממש מתחת למודול ה-NINA. כל אותות ניפוי השגיאות מיוחסים ל-3.3 V.

התקנים היקפיים על הלוח¶

נוריות LED¶

ל-Nano RP2040 Connect יש נורית RGB LED למשתמש — המונעת דרך הערוצים המסומנים LED_RED, LED_GREEN ו-LED_BLUE — בנוסף לנורית כתומה נפרדת LED_BUILTIN על D13. כל ארבעתן ניתנות לשליטה תוכנתית דרך machine.LED

from machine import LED

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

נורית חשמל ירוקה נפרדת על הלוח נדלקת בכל פעם שמסילת ה-+3.3 V פעילה ואינה ניתנת לשליטה על ידי המשתמש.

חיישן מצלמה¶

קושחת OpenMV על ה-Nano RP2040 Connect תומכת בחיישן CMOS מקבילי מסוג OmniVision OV7670. ללוח אין חיישן תמונה על-לוחי — חווטו מודול OV7670 לפיני הכותרת המסומנים המפורטים להלן והפעילו אותו דרך מודול csi — חיישני מצלמה

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

הערה

ה-OV7670 דורש 14 פינים. הקושחה מחווטת אותם כדלקמן:

אות חיישן	פין 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)

אפיק הבקרה I²C של ה-OV7670 משותף עם ה-IMU שעל הלוח ועם ה-ATECC608A על I²C 0. החיישן ממוקם בכתובת 7-ביט 0x21 — התקני משתמש על אפיק 0 חייבים גם הם להימנע מכתובת זו כאשר המצלמה מחווטת.

IMU¶

מד התאוצה + הג’ירוסקופ בעל 6 הצירים LSM6DSOX שעל הלוח ממוקם על I2C0. ה-machine.I2C(0) של פורט ה-rp2 מוגדר כברירת מחדל למערך פינים שונה, לכן העבירו את רפידות ה-SDA/SCL המסומנות במפורש. השתמשו במנהל ההתקן הקפוא 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)

מיקרופון¶

מיקרופון ה-PDM שעל הלוח מסוג MP34DT06 נלכד דרך audio — מודול אודיו באמצעות אחד מבלוקי ה-PIO של ה-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¶

מודול ה-NINA‑W102 שעל הלוח חשוף דרך network — הגדרת רשת כממשק תחנה:

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¶

אותו מודול NINA חושף גם Bluetooth 4.2 LE. השתמשו ב-aioble — BLE אסינכרוני עבור BLE ידידותי ל-asyncio — לדוגמה, פרסמו כהתקן היקפי והמתינו שיחידה מרכזית תתחבר:

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

סימוכין לאפיקים¶

GPIO¶

השתמשו ב-machine.Pin כדי לקרוא או להפעיל כל אחד מהפינים המסומנים. המוצאים הם 3.3 V CMOS, ספיגה כוללת של 50 mA על פני כל ה-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())

כל פין קלט יכול גם להפעיל פסיקה במעברי קצה:

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

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

UART¶

אפיק	TX	RX
UART0	TX	RX

השתמשו בשמות המסומנים TX/RX עם machine.UART

from machine import UART

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

הערה

machine.UART(1) קיים אך שמור עבור מודול ה-NINA‑W102 שעל הלוח (קישור ה-BLE); אל תשתמשו בו ישירות.

I²C¶

אפיק	SDA	SCL
I2C0	`SDA` / `A4`	`SCL` / `A5`
I2C1	`A0`	`A1`

שני האפיקים זקוקים להעברת הפינים שלהם במפורש ל-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()

הערה

שני שבבים שעל הלוח חולקים את אפיק 0 — התקני משתמש על אפיק זה חייבים להימנע מכתובותיהם:

0x6A — LSM6DSOX IMU
0x60 — ATECC608A‑MAHDA‑T

שימוש ב-A0/A1 כ-I²C מנצל אותם עבור האפיק, כך שהם אינם יכולים לשמש בו-זמנית כקלטי ADC.

הערה

רפידות ה-SDA / SCL (אפיק 0) כוללות נגדי משיכה-מעלה על הלוח ל-3.3 V, כך שאין צורך בנגדי משיכה-מעלה חיצוניים עבור התקנים על אותו אפיק. A0 / A1 (אפיק 1) אינם כוללים — הוסיפו נגדי משיכה-מעלה חיצוניים בעת שימוש באפיק 1.

ניתן להשתמש באותה חומרה גם במצב יעד (slave) דרך machine.I2CTarget כדי לחשוף אזור זיכרון לבקר I²C אחר:

from machine import I2CTarget

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

SPI¶

אפיק	MOSI	MISO	SCK	CS
SPI0	D11	D12	D13	D10

פורט ה-rp2 אינו מגדיר מראש את הפינים של SPI0 בלוח זה, לכן העבירו את הרפידות המסומנות במפורש בעת יצירת האפיק:

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)

הערה

D13 משמש גם כנורית הכתומה LED_BUILTIN — הפעלת SPI על אפיק זה תהבהב את הנורית בהתאם לשעון האפיק.

הערה

machine.SPI(1) קיים אך שמור עבור מודול ה-NINA‑W102 שעל הלוח (קישור ה-SPI של Wi-Fi/BLE); אל תשתמשו בו ישירות.

ADC¶

ל-RP2040 יש ארבעה ערוצי ADC של 12 ביט החשופים על A0–A3, כולם מיוחסים ל-3.3 V — read_u16 מחזיר 0–65535 על פני 0–3.3 V בפין. פין ה-AREF של הלוח אינו מחווט, לכן הייחוס הוא תמיד 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¶

פין	פרוסה / ערוץ
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

הפעילו כל אחד מהם דרך machine.PWM

from machine import Pin, PWM

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

הערה

מספר פינים חולקים ערוצי פרוסת PWM:

PWM0 A נמצא על TX וגם D4.
PWM0 B נמצא על RX וגם D5.
PWM2 A נמצא על D8 וגם D12.
PWM2 B נמצא על D9 וגם D10.
PWM6 A נמצא על D16/A2 וגם D18/A4/SDA.
PWM6 B נמצא על D17/A3 וגם D19/A5/SCL.

בחרו צרכן אחד לכל ערוץ פרוסה. ערוצים A ו-B בתוך אותה פרוסה חולקים את המחזור (התדר) שלהם אך לכל אחד יש מחזור עבודה משלו.

אפיקים בהנעת ביטים תוכנתית¶

machine.SoftI2C ו-machine.SoftSPI עובדים על כל GPIO אם אתם זקוקים לאפיק נוסף.

חיישן תרמי (חוץ-לוחי)¶

הקושחה כוללת את מנהל ההתקן fir — מנהל התקן לחיישן תרמי (fir == far infrared) עבור מצלמה תרמית חיצונית מחווטת מסוג AMG8833 בגודל 8×8. חברו את המודול לאפיק ה-I²C המפורט להלן, ואז קראו פריימים עם 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 מתקשר עם החיישן רק דרך I²C 0 — חווטו את המודול לרפידות ה-SCL / SDA המסומנות. אסור שכתובת ה-7-ביט של החיישן (0x69) תהיה בשימוש על ידי התקן אחר כלשהו על אותו אפיק.

תזמון¶

time¶

מודול ה-time מכסה השהיות חוסמות, טיקים מונוטוניים ומדידת זמן שחלף:

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)

טיימרים וירטואליים¶

machine.Timer מתזמן פונקציות callback מחזוריות או חד-פעמיות מבלי לצרוך משבצת טיימר חומרתית. העבירו -1 כ-id כדי להשתמש בטיימר וירטואלי (תוכנתי):

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

ערכי המחזור הם במילישניות. קראו ל-deinit() כדי לעצור ולשחרר את המשבצת.

שעון זמן-אמת¶

machine.RTC שומר על זמן שעון-קיר לאורך איפוסים. ה-RTC של ה-RP2040 מחובר למתנד שעל-השבב ואינו שורד אובדן חשמל מלא — הגדירו את הזמן בכל אתחול קר אם הדבר חשוב ליישום שלכם:

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 מאפס את הלוח אם היישום נתקע. לאחר שהופעל לא ניתן לעצור אותו או להגדירו מחדש — האכילו אותו מעת לעת בתוך הלולאה הראשית שלכם:

from machine import WDT

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

מידע אתחול וזמן ריצה¶

עדכון קושחה (UF2)¶

ה-Nano RP2040 Connect משתמש ב-איפוס בהקשה כפולה הסטנדרטי של Arduino כדי להיכנס למאתחל (bootloader) של Arduino. לחצו במהירות על לחצן האיפוס פעמיים — הלוח מתאתחל מחדש דרך USB כהתקן UF2 ו-OpenMV IDE יכול לצרוב קובץ קושחה חדש.

סקריפט פעיל יכול להיכנס מחדש למאתחל (bootloader) לפי דרישה על ידי קריאה ל-machine.bootloader()

import machine

machine.bootloader()

מערכת קבצים וסדר אתחול¶

קושחת ה-Nano RP2040 Connect מעגנת מערכת קבצים יחידה בעת האתחול:

זיכרון פלאש (flash) פנימי — תמיד מעוגן ב-/flash ומשמש כספריית העבודה. מחזיק את main.py ו-README.txt כברירת מחדל; נוצר באתחול הראשון ממש.

לאחר העיגון, המפרש מריץ אז סקריפטים מ-/flash:

boot.py מורץ בכל איפוס רך.
main.py מורץ רק באתחול קר, מיד לאחר boot.py.

ברירת המחדל של main.py המשולח על לוח שצורב לא מכבר רק מהבהב את הערוץ הכחול של נורית ה-RGB LED למשתמש כפעימת לב (שתי פעימות קצרות, מרווח קצר), כך שתוכלו לדעת שהקושחה אותחלה כראוי ללא חיבור מארח כלשהו.

כאשר מחובר דרך USB, /flash מתאתחל ככונן אחסון המוני של USB במארח, ומאפשר לכם לערוך את boot.py, main.py וכל קובץ אחר ישירות. הוציאו את הכונן לפני איפוס הלוח כדי שהמארח ישטוף את כתיבותיו השמורות במטמון.

הערה

מכיוון שמערכת ההפעלה מתייחסת לכונן כהתקן בלוקים פסיבי, קבצים שנוצרו או שונו על ידי קוד הפועל במצלמה לא יופיעו עד שהמארח יעגן מחדש את הכונן. אם גם מערכת ההפעלה וגם המצלמה כותבות לאותה מערכת קבצים בו-זמנית, מערכת ההפעלה תנצח ותדרוס שינויים שבוצעו על ידי המצלמה. השתמשו בכרטיס ה-SD עבור כל נתון שהסקריפט כותב חזרה, ועגנו מחדש לפני קריאת קבצים אלה מהמארח.

הערה

הערוץ האדום של נורית ה-RGB LED למשתמש עשוי להידלק לרגע בעת שהמארח קורא מכונן האחסון ההמוני של USB או כותב אליו — זהו מחוון פעילות מונע-קושחה, לא תקלה.

גדלי אחסון¶

ה-Nano RP2040 Connect משולח עם:

/flash — מערכת קבצים FAT בנפח 14 MB, קריאה/כתיבה.

בניית ה-Nano RP2040 אינה כוללת ROMFS; שלחו מודולי Python ומודלי ML על /flash ישירות.

ספריות תוכנה¶

ראו את אינדקס הספרייה לרשימה המלאה של המודולים — כולל אלה הייחודיים לבניית ה-Nano RP2040 Connect.