Arduino Nano 33 BLE Sense

Figyelem

Ez a kártya már nem támogatott. Az Arduino Nano 33 BLE Sense utolsó OpenMV firmware-kiadása a 4.7.0. Ehhez a célplatformhoz nem jelennek meg további firmware-frissítések, hibajavítások vagy új funkciók. Az alábbi információkat a 4.7.0-s vagy korábbi verziót futtató felhasználók kedvéért őrizzük meg.

Az Arduino Nano 33 BLE Sense egy 45 × 18 mm-es, Arduino-Nano-formátumú kártya, amely a Nordic Semiconductor nRF52840 köré épül — ez egy egyetlen, 64 MHz-en futó, FPU-val ellátott ARM Cortex-M4, 256 KB belső SRAM-mal és 1 MB belső flash memóriával. A BLE a chipen belüli rádióból származik, és a kártya tartalmaz egy 9 tengelyű IMU-t, egy LPS22HB barométert, egy HTS221 / HS3003 hőmérséklet- / páratartalom-érzékelőt, egy APDS9960 környezeti fény / szín / közelség / gesztus érzékelőt, valamint egy MP34DT05 PDM mikrofont. Az OpenMV firmware mindezeket MicroPythonból vezérli.

A teljes adatlapot, fényképeket és méreteket lásd az Arduino Nano 33 BLE Rev2 termékoldalon.

Kiemelt jellemzők

• Nordic nRF52840 Cortex-M4 FPU-val, 64 MHz-en, 256 KB belső SRAM és 1 MB belső flash memória.

• Bluetooth LE 5.0 a chipen belüli rádión és a Nordic SoftDevice s140-en keresztül.

• 9 tengelyű IMU — LSM9DS1 a Rev 1 esetén, BMI270 + BMM150 a Rev 2 esetén. A beégetett imu meghajtó induláskor mindkettőt felderíti.

• LPS22HB barométer, HTS221 / HS3003 hőmérséklet- és páratartalom-érzékelő, APDS9960 környezeti fény / szín / közelség / gesztus érzékelő, valamint MP34DT05 PDM mikrofon.

• Micro USB csatlakozó a tápellátáshoz, a programozáshoz és egy CDC REPL-hez.

• 22 felhasználói I/O láb a szabványos Nano fejléceken — TX/RX, D2–D13 (digitális), A0–A7 (analóg).

Lábkiosztás

Lábkiosztási referencia

Láb neve	Referencia	Funkció
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	nyomja meg a kártyán lévő RESET gombot, vagy húzza GND-re a visszaállításhoz
LED_BUILTIN	—	Narancssárga felhasználói LED a D13 lábon
LED_RED	—	RGB LED piros csatorna (aktív alacsony)
LED_GREEN	—	RGB LED zöld csatorna (aktív alacsony)
LED_BLUE	—	RGB LED kék csatorna (aktív alacsony)

Figyelem

A Nano 33 BLE Sense I/O lábai csak 3.3 V-osak — nem 5 V-tűrők. Ha 5 V-ot vezet rájuk, az károsítja az nRF52840-et.

Tápellátási lábak

• VIN — 4.5 – 21 V bemenet. A kártyát a fedélzeti feszültségszabályozón keresztül táplálja. Egy diódán keresztül az USB 5 V-os sínjéről is kap táplálást, így az USB és a VIN egyszerre is jelen lehet anélkül, hogy egymást visszatáplálnák.

• +5V — alapértelmezetten nincs bekötve.

• +3V3 — a 3.3 V-os feszültségszabályozó kimenete.

• AREF — analóg referencia láb. Ezen a kártyán nincs bekötve az nRF52840-be — az ADC mindig a 3.3 V-hoz van referálva.

• GND — közös föld.

A Nano 33 BLE Sense bármelyik úton táplálható:

• Micro USB — 5 V-ot biztosít a fedélzeti feszültségszabályozónak.

• VIN láb — egy szabályozott 4.5 – 21 V-os tápforrás vezethető rá.

Megjegyzés

A kártya alján egy VUSB feliratú forrasztható áthidalás köti össze a +5V-ot az USB 5 V-os sínjével. Zárja le, hogy a +5V fejlécláb valóban 5 V-ot vezessen.

Megjegyzés

A fedélzeti 4.5–21 V-os kapcsolóüzemű feszültségszabályozó kimenetén egy alaphelyzetben zárt forrasztható áthidalás elvágható a szabályozó letiltásához, így a kártya közvetlenül egy külső 3.3 V-os tápforrásról is táplálható a +3V3 lábon.

Helyreállítási és hibakeresési lábak

• RESET — egy kivezetett forrasztási felület és egy pillanatkapcsoló RESET gomb is van a kártya tetején, amelyek az nRF52840 reset vonalához kapcsolódnak. Húzza GND-re, vagy nyomja meg a gombot a visszaállításhoz.

A Nano 33 BLE Sense az Arduino szabványos dupla koppintásos visszaállítását használja az Arduino rendszerbetöltőjének eléréséhez. Nyomja meg gyorsan kétszer a RESET gombot — a kártya rendszerbetöltő módba lép, és az OpenMV IDE új firmware-képet írhat rá.

Az nRF52840 SWD jelei a kártya hátoldalán lévő bevont forrasztási felületeken vannak kivezetve. Minden hibakeresési jel 3.3 V-hoz referált.

Fedélzeti perifériák

LED-ek

A Nano 33 BLE Sense rendelkezik egy felhasználói RGB LED-del — amelyet a szitanyomott LED_RED, LED_GREEN és LED_BLUE csatornákon keresztül vezérelnek —, valamint egy különálló narancssárga LED_BUILTIN-nal a D13 lábon. Mind a négy szoftveresen vezérelhető a machine.LED segítségével:

from machine import LED

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

A kártyán egy különálló zöld tápellátás LED világít, amikor a +3.3 V-os sín aktív, és ez nem vezérelhető a felhasználó által.

Kamera-érzékelő

A Nano 33 BLE Sense OpenMV firmware-je támogatja az OmniVision OV7670 párhuzamos CMOS érzékelőt. A kártyán nincs fedélzeti képérzékelő — kösse be egy OV7670 modult az alább felsorolt szitanyomott fejléclábakhoz, és vezérelje a csi — kameraérzékelők modulon keresztül:

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

Megjegyzés

Az OV7670 14 lábat igényel. A firmware ezeket a következőképpen köti be:

Érzékelő jele	Nano 33 BLE Sense láb
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)

Az OV7670 I²C vezérlőbusza ugyanaz a külső I²C 0, amely az A5/A4 lábakon van kivezetve. Az érzékelő a 0x21 7 bites címen helyezkedik el — a buszon lévő felhasználói eszközöknek el kell kerülniük ezt a címet, amikor a kamera be van kötve.

IMU

A 9 tengelyű IMU a beégetett imu modulon keresztül érhető el, amely automatikusan felismeri, hogy a kártya az LSM9DS1-et (Rev 1) vagy a BMI270 + BMM150-et (Rev 2) tartalmazza, és egységes imu.IMU osztályt biztosít. Az érzékelők a belső I²C 1 buszon helyezkednek el (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)

A koppintásérzékeléshez vagy a FIFO-hoz hasonló funkciók közvetlen eléréséhez importálja a megfelelő beégetett meghajtót (lsm9ds1, bmi270 vagy bmm150), és példányosítsa ugyanazon a buszon.

Környezeti érzékelők

A barométer (LPS22HB) és a hőmérséklet- / páratartalom-érzékelő (HTS221 a Rev 1 esetén, HS3003 a Rev 2 esetén) ugyanazon a belső I²C 1 buszon osztozik az IMU-val:

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)

Fény / szín / közelség / gesztus

A Broadcom APDS9960 ugyanazon a belső I²C 1 buszon helyezkedik el, és környezeti fény, RGB szín, közelség és gesztus érzékelést biztosít:

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)

Mikrofon

A fedélzeti MP34DT05 PDM mikrofon a audio — Audio modul segítségével rögzíthető. Minden puffer előjeles 16 bites PCM bytearray formájában érkezik, készen arra, hogy a ulab/numpy által DSP-re kerüljön:

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

Az nRF52840 Bluetooth LE 5.0 rádiója a Nordic SoftDevice s140-en fut, és a régi ubluepy modulon keresztül érhető el — a modern bluetooth / aioble — Aszinkron BLE API-k nincsenek engedélyezve ebben a buildben. Mind a periféria (GATT szerver, hirdetés), mind a központi (GAP megfigyelő / szkenner + csatlakozás) szerepkör elérhető.

Hirdetés perifériaként egyetlen Environmental Sensing szolgáltatással és egy értesíthető hőmérséklet-jellemzővel — az event_handler visszahívás csatlakozáskor, kapcsolatbontáskor és CCCD íráskor aktiválódik:

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

Közeli hirdető eszközök keresése központi szerepkörben:

from ubluepy import Scanner

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

A teljes API-t lásd a ubluepy referenciában — UUID, Service, Characteristic, Peripheral, Scanner, ScanEntry, valamint a constants névtér.

Buszreferencia

GPIO

Használja a machine.Pin osztályt bármely szitanyomott láb olvasásához vagy vezérléséhez. A kimenetek 3.3 V-os CMOS — lábanként 15 mA, az összes GPIO-n összesen 25 mA.

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

Bármely bemeneti láb megszakítást is kiválthat éltranzícióknál:

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

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

UART

Busz	TX	RX
UART1	TX	RX

Használja a TX/RX szitanyomott neveket a machine.UART osztállyal:

from machine import UART

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

I²C

Busz	SDA	SCL
I2C0	I2C_SDA / A4	I2C_SCL / A5
I2C1	P14	P15

Mindkét busznál a lábakat kifejezetten át kell adni a machine.I2C osztálynak:

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

Megjegyzés

Az 1-es busz a belső érzékelőbusz a P14/P15 lábakon (nem a felhasználói fejléceken) — ez szolgálja ki az IMU-t, a barométert, a környezeti érzékelőt és az APDS9960-at. A beégetett érzékelő-meghajtók közvetlenül használják; a felhasználói kód is szkennelheti, de a címeket már a fedélzeti érzékelők foglalják.

SPI

Busz	MOSI	MISO	SCK	CS
SPI0	D11	D12	D13	D10

A CS vonalat nem az SPI periféria vezérli — konfigurálja a D10-et kimenetként, és kapcsolgassa manuálisan az átvitel körül:

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)

Megjegyzés

A D13 egyben a narancssárga LED_BUILTIN is — az SPI vezérlése ezen a buszon a busz órajelének ütemében villogtatja a LED-et.

ADC

Az nRF52840 nyolc 12 bites ADC csatornával (SAADC) rendelkezik, amelyek az A0–A7 lábakon vannak kivezetve, mind 3.3 V-hoz referált — a read_u16 0–65535 értéket ad vissza a láb 0–3.3 V tartományában. A kártya AREF lába nincs bekötve, így a referencia mindig 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

Az nRF52840 négy PWM perifériát (PWM0–PWM3) tesz elérhetővé, amelyek mindegyike négy csatornát vezérel, összesen 16 hardveres PWM helyet. A rögzített funkciójú portokkal ellentétben a perifériák a GPIOTE mátrixon keresztül irányítanak — bármely GPIO lehet PWM kimenet, így nincs láb-szeletszelet hozzárendelés. E rugalmasság ára két, a szilíciumba épített megkötés:

• Egy modulon belüli mind a négy csatorna egyetlen periódust/frekvenciát oszt meg.

• Minden csatornának saját kitöltési tényezője és polaritása van.

Fogalmilag a 16 hely így néz ki:

Modul	Ch 0	Ch 1	Ch 2	Ch 3
PWM0	kitöltés	kitöltés	kitöltés	kitöltés
PWM1	kitöltés	kitöltés	kitöltés	kitöltés
PWM2	kitöltés	kitöltés	kitöltés	kitöltés
PWM3	kitöltés	kitöltés	kitöltés	kitöltés

Minden sor egy frekvencián fut; egy sor négy cellája egy-egy önállóan kiválasztott lábat vezérel saját kitöltési tényezővel. A különböző sorok teljesen eltérő frekvenciákon futhatnak.

Vezéreljen bármely szitanyomott lábat (vagy a fedélzeti LED-eket) a machine.PWM segítségével:

from machine import Pin, PWM

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

Figyelem

Az automatikus kiosztás híváKonként egy egész modult felemészt. Amikor device=/channel= kulcsszóargumentumok nélkül hoz létre egy PWM-et, a meghajtó megragadja az első szabad modult, és a lábat csak annak 0. csatornájához köti. A modul fennmaradó három csatornája tétlen marad, és csak kifejezett device=/channel= megadásával érhető el. Ez négyre korlátozza a segítség nélküli PWM(Pin(...)) hívásokat, mielőtt a meghajtó ValueError: all PWM devices in use hibát váltana ki — annak ellenére, hogy technikailag még tizenkét hely szabad.

Négynél több PWM használatához, vagy egy frekvencia szándékos megosztásához a lábak között, adja át a device (0–3) és channel (0–3) paramétert:

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

A kitöltési tényező a duty (0–100%), a duty_u16 (0–65535) vagy a duty_ns értéket fogadja el. Adjon hozzá invert=1-et a kimeneti polaritás megfordításához (hasznos az aktív alacsony RGB LED-hez).

Megjegyzés

Mivel a frekvencia modulonkénti tulajdonság, a pwm.freq(new_freq) meghívása egy modul bármelyik csatornáján újrafuttatja az nrfx_pwm_init-et az egész modulra, és megváltoztatja az ugyanazon osztozó összes többi csatorna által látott frekvenciát.

Megjegyzés

Az engedélyezett frekvenciák nagyjából 4 Hz-től 5.3 MHz-ig terjednek, a 16 MHz-es alapórajelből 1/2/4/8/16/32/64/128 előosztókkal és egy 15 bites periódusszámlálóval származtatva. A meghajtó automatikusan a legközelebbi osztót választja — a freq() a kért értéket jelenti, nem a pontosan elérhetőt.

Szoftveresen bitléptetett buszok

A machine.SoftI2C és a machine.SoftSPI bármely GPIO-n működik, ha egy további buszra van szüksége.

Hőérzékelő (külső)

A firmware tartalmazza a fir — hőérzékelő-meghajtó (fir == far infrared, távoli infravörös) meghajtót külsőleg bekötött hőkamerákhoz:

• MLX90621 — 16 × 4 IR mátrix

• MLX90640 — 32 × 24 IR mátrix

• MLX90641 — 16 × 12 IR mátrix

• AMG8833 — 8 × 8 IR mátrix

Kösse be a modult a kártya I²C buszára, és olvassa be a képkockákat a fir.init() + fir.snapshot() segítségével:

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

A fir meghajtó csak az I²C 0-n keresztül kommunikál az érzékelővel — kösse be a modult az I2C_SCL / I2C_SDA felületekhez (A5 / A4).

Időzítés

time

A time modul lefedi a blokkoló késleltetéseket, a monoton ütemjeleket és az eltelt idő mérését:

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)

Virtuális időzítők

A machine.Timer periodikus vagy egyszeri visszahívásokat ütemez anélkül, hogy hardveres időzítő helyet foglalna le. Adjon át -1-et azonosítóként egy virtuális (szoftveres) időzítő használatához:

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

A periódusértékek ezredmásodpercben vannak. Hívja meg a deinit() metódust a leállításhoz és a hely felszabadításához.

Valós idejű óra

A machine.RTC a visszaállítások között megőrzi a faliórát. Az nRF52840 RTC-je a chipen lévő oszcillátorhoz kötődik, és teljes áramkimaradást nem él túl — állítsa be az időt minden hidegindításkor, ha ez fontos az alkalmazása számára:

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

A machine.WDT visszaállítja a kártyát, ha az alkalmazás lefagy. Az indítás után nem állítható le és nem konfigurálható újra — táplálja rendszeresen a fő ciklusán belül:

from machine import WDT

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

Indítási és futásidejű információk

Firmware-frissítés

A Nano 33 BLE Sense az Arduino szabványos dupla koppintásos visszaállítását használja az Arduino rendszerbetöltőjének eléréséhez. Nyomja meg gyorsan kétszer a RESET gombot — a kártya rendszerbetöltő módba lép, és az OpenMV IDE új firmware-képet írhat rá.

Egy futó szkript igény szerint újra beléphet a rendszerbetöltőbe a machine.bootloader() meghívásával:

import machine

machine.bootloader()

Fájlrendszer és indítási sorrend

A Nano 33 BLE Sense firmware indításkor egyetlen fájlrendszert csatol fel:

• Belső flash — mindig a /flash alá van csatolva, és munkakönyvtárként szolgál. Alapértelmezetten a main.py-t és a README.txt-t tartalmazza; a legelső indításkor jön létre.

A felcsatolás után az értelmező a szkripteket a /flash-ből futtatja:

• A boot.py minden szoftveres visszaállításkor lefut.

• A main.py csak hidegindításkor fut le, közvetlenül a boot.py után.

A frissen flashelt kártyán szállított alapértelmezett main.py csak a felhasználói RGB LED kék csatornáját villogtatja szívverésként (két rövid impulzus, rövid szünet), így anélkül is megállapíthatja, hogy a firmware tisztán elindult, hogy bármilyen gazdagép csatlakozna.

A /flash ezen a kártyán nincs USB tömegtárolóként megjelenítve.

Tárolóméretek

A Nano 33 BLE Sense a következőkkel érkezik:

• /flash — 64 KB FAT fájlrendszer, írható/olvasható.

A Nano 33 BLE Sense build nem tartalmaz ROMFS-t; a Python modulokat közvetlenül a /flash-en szállítsa.

Szoftverkönyvtárak

A modulok teljes listáját lásd a könyvtárindexben — beleértve azt is, hogy melyek egyediek a Nano 33 BLE Sense buildben.