MTU a BLE-ben: mi ez, csomagméret és egyeztetés

Mi az MTU a BLE-ben?

Maximum Transmission Unit (MTU) a BLE kontextusában — az Application Protocol Data Unit (APDU) maximális mérete, amelyet egy eszköz egyetlen GATT kérésben fogadni tud. Az MTU az ATT (Attribute Protocol) szintjén van meghatározva és tartalmazza az ATT fejlécet (1 byte) + hasznos adatokat. Alapértelmezésben minden BLE eszköz támogatja a 23 byte-os MTU-t (23 = 1 byte ATT fejléc + 22 byte adat).

Az MTU nem a rádiócsatorna fizikai korlátja, hanem az eszközök közötti megállapodás a GATT szinten. A BLE csomag fizikai mérete a Link Layer szinten nagyobb lehet (BLE 4.0-ban 27 byte-ig, BLE 5.0-ban Data Length Extension-nel 257 byte-ig), de a GATT réteg korlátozza, hogy mennyi adat kerül átvitelre egyetlen tranzakcióban. A Data Length Extension (DLE) — egy külön mechanizmus a Link Layer szinten, amely 251 byte-ra növeli a fizikai csomagot, és külön kell egyeztetni.

Különbség az MTU és a DLE között: ATT MTU — mennyi adat kerül átvitelre egy GATT kérésben, DLE — mennyi adat fér el egy Link Layer csomagban. A maximális sebességhez mindkét paramétert egyeztetni kell. DLE nélkül még 247 byte-os MTU esetén is több 27 byte-os Link Layer csomagra töredezik az adat, csökkentve a sávszélességet.

MTU egyeztetés: eljárás és protokoll

MTU Size Request — eljárás, amelyet a Central indít a GATT kapcsolat létrejötte után. A Central elküldi az MTU Request-et az MTU kapacitása (az általa fogadható maximális méret) megadásával. A Peripheral válaszol az MTU Response-szal a saját értékével. A használt MTU a két érték minimuma. Ha a Central MTU 512-t javasol, és a Peripheral csak 128-at támogat, a kapcsolat MTU 128-at fog használni.

import CoreBluetooth

// Maximális MTU kérése iOS-ben
func requestMTU(central: CBCentralManager,
                    peripheral: CBPeripheral) {
    peripheral.maximumWriteValueLength(
        for: .withoutResponse
    )

// Az iOS automatikusan egyezteti az MTU-t kapcsolódáskor
            // MTU = 512 BLE 5.0 eszközökhöz
    let mtu = peripheral.maximumWriteValueLength(
        for: .withResponse
    )

    print("Egyeztetett MTU: " +
          String(mtu))
}

Az egyeztetés időzítése: az MTU Request-et a szolgáltatások felderítése (discoverServices) után, de az aktív adatátvitel megkezdése előtt kell elküldeni. Az iOS Core Bluetooth automatikusan egyezteti az MTU-t a kapcsolódáskor — a fejlesztőnek nem kell kézzel elküldenie az MTU Request-et. Android-ban expliciten meg kell hívni a requestMTU-t. Az egyeztetés után az MTU rögzített marad ehhez a kapcsolathoz — az újraegyeztetés nem lehetséges a kapcsolat bontása és újra csatlakozás nélkül.

ATT korlátozások: miért nem lehet az MTU nagyobb 251 byte-nál

ATT (Attribute Protocol) — a protokoll, amelyre a GATT épül. Az ATT csomag maximális mérete 257 byte (ATT_MTU-1). Ebből 1 byte az Opcode (művelet típusa), 1 byte a Handle, és legfeljebb 255 byte a Value. Így a maximális MTU, amelyet az ATT specifikáció megenged, 257 byte (a gyakorlatban 251 byte-ig használják, mert néhány szervizmezőre úgyis szükség van).

Az MTU-nál nagyobb adatok küldéséhez fragmentációt használnak az alkalmazás szintjén. A fejlesztő maga osztja fel az adatokat ≤ MTU méretű darabokra, és egymás után küldi el őket. Minden darab formálisan külön GATT Write Request. A fogadó fél összeállítja a darabokat egyetlen pufferbe. A GATT-ban nincs beépített támogatás a fragmentációhoz — ez a fejlesztő feladata.

Érdekes tény: az iOS és Android rendre 512 és 517 byte MTU-t kér, de ez az érték meghaladja az ATT korlátot. A gyakorlatban a BLE verem automatikusan fragmentálja az ilyen adatokat, és több egymás utáni, maximum 251 byte-os GATT kérésként küldi el őket. A fejlesztő számára a különbség észrevehetetlen — a writeValue bármilyen mérettel működik 512 byte-ig iOS-ben.

Az MTU hatása a teljesítményre

Az MTU mérete közvetlenül befolyásolja a BLE kapcsolat sávszélességét. 23 byte-os MTU esetén a maximális hasznos átviteli sebesség ideális körülmények között kb. 7–10 KB/s. Az MTU 247 byte-ra növelése 60–90 KB/s-ra emeli a sebességet (DLE-vel és optimális connection interval-lal). Ez különösen fontos a képeket, audio töredékeket vagy naplókat átvitelő alkalmazások számára.

A BLE átvitel teljesítménye három tényezőtől függ: MTU (mennyi adat egy ATT kérésben), connection interval (milyen gyakran történnek a csereesemények) és DLE (mennyi adat egy Link Layer csomagban). Optimális konfiguráció a maximális sebességhez: MTU = 247, DLE = 251, connection interval = 7.5 ms (minimális érték).

A Bluetooth SIG White Paper (2023) adatai szerint az MTU 23-ról 247 byte-ra növelése 30 ms connection interval mellett 8 KB/s-ról 42 KB/s-ra növeli a sávszélességet — ötszörös növekedés. 7.5 ms connection interval mellett a sávszélesség eléri a 88 KB/s-t. Azoknak az alkalmazásoknak, amelyek nem igényelnek nagy sebességet (hőmérséklet érzékelők, BLE jeladók), a standard 23 byte-os MTU továbbra is elegendő.

MTU beállítása iOS-ben és Android-ban

iOS Core Bluetooth automatikusan egyezteti az MTU-t a Peripheral-hez való csatlakozáskor. A fejlesztő ellenőrizheti az aktuális MTU-t a maximumWriteValueLength-en keresztül, de nem állíthatja be manuálisan. Az iOS 512 byte-ig terjedő MTU-t használ a BLE 5.0 eszközökhöz és 247 byte-ig a BLE 4.2-höz. Nagy adatmennyiség írásához használja a writeType: .withResponse-t a garantált kézbesítésért.

// MTU kérése Android-ban (Kotlin)
val bluetoothGatt: BluetoothGatt = ...

// MTU 517 byte kérése
bluetoothGatt.requestMtu(517)

// Eredmény kezelése callback-ben
override fun onMtuChanged(
    gatt: BluetoothGatt,
    mtu: Int,
    status: Int
) {
    if (status == BluetoothGatt.GATT_SUCCESS) {
        println("MTU negotiated: $mtu")
    }
}

Android biztosítja a BluetoothGatt.requestMtu(int) metódust, amely lehetővé teszi bármilyen MTU kérését 517 byte-ig. A tényleges MTU-t a periférikus eszköz határozza meg — ha az csak 23 byte-ot támogat, az Android MTU 23-at ad vissza. Az aktuális MTU meghatározásához használja a gatt.requestMtu(0)-t — ez véltoztatási kísérlet nélkül adja vissza az aktuális értéket. Az Android 12+ támogatja az automatikus MTU egyeztetést TRANSPORT_LE-n keresztül.

A platformok közötti keretrendszerek (Flutter, React Native) általában API-t biztosítanak a requestMTU számára. A FlutterBlue Plus könyvtárban az MTU kapcsolódási paraméterként van beállítva. A RxAndroidBle-ben — a requestMtu metóduson keresztül. Javasolt mindig a maximális MTU-t egyeztetni közvetlenül a szolgáltatások felfedezése után, az adatátvitel megkezdése előtt, hogy elkerüljük a fragmentációt az alkalmazás szintjén.

MTU és OTA frissítések

OTA (Over-The-Air) firmware frissítések — a leginkább MTU-igényes forgatókönyv a BLE-ben. Egy IoT eszköz firmware-ének tipikus mérete 100–500 KB. 23 byte-os MTU és 30 ms connection interval mellett 100 KB átviteli ideje kb. 2–3 perc. 247 byte-os MTU és 251 byte-os DLE mellett — 20–40 másodperc. 512 byte-os MTU (iOS) esetén pedig — 10–15 másodperc.

Az OTA frissítési folyamat általában magában foglalja: a firmware fragmentálását ≤ MTU méretű csomagokra, egymás utáni küldést Notify/Write révén, az ellenőrző összeg ellenőrzését minden csomagon és a vétel megerősítését. Ha egy csomag elvész, az eszköz újraküldést kér. Az OTA megbízhatósága kritikusan függ az MTU és a connection interval helyes megválasztásától.

Javaslatok OTA-hoz: egyeztesse a maximális MTU-t (247–512 byte), állítsa a connection interval-t 7.5–15 ms-ra (ha az eszköz támogatja), használja a DLE-t (Data Length Extension) a fizikai csomag 251 byte-ra növeléséhez. Korlátozott puffer memóriával rendelkező eszközöknél (pl. nRF52 alapú BLE modulok) ellenőrizze a maximális MTU-t a chip specifikációjában.