Arduino Nano 33 BLE Sense¶

אזהרה

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

ה‑Arduino Nano 33 BLE Sense הוא לוח בגודל 45 × 18 מ“מ בפורמט Arduino‑Nano הבנוי סביב ה‑Nordic Semiconductor nRF52840 — מעבד יחיד ARM Cortex‑M4 עם FPU הפועל בתדר 64 MHz עם 256 KB של SRAM פנימי ו‑1 MB של זיכרון פלאש (flash) פנימי. ה‑BLE מגיע מהרדיו המובנה בשבב, והלוח נושא IMU בעל 9 צירים, ברומטר LPS22HB, חיישן טמפרטורה / לחות HTS221 / HS3003, חיישן אור סביבתי / צבע / קרבה / מחוות APDS9960, ומיקרופון PDM מסוג MP34DT05. קושחת OpenMV מפעילה את כל אלה מתוך MicroPython.

לגיליון הנתונים המלא, תמונות ומידות ראו את דף המוצר של Arduino Nano 33 BLE Rev2.

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

Nordic nRF52840 Cortex‑M4 עם FPU בתדר 64 MHz עם 256 KB SRAM פנימי ו‑1 MB זיכרון פלאש (flash) פנימי.
Bluetooth LE 5.0 באמצעות הרדיו המובנה בשבב ו‑Nordic SoftDevice s140.
IMU בעל 9 צירים — LSM9DS1 ב‑Rev 1, BMI270 + BMM150 ב‑Rev 2. מנהל ההתקן הקפוא imu מגשש אחר שניהם בעת האתחול.
ברומטר LPS22HB, חיישן טמפרטורה ולחות HTS221 / HS3003, חיישן אור סביבתי / צבע / קרבה / מחוות APDS9960, ומיקרופון PDM מסוג MP34DT05.
מחבר Micro USB עבור הזנה, תכנות ו‑CDC REPL.
22 פיני קלט/פלט למשתמש על מגשרי ה‑Nano הסטנדרטיים — TX/RX, D2–D13 (דיגיטליים), A0–A7 (אנלוגיים).

מפת פינים¶

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

שם הפין	סימוכין	פונקציה
TX	3.3 V	UART1 TX
RX	3.3 V	UART1 RX
D2	3.3 V	PWM
D3	3.3 V	PWM
D4	3.3 V	PWM
D5	3.3 V	PWM
D6	3.3 V	PWM
D7	3.3 V	PWM
D8	3.3 V	PWM
D9	3.3 V	PWM
D10	3.3 V	PWM
D11	3.3 V	PWM / SPI0 MOSI
D12	3.3 V	PWM / SPI0 MISO
D13	3.3 V	PWM / SPI0 SCK
A0	3.3 V	ADC / PWM
A1	3.3 V	ADC / PWM
A2	3.3 V	ADC / PWM
A3	3.3 V	ADC / PWM
A4 / I2C_SDA	3.3 V	ADC / PWM / I2C0 SDA
A5 / I2C_SCL	3.3 V	ADC / PWM / I2C0 SCL
A6	3.3 V	ADC / PWM
A7	3.3 V	ADC / PWM
RESET	3.3 V	לחצו על כפתור ה‑RESET שעל הלוח או משכו ל‑GND כדי לאפס
LED_BUILTIN	—	נורית LED כתומה למשתמש על `D13`
LED_RED	—	ערוץ אדום של נורית RGB LED (פעיל בנמוך)
LED_GREEN	—	ערוץ ירוק של נורית RGB LED (פעיל בנמוך)
LED_BLUE	—	ערוץ כחול של נורית RGB LED (פעיל בנמוך)

אזהרה

פיני הקלט/פלט של ה‑Nano 33 BLE Sense הם 3.3 V בלבד — הם אינם סובלניים ל‑5 V. הזנת 5 V לתוכם תגרום נזק ל‑nRF52840.

פיני הזנה¶

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

ניתן להזין את ה‑Nano 33 BLE Sense דרך כל אחד מהמסלולים:

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

הערה

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

הערה

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

פיני התאוששות וניפוי באגים¶

RESET — גם רפידה חשופה וגם כפתור RESET רגעי בחלק העליון של הלוח, מחוברים לקו האיפוס של ה‑nRF52840. משכו ל‑GND או לחצו על הכפתור כדי לאפס.

ה‑Nano 33 BLE Sense משתמש ב‑איפוס דאבל‑טאפ הסטנדרטי של Arduino כדי להיכנס למאתחל (bootloader) של Arduino. לחצו על כפתור ה‑RESET פעמיים במהירות — הלוח נכנס למצב מאתחל (bootloader) ו‑OpenMV IDE יכול לצרוב תמונת קושחה חדשה.

אותות ה‑SWD של ה‑nRF52840 חשופים על רפידות מצופות בגב הלוח. כל אותות ניפוי הבאגים מקבלים סימוכין ל‑3.3 V.

התקנים היקפיים מובנים¶

נוריות LED¶

ל‑Nano 33 BLE Sense יש נורית 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 33 BLE Sense תומכת בחיישן ה‑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 33 BLE Sense
D0	`D10`
D1	`TX`
D2	`RX`
D3	`D2`
D4	`D3`
D5	`D5`
D6	`D6`
D7	`D4`
HSYNC	`A1`
VSYNC	`D8`
PXCLK	`A0`
MXCLK	`D9`
POWER	`A3`
RESET	`A2`
SCL	`A5` (I²C 0)
SDA	`A4` (I²C 0)

אפיק הבקרה I²C של ה‑OV7670 הוא אותו I²C 0 חיצוני החשוף על A5/A4. החיישן יושב בכתובת 7 ביט 0x21 — התקני משתמש על אפיק זה חייבים להימנע מכתובת זו כאשר המצלמה מחווטת.

IMU¶

ה‑IMU בעל 9 הצירים חשוף דרך מודול imu הקפוא, אשר מזהה אוטומטית אם ללוח יש את ה‑LSM9DS1 (Rev 1) או את ה‑BMI270 + BMM150 (Rev 2) ומציג מחלקה מאוחדת imu.IMU. החיישנים יושבים על אפיק ה‑I²C 1 הפנימי (P14 / P15):

import time
from machine import I2C, Pin
from imu import IMU

bus = I2C(1, scl=Pin("P15"), sda=Pin("P14"))
sensor = IMU(bus)

while True:
    print(sensor.accel())     # (x, y, z) in g
    print(sensor.gyro())      # (x, y, z) in deg/s
    print(sensor.magnet())    # (x, y, z) magnetometer
    time.sleep_ms(100)

לגישה ישירה לתכונות כמו זיהוי הקשה או ה‑FIFO, ייבאו את מנהל ההתקן הקפוא המתאים (lsm9ds1, bmi270, או bmm150) וצרו ממנו מופע על אותו אפיק.

חיישנים סביבתיים¶

הברומטר (LPS22HB) וחיישן הטמפרטורה / לחות (HTS221 ב‑Rev 1, HS3003 ב‑Rev 2) חולקים את אותו אפיק I²C 1 פנימי עם ה‑IMU:

import time
from machine import I2C, Pin
from lps22h import LPS22H
from hts221 import HTS221

bus = I2C(1, scl=Pin("P15"), sda=Pin("P14"))
lps = LPS22H(bus)
try:
    hts = HTS221(bus)
except OSError:
    from hs3003 import HS3003
    hts = HS3003(bus)

while True:
    print("pressure:    %.2f hPa" % lps.pressure())
    print("temperature: %.2f C"   % lps.temperature())
    print("humidity:    %.2f %%"  % hts.humidity())
    time.sleep_ms(500)

אור / צבע / קרבה / מחוות¶

ה‑APDS9960 של Broadcom יושב על אותו אפיק I²C 1 פנימי ומספק חישת אור סביבתי, צבע RGB, קרבה ומחוות:

import time
from machine import I2C, Pin
from apds9960 import uAPDS9960 as APDS9960

bus = I2C(1, scl=Pin("P15"), sda=Pin("P14"))
apds = APDS9960(bus)
apds.enableLightSensor()

while True:
    print("ambient light:", apds.readAmbientLight())
    time.sleep_ms(250)

מיקרופון¶

מיקרופון ה‑PDM מסוג MP34DT05 שעל הלוח נלכד דרך audio — מודול אודיו. כל חוצץ (buffer) מגיע כ‑PCM מסומן בן 16 ביט בתוך bytearray, מוכן להזנה אל ulab/numpy עבור DSP:

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

Bluetooth¶

רדיו ה‑Bluetooth LE 5.0 של ה‑nRF52840 פועל על Nordic SoftDevice s140 וחשוף דרך מודול ubluepy הישן — ממשקי ה‑API המודרניים bluetooth / aioble — BLE אסינכרוני אינם מופעלים בבנייה זו. שני התפקידים זמינים — periferal (שרת GATT, פרסום) ו‑central (משקיף / סורק GAP + התחברות).

פרסמו בתפקיד periferal עם שירות Environmental Sensing יחיד ומאפיין טמפרטורה הניתן להתראה — פונקציית ה‑callback event_handler נורית בעת התחברות, ניתוק וכתיבות CCCD:

from ubluepy import Service, Characteristic, UUID, Peripheral, constants
from machine import LED

def event_handler(event_id, handle, data):
    if event_id == constants.EVT_GAP_CONNECTED:
        LED("LED_GREEN").on()
    elif event_id == constants.EVT_GAP_DISCONNECTED:
        LED("LED_GREEN").off()
        periph.advertise(device_name="Nano 33", services=[svc])

svc = Service(UUID("181A"))                          # Environmental Sensing
char = Characteristic(UUID("2A6E"),                  # Temperature
                      props=Characteristic.PROP_NOTIFY | Characteristic.PROP_READ,
                      attrs=Characteristic.ATTR_CCCD)
svc.addCharacteristic(char)

periph = Peripheral()
periph.addService(svc)
periph.setConnectionHandler(event_handler)
periph.advertise(device_name="Nano 33", services=[svc])

סרקו אחר התקנים מפרסמים סמוכים בתפקיד central:

from ubluepy import Scanner

for entry in Scanner().scan(1_000):                  # 1 second window
    print(entry.addr(), entry.rssi(), "dBm")

ראו את הסימוכין של ubluepy עבור ה‑API המלא — UUID, Service, Characteristic, Peripheral, Scanner, ScanEntry, ומרחב השמות constants.

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

GPIO¶

השתמשו ב‑machine.Pin כדי לקרוא או להפעיל כל אחד מהפינים המודפסים. המוצאים הם 3.3 V CMOS — 15 mA לכל פין, 25 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
UART1	TX	RX

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

from machine import UART

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

I²C¶

אפיק	SDA	SCL
I2C0	`I2C_SDA` / `A4`	`I2C_SCL` / `A5`
I2C1	`P14`	`P15`

שני האפיקים צריכים שהפינים שלהם יועברו במפורש אל machine.I2C

from machine import I2C, Pin

bus0 = I2C(0, scl=Pin("I2C_SCL"), sda=Pin("I2C_SDA"), freq=400_000)
bus0.scan()

bus1 = I2C(1, scl=Pin("P15"), sda=Pin("P14"), freq=400_000)
bus1.scan()

הערה

אפיק 1 הוא אפיק החיישנים הפנימי על P14/P15 (לא על מגשרי המשתמש) — הוא משרת את ה‑IMU, הברומטר, החיישן הסביבתי ו‑APDS9960. מנהלי ההתקן הקפואים של החיישנים משתמשים בו ישירות; קוד משתמש יכול גם לסרוק אותו אך הכתובות כבר תפוסות על ידי החיישנים שעל הלוח.

SPI¶

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

קו ה‑CS אינו מופעל על ידי ההתקן ההיקפי SPI — הגדירו את D10 כמוצא וְהחליפו אותו ידנית סביב ההעברה:

from machine import SPI, Pin

spi = SPI(0, baudrate=10_000_000)
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 על אפיק זה תהבהב את הנורית בקצב שעון האפיק.

ADC¶

ל‑nRF52840 יש שמונה ערוצי ADC בני 12 ביט (SAADC) החשופים על A0–A7, כולם מקבלים סימוכין ל‑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¶

ה‑nRF52840 חושף ארבעה התקני PWM היקפיים (PWM0–PWM3), כל אחד מפעיל ארבעה ערוצים, עבור 16 משבצות PWM חומרתיות בסך הכול. בניגוד ליציאות בעלות פונקציה קבועה, ההתקנים ההיקפיים מנותבים דרך מטריצת ה‑GPIOTE — כל GPIO יכול להיות מוצא PWM, כך שאין מיפוי פין‑לפרוסה. המחיר של גמישות זו הוא שתי מגבלות החרוטות בסיליקון:

כל ארבעת הערוצים בתוך מודול חולקים מחזור/תדר יחיד.
לכל ערוץ יש מחזור פעולה (duty cycle) משלו וקוטביות משלו.

מבחינה רעיונית 16 המשבצות נראות כך:

מודול	ערוץ 0	ערוץ 1	ערוץ 2	ערוץ 3
PWM0	duty	duty	duty	duty
PWM1	duty	duty	duty	duty
PWM2	duty	duty	duty	duty
PWM3	duty	duty	duty	duty

כל שורה פועלת בתדר אחד; ארבעת התאים בשורה מפעילים כל אחד פין שנבחר באופן עצמאי עם מחזור הפעולה (duty cycle) שלו. שורות שונות יכולות לפעול בתדרים שונים לחלוטין.

הפעילו כל פין מודפס (או את הנוריות שעל הלוח) דרך machine.PWM

from machine import Pin, PWM

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

אזהרה

הקצאה אוטומטית צורכת מודול שלם בכל קריאה. כאשר אתם יוצרים PWM ללא ארגומנטי מילות מפתח device=/channel=, מנהל ההתקן תופס את המודול הפנוי הראשון וקושר את הפין שלכם ל‑ערוץ 0 שלו בלבד. שלושת הערוצים הנותרים של אותו מודול נשארים בטלים וניתן להגיע אליהם רק דרך device=/channel= מפורשים. הדבר מגביל קריאות PWM(Pin(...)) ללא עזרה ל‑ארבע לפני שמנהל ההתקן מעלה ValueError: all PWM devices in use — למרות ששתים‑עשרה משבצות עדיין פנויות מבחינה טכנית.

כדי להשתמש ביותר מארבעה PWM, או כדי לחלוק תדר בכוונה בין פינים, העבירו device (0–3) ו‑channel (0–3):

# Two PWMs on the same module → forced to share frequency,
# but each gets its own duty cycle.
pwm_a = PWM(Pin("D3"), device=0, channel=0,
            freq=1_000, duty_u16=32768)
pwm_b = PWM(Pin("D5"), device=0, channel=1,
            freq=1_000, duty_u16=16384)

# A third PWM on a separate module, free to pick any frequency.
pwm_c = PWM(Pin("D6"), device=1, channel=0,
            freq=20_000, duty_u16=49152)

מחזור הפעולה (duty cycle) מקבל duty (0–100%), duty_u16 (0–65535), או duty_ns. הוסיפו invert=1 כדי להפוך את קוטביות המוצא (נוח עבור נורית ה‑RGB הפעילה בנמוך).

הערה

מכיוון שהתדר הוא תכונה ברמת המודול, קריאה ל‑pwm.freq(new_freq) על כל ערוץ של מודול מריצה מחדש את nrfx_pwm_init עבור כל המודול ומשנה את התדר שכל ערוץ אחר החולק אותו רואה.

הערה

התדרים המותרים נעים בערך בין 4 Hz ל‑5.3 MHz, נגזרים משעון הבסיס 16 MHz עם מחלקים מקדימים 1/2/4/8/16/32/64/128 ומונה מחזור בן 15 ביט. מנהל ההתקן בוחר את המחלק הקרוב ביותר אוטומטית — freq() מדווח את הערך המבוקש, לא את הערך המדויק שניתן להשגה.

אפיקים בתוכנה (bit‑banged)¶

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

חיישן תרמי (חיצוני ללוח)¶

הקושחה כוללת את מנהל ההתקן fir — מנהל התקן לחיישן תרמי (fir == far infrared) עבור מצלמות תרמיות מחווטות חיצונית:

MLX90621 — מערך IR בגודל 16 × 4
MLX90640 — מערך IR בגודל 32 × 24
MLX90641 — מערך IR בגודל 16 × 12
AMG8833 — מערך IR בגודל 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 — חווטו את המודול לרפידות I2C_SCL / I2C_SDA (A5 / A4).

תזמון¶

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 כמזהה כדי להשתמש בטיימר וירטואלי (תוכנתי):

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 של ה‑nRF52840 קשור למתנד שעל השבב ואינו שורד אובדן הזנה מלא — הגדירו את הזמן בכל אתחול קר אם זה חשוב ליישום שלכם:

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

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

עדכון קושחה¶

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

import machine

machine.bootloader()

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

קושחת ה‑Nano 33 BLE Sense מעגנת מערכת קבצים יחידה בעת האתחול:

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

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

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

ברירת המחדל main.py המסופקת על לוח שזה עתה נצרב פשוט מהבהבת את הערוץ הכחול של נורית ה‑RGB למשתמש כפעימת לב (שני פולסים קצרים, מרווח קצר), כך שתוכלו לדעת שהקושחה אותחלה כראוי ללא מארח מחובר.

/flash אינו חשוף ככונן אחסון המוני USB בלוח זה.

גדלי אחסון¶

ה‑Nano 33 BLE Sense מסופק עם:

/flash — מערכת קבצים FAT בגודל 64 KB, קריאה/כתיבה.

בניית ה‑Nano 33 BLE Sense אינה כוללת ROMFS; ספקו מודולי Python על /flash ישירות.

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

ראו את אינדקס הספרייה לרשימה המלאה של המודולים — כולל אלו הייחודיים לבניית ה‑Nano 33 BLE Sense.