Arduino Nano 33 BLE Sense¶

Ostrzeżenie

Ta płytka nie jest już wspierana. Ostatnim wydaniem oprogramowania układowego OpenMV dla Arduino Nano 33 BLE Sense jest 4.7.0. Dla tego celu nie będą wydawane żadne dalsze aktualizacje oprogramowania układowego, poprawki błędów ani nowe funkcje. Poniższe informacje zachowano dla użytkowników korzystających z wersji 4.7.0 lub wcześniejszej.

Arduino Nano 33 BLE Sense to płytka o wymiarach 45 × 18 mm w formacie Arduino-Nano, zbudowana wokół układu Nordic Semiconductor nRF52840 — pojedynczego rdzenia ARM Cortex-M4 z FPU taktowanego zegarem 64 MHz, z 256 KB wewnętrznej pamięci SRAM i 1 MB wewnętrznej pamięci flash. BLE pochodzi z radia zintegrowanego w układzie, a płytka jest wyposażona w 9-osiowy IMU, barometr LPS22HB, sensor temperatury / wilgotności HTS221 / HS3003, sensor światła otoczenia / koloru / zbliżeniowy / gestów APDS9960 oraz mikrofon PDM MP34DT05. Oprogramowanie układowe OpenMV obsługuje je wszystkie z poziomu MicroPython.

Pełną kartę katalogową, zdjęcia i wymiary znajdziesz na stronie produktu Arduino Nano 33 BLE Rev2.

Najważniejsze cechy¶

Nordic nRF52840 Cortex-M4 z FPU o taktowaniu 64 MHz, z 256 KB wewnętrznej pamięci SRAM i 1 MB wewnętrznej pamięci flash.
Bluetooth LE 5.0 dzięki radiu zintegrowanemu w układzie i Nordic SoftDevice s140.
9-osiowy IMU — LSM9DS1 w Rev 1, BMI270 + BMM150 w Rev 2. Wbudowany sterownik imu wykrywa oba przy starcie.
Barometr LPS22HB, sensor temperatury i wilgotności HTS221 / HS3003, sensor światła otoczenia / koloru / zbliżeniowy / gestów APDS9960 oraz mikrofon PDM MP34DT05.
Złącze Micro USB do zasilania, programowania i obsługi REPL przez CDC.
22 pinów wejścia/wyjścia użytkownika na standardowych złączach Nano — TX/RX, D2–D13 (cyfrowe), A0–A7 (analogowe).

Rozkład wyprowadzeń¶

Opis wyprowadzeń¶

Nazwa pinu	Odniesienie	Funkcja
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	naciśnij wbudowany przycisk RESET lub zewrzyj do GND, aby zresetować
LED_BUILTIN	—	Pomarańczowa dioda LED użytkownika na `D13`
LED_RED	—	Czerwony kanał diody RGB LED (aktywny stanem niskim)
LED_GREEN	—	Zielony kanał diody RGB LED (aktywny stanem niskim)
LED_BLUE	—	Niebieski kanał diody RGB LED (aktywny stanem niskim)

Ostrzeżenie

Piny wejścia/wyjścia Nano 33 BLE Sense pracują wyłącznie z napięciem 3.3 V — nie są tolerancyjne na 5 V. Podanie na nie 5 V uszkodzi układ nRF52840.

Piny zasilania¶

VIN — wejście 4.5 – 21 V. Zasila płytkę przez wbudowany stabilizator. Jest również podawane przez diodę z szyny 5 V z USB, dzięki czemu USB i VIN mogą być obecne jednocześnie bez wzajemnego oddziaływania zwrotnego.
+5V — domyślnie niepodłączone.
+3V3 — wyjście stabilizatora 3.3 V.
AREF — pin analogowego napięcia odniesienia. Na tej płytce nie jest podłączony do nRF52840 — ADC zawsze odnosi się do 3.3 V.
GND — wspólna masa.

Nano 33 BLE Sense można zasilać jedną z dwóch dróg:

Micro USB — dostarcza 5 V do wbudowanego stabilizatora.
Pin VIN — podaj ustabilizowane napięcie 4.5 – 21 V.

Informacja

Zworka lutownicza na spodzie płytki oznaczona VUSB łączy +5V z szyną 5 V z USB. Zewrzyj ją, aby pin nagłówka +5V faktycznie przenosił 5 V.

Informacja

Normalnie zwartą zworkę lutowniczą na wyjściu wbudowanego impulsowego stabilizatora 4.5–21 V można przeciąć, aby wyłączyć stabilizator, dzięki czemu płytkę można zasilać bezpośrednio z zewnętrznego źródła 3.3 V na pinie +3V3.

Piny do odzyskiwania i debugowania¶

RESET — zarówno odsłonięte pole lutownicze, jak i chwilowy przycisk RESET na górze płytki, połączone z linią resetu nRF52840. Zewrzyj do GND lub naciśnij przycisk, aby zresetować.

Nano 33 BLE Sense używa standardowego dla Arduino podwójnego naciśnięcia resetu, aby wejść do bootloadera Arduino. Naciśnij szybko dwukrotnie przycisk RESET — płytka przejdzie w tryb bootloadera, a OpenMV IDE może wgrać nowy obraz oprogramowania układowego.

Sygnały SWD układu nRF52840 są wyprowadzone na pokrytych metalem polach z tyłu płytki. Wszystkie sygnały debugowania odnoszą się do 3.3 V.

Wbudowane urządzenia peryferyjne¶

Diody LED¶

Nano 33 BLE Sense ma diodę RGB LED użytkownika — sterowaną przez opisane na nadruku kanały LED_RED, LED_GREEN i LED_BLUE — oraz osobną pomarańczową diodę LED_BUILTIN na D13. Wszystkie cztery można sterować programowo przez machine.LED

from machine import LED

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

Osobna zielona dioda zasilania na płytce świeci zawsze, gdy szyna +3.3 V jest aktywna, i nie jest sterowalna przez użytkownika.

Sensor kamery¶

Oprogramowanie układowe OpenMV na Nano 33 BLE Sense obsługuje równoległy sensor CMOS OmniVision OV7670. Płytka nie ma wbudowanego sensora obrazu — podłącz moduł OV7670 do opisanych na nadruku pinów nagłówka wymienionych poniżej i steruj nim przez moduł csi — sensory kamery

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

Informacja

OV7670 zajmuje 14 pinów. Oprogramowanie układowe podłącza je w następujący sposób:

Sygnał sensora	Pin 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)

Magistrala sterująca I²C układu OV7670 to ta sama zewnętrzna magistrala I²C 0 wyprowadzona na A5/A4. Sensor znajduje się pod 7-bitowym adresem 0x21 — urządzenia użytkownika na tej magistrali muszą unikać tego adresu, gdy kamera jest podłączona.

IMU¶

9-osiowy IMU jest udostępniany przez wbudowany moduł imu, który automatycznie wykrywa, czy płytka ma LSM9DS1 (Rev 1), czy BMI270 + BMM150 (Rev 2), i prezentuje ujednoliconą klasę imu.IMU. Sensory znajdują się na wewnętrznej magistrali 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)

Aby uzyskać bezpośredni dostęp do funkcji takich jak wykrywanie stuknięć czy FIFO, zaimportuj odpowiedni wbudowany sterownik (lsm9ds1, bmi270 lub bmm150) i utwórz jego instancję na tej samej magistrali.

Sensory środowiskowe¶

Barometr (LPS22HB) oraz sensor temperatury / wilgotności (HTS221 w Rev 1, HS3003 w Rev 2) współdzielą tę samą wewnętrzną magistralę I²C 1 co 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)

Światło / kolor / zbliżenie / gesty¶

Układ Broadcom APDS9960 znajduje się na tej samej wewnętrznej magistrali I²C 1 i zapewnia pomiar światła otoczenia, koloru RGB, zbliżenia oraz wykrywanie gestów:

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¶

Wbudowany mikrofon PDM MP34DT05 jest przechwytywany przez audio — Moduł Audio. Każdy bufor przychodzi jako 16-bitowy PCM ze znakiem w postaci bytearray, gotowy do przekazania do ulab/numpy w celu przetwarzania 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¶

Radio Bluetooth LE 5.0 układu nRF52840 działa na Nordic SoftDevice s140 i jest udostępniane przez starszy moduł ubluepy — nowoczesne API bluetooth / aioble — Asynchroniczne BLE nie są włączone w tej kompilacji. Dostępne są zarówno role peripheral (serwer GATT, rozgłaszanie), jak i central (obserwator / skaner GAP + łączenie).

Rozgłaszanie jako peripheral z pojedynczą usługą Environmental Sensing i powiadamialną charakterystyką temperatury — wywołanie zwrotne event_handler uruchamia się przy połączeniu, rozłączeniu i zapisach 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])

Skanowanie w poszukiwaniu pobliskich rozgłaszających urządzeń w roli central:

from ubluepy import Scanner

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

Pełne API znajdziesz w dokumentacji ubluepy — UUID, Service, Characteristic, Peripheral, Scanner, ScanEntry oraz przestrzeń nazw constants.

Opis magistral¶

GPIO¶

Użyj machine.Pin, aby odczytać lub sterować dowolnym z opisanych na nadruku pinów. Wyjścia to 3.3 V CMOS — 15 mA na pin, 25 mA łącznie dla wszystkich 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())

Każdy pin wejściowy może również wyzwalać przerwanie przy zmianie zbocza:

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

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

UART¶

Magistrala	TX	RX
UART1	TX	RX

Użyj nazw z nadruku TX/RX z machine.UART

from machine import UART

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

I²C¶

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

Obie magistrale wymagają jawnego przekazania swoich pinów do 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()

Informacja

Magistrala 1 to wewnętrzna magistrala sensorów na P14/P15 (niedostępna na nagłówkach użytkownika) — obsługuje IMU, barometr, sensor środowiskowy i APDS9960. Wbudowane sterowniki sensorów korzystają z niej bezpośrednio; kod użytkownika również może ją przeskanować, ale adresy są już zajęte przez wbudowane sensory.

SPI¶

Magistrala	MOSI	MISO	SCK	CS
SPI0	D11	D12	D13	D10

Linia CS nie jest sterowana przez urządzenie peryferyjne SPI — skonfiguruj D10 jako wyjście i przełączaj ją ręcznie wokół transferu:

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)

Informacja

D13 pełni jednocześnie funkcję pomarańczowej diody LED_BUILTIN — sterowanie SPI na tej magistrali będzie migać diodą w rytm zegara magistrali.

ADC¶

Układ nRF52840 ma osiem 12-bitowych kanałów ADC (SAADC) wyprowadzonych na A0–A7, wszystkie odnoszące się do 3.3 V — read_u16 zwraca 0–65535 w zakresie 0–3.3 V na pinie. Pin AREF płytki nie jest podłączony, więc odniesienie zawsze wynosi 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¶

Układ nRF52840 udostępnia cztery urządzenia peryferyjne PWM (PWM0–PWM3), z których każde steruje czterema kanałami, co daje łącznie 16 sprzętowych slotów PWM. W przeciwieństwie do portów o stałej funkcji urządzenia te są kierowane przez macierz GPIOTE — każdy GPIO może być wyjściem PWM, więc nie ma stałego przyporządkowania pin-do-slotu. Kosztem tej elastyczności są dwa ograniczenia wpisane w krzem:

Wszystkie cztery kanały w obrębie jednego modułu współdzielą jeden okres/częstotliwość.
Każdy kanał ma własny współczynnik wypełnienia i polaryzację.

Koncepcyjnie 16 slotów wygląda tak:

Moduł	Kan. 0	Kan. 1	Kan. 2	Kan. 3
PWM0	wypełnienie	wypełnienie	wypełnienie	wypełnienie
PWM1	wypełnienie	wypełnienie	wypełnienie	wypełnienie
PWM2	wypełnienie	wypełnienie	wypełnienie	wypełnienie
PWM3	wypełnienie	wypełnienie	wypełnienie	wypełnienie

Każdy wiersz działa z jedną częstotliwością; cztery komórki w wierszu sterują niezależnie wybranym pinem z własnym współczynnikiem wypełnienia. Różne wiersze mogą działać z zupełnie różnymi częstotliwościami.

Steruj dowolnym opisanym na nadruku pinem (lub wbudowanymi diodami LED) przez machine.PWM

from machine import Pin, PWM

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

Ostrzeżenie

Automatyczne przydzielanie zajmuje cały moduł na jedno wywołanie. Gdy tworzysz PWM bez argumentów device=/channel=, sterownik zajmuje pierwszy wolny moduł i wiąże twój pin tylko z jego kanałem 0. Pozostałe trzy kanały tego modułu pozostają bezczynne i są dostępne tylko przez jawne device=/channel=. To ogranicza liczbę nieoznaczonych wywołań PWM(Pin(...)) do czterech, zanim sterownik zgłosi ValueError: all PWM devices in use — mimo że technicznie dwanaście slotów jest nadal wolnych.

Aby użyć więcej niż czterech PWM lub celowo współdzielić częstotliwość między pinami, przekaż device (0–3) i 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)

Współczynnik wypełnienia przyjmuje duty (0–100%), duty_u16 (0–65535) lub duty_ns. Dodaj invert=1, aby odwrócić polaryzację wyjścia (przydatne dla aktywnej stanem niskim diody RGB LED).

Informacja

Ponieważ częstotliwość jest właściwością modułu, wywołanie pwm.freq(new_freq) na dowolnym kanale modułu ponownie uruchamia nrfx_pwm_init dla całego modułu i zmienia częstotliwość widzianą przez każdy inny kanał, który go współdzieli.

Informacja

Dozwolone częstotliwości obejmują w przybliżeniu zakres od 4 Hz do 5.3 MHz, wyprowadzone z zegara bazowego 16 MHz z preskalerami 1/2/4/8/16/32/64/128 i 15-bitowym licznikiem okresu. Sterownik automatycznie wybiera najbliższy dzielnik — freq() raportuje żądaną wartość, a nie dokładną osiągalną.

Programowo emulowane magistrale (bit-banging)¶

machine.SoftI2C i machine.SoftSPI działają na dowolnym GPIO, jeśli potrzebujesz dodatkowej magistrali.

Sensor termiczny (zewnętrzny)¶

Oprogramowanie układowe zawiera sterownik fir — sterownik sensora termicznego (fir == far infrared, daleka podczerwień) dla zewnętrznie podłączonych kamer termowizyjnych:

MLX90621 — matryca IR 16 × 4
MLX90640 — matryca IR 32 × 24
MLX90641 — matryca IR 16 × 12
AMG8833 — matryca IR 8 × 8

Podłącz moduł do magistrali I²C płytki i odczytuj ramki za pomocą 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())

Sterownik fir komunikuje się z sensorem wyłącznie przez I²C 0 — podłącz moduł do pól I2C_SCL / I2C_SDA (A5 / A4).

Pomiar czasu¶

time¶

Moduł time obejmuje blokujące opóźnienia, monotoniczne takty oraz pomiar upływającego czasu:

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)

Wirtualne liczniki czasu¶

machine.Timer planuje okresowe lub jednorazowe wywołania zwrotne bez zajmowania sprzętowego slotu licznika czasu. Przekaż -1 jako id, aby użyć wirtualnego (programowego) licznika czasu:

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

Wartości okresu podawane są w milisekundach. Wywołaj deinit(), aby zatrzymać i zwolnić slot.

Zegar czasu rzeczywistego¶

machine.RTC utrzymuje czas zegarowy przez resety. RTC układu nRF52840 jest powiązany z oscylatorem na chipie i nie przetrwa całkowitego zaniku zasilania — ustawiaj czas przy każdym zimnym starcie, jeśli ma to znaczenie dla twojej aplikacji:

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 resetuje płytkę, jeśli aplikacja zawiesi się. Po uruchomieniu nie można go zatrzymać ani przekonfigurować — karm go okresowo wewnątrz swojej głównej pętli:

from machine import WDT

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

Informacje o starcie i czasie wykonywania¶

Aktualizacja oprogramowania układowego¶

Działający skrypt może na żądanie ponownie wejść do bootloadera, wywołując machine.bootloader()

import machine

machine.bootloader()

System plików i kolejność startu¶

Oprogramowanie układowe Nano 33 BLE Sense montuje przy starcie pojedynczy system plików:

Wewnętrzna pamięć flash — zawsze montowana w /flash i używana jako katalog roboczy. Domyślnie zawiera main.py i README.txt; tworzona przy pierwszym starcie.

Po zamontowaniu interpreter uruchamia następnie skrypty z /flash:

boot.py jest wykonywany przy każdym miękkim resecie.
main.py jest wykonywany tylko przy zimnym starcie, bezpośrednio po boot.py.

Domyślny main.py dostarczany na świeżo wgranej płytce po prostu miga niebieskim kanałem diody RGB LED użytkownika jako sygnał obecności (dwa krótkie błyski, krótka przerwa), dzięki czemu można poznać, że oprogramowanie układowe wystartowało poprawnie, bez podłączonego hosta.

/flash nie jest na tej płytce udostępniany jako napęd pamięci masowej USB.

Rozmiary pamięci masowej¶

Nano 33 BLE Sense jest dostarczany z:

/flash — system plików FAT o pojemności 64 KB, do odczytu/zapisu.

Kompilacja Nano 33 BLE Sense nie zawiera ROMFS; dostarczaj moduły Python bezpośrednio na /flash.

Biblioteki programowe¶

Pełną listę modułów — w tym te unikalne dla kompilacji Nano 33 BLE Sense — znajdziesz w indeksie bibliotek.