Arduino Nano 33 BLE Sense¶

Warnung

Dieses Board wird nicht mehr unterstützt. Die letzte OpenMV-Firmware-Version für das Arduino Nano 33 BLE Sense ist 4.7.0. Für dieses Target werden keine weiteren Firmware-Updates, Fehlerbehebungen oder neuen Funktionen mehr veröffentlicht. Die folgenden Informationen sind für Benutzer erhalten geblieben, die 4.7.0 oder früher verwenden.

Das Arduino Nano 33 BLE Sense ist ein 45 × 18 mm großes Board im Arduino-Nano-Formfaktor, das um den Nordic Semiconductor nRF52840 herum aufgebaut ist – einen einzelnen ARM Cortex-M4 mit FPU, der mit 64 MHz läuft und über 256 KB internes SRAM sowie 1 MB internen Flash verfügt. BLE stammt vom integrierten Funkmodul, und das Board trägt eine 9-Achsen-IMU, einen LPS22HB-Barometer, einen HTS221-/HS3003-Temperatur-/Feuchtigkeitssensor, einen APDS9960-Sensor für Umgebungslicht/Farbe/Annäherung/Gesten sowie ein MP34DT05-PDM-Mikrofon. Die OpenMV-Firmware steuert all dies von MicroPython aus an.

Vollständiges Datenblatt, Fotos und Abmessungen finden Sie auf der Produktseite des Arduino Nano 33 BLE Rev2.

Highlights¶

Nordic nRF52840 Cortex-M4 mit FPU bei 64 MHz mit 256 KB internem SRAM und 1 MB internem Flash.
Bluetooth LE 5.0 über das integrierte Funkmodul und Nordic SoftDevice s140.
9-Achsen-IMU – LSM9DS1 auf Rev 1, BMI270 + BMM150 auf Rev 2. Der eingefrorene imu-Treiber tastet beim Booten beide ab.
LPS22HB-Barometer, HTS221-/HS3003-Temperatur- und Feuchtigkeitssensor, APDS9960-Sensor für Umgebungslicht/Farbe/Annäherung/Gesten sowie MP34DT05-PDM-Mikrofon.
Micro-USB-Anschluss für Stromversorgung, Programmierung und eine CDC-REPL.
22 Benutzer-I/O-Pins an den standardmäßigen Nano-Headern – TX/RX, D2–D13 (digital), A0–A7 (analog).

Pinbelegung¶

Pin-Referenz¶

Pin-Name	Referenz	Funktion
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	Drücken Sie die RESET-Taste auf dem Board oder ziehen Sie den Pin auf GND, um einen Reset auszulösen
LED_BUILTIN	—	Orangefarbene Benutzer-LED an `D13`
LED_RED	—	Roter Kanal der RGB-LED (Low-aktiv)
LED_GREEN	—	Grüner Kanal der RGB-LED (Low-aktiv)
LED_BLUE	—	Blauer Kanal der RGB-LED (Low-aktiv)

Warnung

Die I/O-Pins des Nano 33 BLE Sense sind ausschließlich 3,3 V – sie sind nicht 5-V-tolerant. Das Anlegen von 5 V beschädigt den nRF52840.

Stromversorgungs-Pins¶

VIN – Eingang von 4,5 – 21 V. Versorgt das Board über den Spannungsregler auf dem Board. Wird außerdem über eine Diode von der USB-5-V-Schiene gespeist, sodass USB und VIN gleichzeitig anliegen können, ohne sich gegenseitig rückzuspeisen.
+5V – standardmäßig nicht angeschlossen.
+3V3 – Ausgang des 3,3-V-Spannungsreglers.
AREF – analoger Referenz-Pin. Auf diesem Board nicht mit dem nRF52840 verdrahtet – der ADC ist immer auf 3,3 V referenziert.
GND – gemeinsame Masse.

Das Nano 33 BLE Sense kann über einen der beiden Wege mit Strom versorgt werden:

Micro-USB – liefert 5 V an den Spannungsregler auf dem Board.
VIN-Pin – legen Sie eine geregelte Versorgung von 4,5 – 21 V an.

Bemerkung

Ein Lötjumper auf der Unterseite des Boards mit der Beschriftung VUSB verbindet +5V mit der USB-5-V-Schiene. Schließen Sie ihn, damit der +5V-Header-Pin tatsächlich 5 V führt.

Bemerkung

Ein normalerweise geschlossener Lötjumper am Ausgang des 4,5–21-V-Schaltreglers auf dem Board kann durchtrennt werden, um den Regler zu deaktivieren, sodass das Board direkt von einer externen 3,3-V-Versorgung an +3V3 gespeist werden kann.

Recovery- und Debug-Pins¶

RESET – sowohl ein freiliegendes Pad als auch eine RESET-Taste auf der Oberseite des Boards, beide mit der Reset-Leitung des nRF52840 verbunden. Ziehen Sie auf GND oder drücken Sie die Taste, um einen Reset auszulösen.

Das Nano 33 BLE Sense verwendet Arduinos standardmäßigen Double-Tap-Reset, um in den Arduino-Bootloader zu gelangen. Drücken Sie die RESET-Taste zweimal schnell hintereinander – das Board wechselt in den Bootloader-Modus und OpenMV IDE kann ein neues Firmware-Image flashen.

Die SWD-Signale des nRF52840 sind auf verzinnten Pads auf der Rückseite des Boards zugänglich. Alle Debug-Signale sind auf 3,3 V referenziert.

Onboard-Peripheriegeräte¶

LEDs¶

Das Nano 33 BLE Sense verfügt über eine Benutzer-RGB-LED – angesteuert über die mit LED_RED, LED_GREEN und LED_BLUE bedruckten Kanäle – sowie eine separate orangefarbene LED_BUILTIN an D13. Alle vier sind über machine.LED per Software steuerbar:

from machine import LED

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

Eine separate grüne Power-LED auf dem Board leuchtet, sobald die +3,3-V-Schiene aktiv ist, und ist nicht durch den Benutzer steuerbar.

Kamerasensor¶

Die OpenMV-Firmware auf dem Nano 33 BLE Sense unterstützt den parallelen CMOS-Sensor OmniVision OV7670. Das Board hat keinen integrierten Bildsensor – verdrahten Sie ein OV7670-Modul mit den unten aufgeführten, bedruckten Header-Pins und steuern Sie es über das Modul csi — Kamerasensoren an:

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

Bemerkung

Der OV7670 benötigt 14 Pins. Die Firmware verdrahtet sie wie folgt:

Sensorsignal	Nano 33 BLE Sense Pin
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)

Der I²C-Steuerbus des OV7670 ist derselbe externe I²C 0, der an A5/A4 zugänglich ist. Der Sensor liegt auf der 7-Bit-Adresse 0x21 – Benutzergeräte an diesem Bus müssen diese Adresse vermeiden, wenn die Kamera angeschlossen ist.

IMU¶

Die 9-Achsen-IMU ist über das eingefrorene imu-Modul zugänglich, das automatisch erkennt, ob das Board die LSM9DS1 (Rev 1) oder die BMI270 + BMM150 (Rev 2) besitzt, und eine einheitliche imu.IMU-Klasse bereitstellt. Die Sensoren liegen auf dem internen I²C-1-Bus (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)

Für direkten Zugriff auf Funktionen wie Tap-Erkennung oder den FIFO importieren Sie den passenden eingefrorenen Treiber (lsm9ds1, bmi270 oder bmm150) und instanziieren ihn auf demselben Bus.

Umgebungssensoren¶

Der Barometer (LPS22HB) und der Temperatur-/Feuchtigkeitssensor (HTS221 auf Rev 1, HS3003 auf Rev 2) teilen sich denselben internen I²C-1-Bus wie die 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)

Licht / Farbe / Annäherung / Gesten¶

Der Broadcom APDS9960 liegt auf demselben internen I²C-1-Bus und bietet Umgebungslicht-, RGB-Farb-, Annäherungs- und Gestenerkennung:

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¶

Das integrierte MP34DT05-PDM-Mikrofon wird über audio — Audio-Modul erfasst. Jeder Puffer kommt als vorzeichenbehaftetes 16-Bit-PCM-bytearray an, bereit zur Weiterverarbeitung mit ulab/numpy für 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¶

Das Bluetooth-LE-5.0-Funkmodul des nRF52840 läuft auf dem Nordic SoftDevice s140 und ist über das veraltete Modul ubluepy zugänglich – die modernen APIs bluetooth / aioble — Async BLE sind in diesem Build nicht aktiviert. Sowohl die Peripheral-Rolle (GATT-Server, Advertising) als auch die Central-Rolle (GAP-Observer / Scanner + Connect) sind verfügbar.

Advertising als Peripheral mit einem einzelnen Environmental-Sensing-Service und einer benachrichtigungsfähigen Temperaturcharakteristik – der event_handler-Callback wird bei Connect, Disconnect und CCCD-Schreibvorgängen ausgelöst:

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

Scannen nach nahegelegenen Advertising-Geräten in der Central-Rolle:

from ubluepy import Scanner

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

Die vollständige API finden Sie in der ubluepy-Referenz – UUID, Service, Characteristic, Peripheral, Scanner, ScanEntry und der constants-Namespace.

Bus-Referenz¶

GPIO¶

Verwenden Sie machine.Pin, um einen beliebigen der bedruckten Pins zu lesen oder anzusteuern. Die Ausgänge sind 3,3-V-CMOS – 15 mA pro Pin, 25 mA insgesamt über alle 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())

Jeder Eingangspin kann außerdem bei Flankenwechseln einen Interrupt auslösen:

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

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

UART¶

Bus	TX	RX
UART1	TX	RX

Verwenden Sie die Aufdruck-Namen TX/RX mit machine.UART:

from machine import UART

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

I²C¶

Bus	SDA	SCL
I2C0	`I2C_SDA` / `A4`	`I2C_SCL` / `A5`
I2C1	`P14`	`P15`

Bei beiden Bussen müssen ihre Pins explizit an machine.I2C übergeben werden:

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

Bemerkung

Bus 1 ist der interne Sensorbus an P14/P15 (nicht an den Benutzer-Headern) – er bedient die IMU, den Barometer, den Umgebungssensor und den APDS9960. Die eingefrorenen Sensortreiber nutzen ihn direkt; Benutzercode kann ihn ebenfalls scannen, doch die Adressen sind bereits durch die Sensoren auf dem Board belegt.

SPI¶

Bus	MOSI	MISO	SCK	CS
SPI0	D11	D12	D13	D10

Die CS-Leitung wird nicht vom SPI-Peripheriegerät angesteuert – konfigurieren Sie D10 als Ausgang und schalten Sie ihn manuell um die Übertragung herum:

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)

Bemerkung

D13 dient zugleich als orangefarbene LED_BUILTIN – das Ansteuern von SPI auf diesem Bus lässt die LED im Takt des Bus-Clocks blinken.

ADC¶

Der nRF52840 verfügt über acht 12-Bit-ADC-Kanäle (SAADC), die an A0–A7 zugänglich und alle auf 3,3 V referenziert sind – read_u16 liefert 0–65535 über den Bereich 0–3,3 V am Pin. Der AREF-Pin des Boards ist nicht verdrahtet, sodass die Referenz stets 3,3 V beträgt:

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¶

Der nRF52840 stellt vier PWM-Peripheriegeräte (PWM0–PWM3) bereit, die jeweils vier Kanäle ansteuern, also insgesamt 16 Hardware-PWM-Slots. Anders als bei Ports mit fester Funktion werden die Peripheriegeräte über die GPIOTE-Matrix geroutet – jeder GPIO kann ein PWM-Ausgang sein, sodass es keine feste Pin-zu-Slice-Zuordnung gibt. Der Preis dieser Flexibilität sind zwei in der Silizium-Hardware verankerte Einschränkungen:

Alle vier Kanäle innerhalb eines Moduls teilen sich eine einzelne Periode/Frequenz.
Jeder Kanal hat seinen eigenen Tastgrad und seine eigene Polarität.

Konzeptionell sehen die 16 Slots so aus:

Modul	Kanal 0	Kanal 1	Kanal 2	Kanal 3
PWM0	Tastgrad	Tastgrad	Tastgrad	Tastgrad
PWM1	Tastgrad	Tastgrad	Tastgrad	Tastgrad
PWM2	Tastgrad	Tastgrad	Tastgrad	Tastgrad
PWM3	Tastgrad	Tastgrad	Tastgrad	Tastgrad

Jede Zeile läuft mit einer Frequenz; die vier Zellen einer Zeile steuern jeweils einen unabhängig gewählten Pin mit eigenem Tastgrad an. Verschiedene Zeilen können mit völlig unterschiedlichen Frequenzen laufen.

Steuern Sie jeden bedruckten Pin (oder die LEDs auf dem Board) über machine.PWM an:

from machine import Pin, PWM

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

Warnung

Die automatische Zuweisung belegt pro Aufruf ein ganzes Modul. Wenn Sie ein PWM ohne die kwargs device=/channel= erstellen, greift der Treiber auf das erste freie Modul zu und bindet Ihren Pin nur an dessen Kanal 0. Die übrigen drei Kanäle dieses Moduls bleiben ungenutzt und sind nur über explizites device=/channel= erreichbar. Das begrenzt einfache PWM(Pin(...))-Aufrufe auf vier, bevor der Treiber ValueError: all PWM devices in use auslöst – obwohl technisch noch zwölf Slots frei sind.

Um mehr als vier PWMs zu verwenden oder eine Frequenz absichtlich über mehrere Pins zu teilen, übergeben Sie device (0–3) und 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)

Der Tastgrad akzeptiert duty (0–100 %), duty_u16 (0–65535) oder duty_ns. Fügen Sie invert=1 hinzu, um die Polarität des Ausgangs umzukehren (praktisch für die Low-aktive RGB-LED).

Bemerkung

Da die Frequenz eine Eigenschaft pro Modul ist, führt der Aufruf von pwm.freq(new_freq) auf einem beliebigen Kanal eines Moduls erneut nrfx_pwm_init für das gesamte Modul aus und ändert die Frequenz, die jeder andere mitnutzende Kanal sieht.

Bemerkung

Die zulässigen Frequenzen reichen ungefähr von 4 Hz bis 5,3 MHz, abgeleitet vom 16-MHz-Basistakt mit den Vorteilern 1/2/4/8/16/32/64/128 und einem 15-Bit-Periodenzähler. Der Treiber wählt automatisch den nächstgelegenen Teiler – freq() meldet den angeforderten Wert, nicht den exakt erreichbaren.

Software-Bit-Banged-Busse¶

machine.SoftI2C und machine.SoftSPI funktionieren auf jedem GPIO, falls Sie einen zusätzlichen Bus benötigen.

Thermosensor (extern)¶

Die Firmware enthält den fir — Wärmesensortreiber (fir == far infrared)-Treiber für extern verdrahtete Wärmebildkameras:

MLX90621 – 16 × 4 IR-Array
MLX90640 – 32 × 24 IR-Array
MLX90641 – 16 × 12 IR-Array
AMG8833 – 8 × 8 IR-Array

Verdrahten Sie das Modul mit dem I²C-Bus des Boards und lesen Sie Einzelbilder mit 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())

Der fir-Treiber kommuniziert mit dem Sensor nur über I²C 0 – verdrahten Sie das Modul mit den Pads I2C_SCL / I2C_SDA (A5 / A4).

Timing¶

time¶

Das time-Modul deckt blockierende Verzögerungen, monotone Ticks und die Messung verstrichener Zeit ab:

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)

Virtuelle Timer¶

machine.Timer plant periodische oder einmalige Callbacks, ohne einen Hardware-Timer-Slot zu belegen. Übergeben Sie -1 als ID, um einen virtuellen (Software-)Timer zu verwenden:

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

Die Periodenwerte sind in Millisekunden angegeben. Rufen Sie deinit() auf, um den Slot zu stoppen und freizugeben.

Echtzeituhr¶

machine.RTC hält die Uhrzeit über Resets hinweg. Die RTC des nRF52840 ist an den On-Chip-Oszillator gebunden und übersteht keinen vollständigen Stromausfall – stellen Sie die Zeit bei jedem Kaltstart ein, falls dies für Ihre Anwendung wichtig ist:

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 setzt das Board zurück, falls die Anwendung hängen bleibt. Einmal gestartet, kann er nicht mehr gestoppt oder neu konfiguriert werden – füttern Sie ihn regelmäßig innerhalb Ihrer Hauptschleife:

from machine import WDT

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

Boot- und Laufzeitinformationen¶

Firmware-Update¶

Ein laufendes Skript kann durch Aufruf von machine.bootloader() bei Bedarf wieder in den Bootloader wechseln:

import machine

machine.bootloader()

Dateisystem und Boot-Reihenfolge¶

Die Firmware des Nano 33 BLE Sense mountet beim Booten ein einzelnes Dateisystem:

Interner Flash – immer unter /flash gemountet und als Arbeitsverzeichnis verwendet. Enthält standardmäßig main.py und README.txt; wird beim allerersten Boot erstellt.

Nach dem Mounten führt der Interpreter anschließend Skripte aus /flash aus:

boot.py wird bei jedem Soft-Reset ausgeführt.
main.py wird nur beim Kaltstart ausgeführt, unmittelbar nach boot.py.

Die standardmäßige main.py, die auf einem frisch geflashten Board ausgeliefert wird, lässt lediglich den blauen Kanal der Benutzer-RGB-LED als Herzschlag blinken (zwei kurze Impulse, kurze Pause), sodass Sie ohne angeschlossenen Host erkennen können, dass die Firmware sauber gebootet ist.

/flash wird auf diesem Board nicht als USB-Massenspeicherlaufwerk bereitgestellt.

Speichergrößen¶

Das Nano 33 BLE Sense wird ausgeliefert mit:

/flash – 64 KB FAT-Dateisystem, Lesen/Schreiben.

Der Build des Nano 33 BLE Sense enthält kein ROMFS; liefern Sie Python-Module direkt auf /flash aus.

Software-Bibliotheken¶

Die vollständige Liste der Module finden Sie im Bibliotheksindex – einschließlich derjenigen, die nur im Build des Nano 33 BLE Sense vorhanden sind.