MTU i BLE: vad är det, paketstorlek och förhandling

Vad är MTU i BLE?

Maximum Transmission Unit (MTU) i BLE-sammanhang — är den maximala storleken på Application Protocol Data Unit (APDU) som en enhet kan ta emot i en GATT-begäran. MTU definieras på ATT-nivå (Attribute Protocol) och inkluderar ATT-huvud (1 byte) + användbara data. Som standard stöder alla BLE-enheter MTU 23 byte (23 = 1 byte ATT-huvud + 22 byte data).

MTU är inte en fysisk begränsning av radiokanalen, utan ett avtal mellan enheter på GATT-nivå. Den fysiska storleken på ett BLE-paket på Link Layer-nivå kan vara större (upp till 27 byte i BLE 4.0, upp till 257 byte i BLE 5.0 med Data Length Extension), men GATT-skiktet begränsar hur mycket data som överförs i en transaktion. Data Length Extension (DLE) — är en separat mekanism på Link Layer-nivå som ökar det fysiska paketet till 251 byte och måste förhandlas separat.

Skillnad mellan MTU och DLE: ATT MTU — hur mycket data som överförs i en GATT-begäran, DLE — hur mycket data som får plats i ett Link Layer-paket. För maximal hastighet måste båda parametrarna förhandlas. Utan DLE kommer data även vid MTU 247 byte att fragmenteras i flera Link Layer-paket om 27 byte, vilket minskar bandbredden.

MTU-förhandling: procedur och protokoll

MTU Size Request — procedur som initieras av Central efter att GATT-anslutning har upprättats. Central skickar en MTU Request med sin MTU-kapacitet (den maximala storlek den kan ta emot). Peripheral svarar med en MTU Response med sitt värde. Det använda MTU är minimivärdet av de två. Om Central föreslår MTU 512 och Peripheral endast stödjer 128, kommer anslutningen att använda MTU 128.

import CoreBluetooth

// Begär maximalt MTU i iOS
func requestMTU(central: CBCentralManager,
                    peripheral: CBPeripheral) {
    peripheral.maximumWriteValueLength(
        for: .withoutResponse
    )

// iOS förhandlar automatiskt MTU vid anslutning
            // MTU = 512 för BLE 5.0-enheter
    let mtu = peripheral.maximumWriteValueLength(
        for: .withResponse
    )

    print("Förhandlat MTU: " +
          String(mtu))
}

Timing för förhandling: MTU Request bör skickas efter upptäckt av tjänster (discoverServices), men innan aktiv dataöverföring påbörjas. I iOS förhandlar Core Bluetooth automatiskt MTU vid anslutning — utvecklaren behöver inte skicka MTU Request manuellt. I Android måste requestMTU anropas explicit. Efter förhandling förblir MTU fixerat för denna anslutning — omförhandling är omöjlig utan frånkoppling och återanslutning.

ATT-begränsningar: varför MTU inte kan vara större än 251 byte

ATT (Attribute Protocol) — protokollet som GATT är byggt på. Ett ATT-paket har en maximal storlek på 257 byte (ATT_MTU-1). Av dessa är 1 byte Opcode (operationstyp), 1 byte är Handle och upp till 255 byte är Value. Således är det maximala MTU som tillåts av ATT-specifikationen 257 byte (i praktiken används upp till 251 byte eftersom vissa tjänstefält ändå behövs).

För att skicka data större än MTU används fragmentering på applikationsnivå. Utvecklaren delar själv upp data i bitar av storlek ≤ MTU och skickar dem sekventiellt. Varje bit är formellt en separat GATT Write Request. Den mottagande sidan assemblerar bitarna till en enda buffert. Inbyggt stöd för fragmentering i GATT finns inte — detta är utvecklarens uppgift.

Intressant faktum: iOS och Android begär MTU på 512 respektive 517 byte, men detta värde överskrider ATT-gränsen. I praktiken fragmenterar BLE-stacken automatiskt sådan data och skickar den som flera sekventiella GATT-begäran om maximalt 251 byte. För utvecklaren är skillnaden omärkbar — writeValue fungerar med valfri storlek upp till 512 byte i iOS.

MTU:s påverkan på prestanda

MTU-storleken påverkar direkt bandbredden för BLE-anslutningen. Vid MTU 23 byte är den maximala användbara överföringshastigheten cirka 7–10 KB/s under ideala förhållanden. Att öka MTU till 247 byte höjer hastigheten till 60–90 KB/s (med DLE och optimalt connection interval). Detta är särskilt viktigt för applikationer som överför bilder, ljudfragment eller loggar.

BLE-överföringens prestanda beror på tre faktorer: MTU (hur mycket data i en ATT-begäran), connection interval (hur ofta utväxlingshändelser inträffar) och DLE (hur mycket data i ett Link Layer-paket). Optimal konfiguration för maximal hastighet: MTU = 247, DLE = 251, connection interval = 7.5 ms (minimivärde).

Enligt data från Bluetooth SIG White Paper (2023) ökar ökningen av MTU från 23 till 247 byte vid connection interval 30 ms bandbredden från 8 KB/s till 42 KB/s — en ökning med 5 gånger. Vid connection interval 7.5 ms når bandbredden 88 KB/s. För applikationer som inte kräver hög hastighet (temperatursensorer, BLE-beacons) är standard MTU 23 byte fortfarande tillräckligt.

Konfigurera MTU i iOS och Android

iOS Core Bluetooth förhandlar automatiskt MTU vid anslutning till Peripheral. Utvecklaren kan kontrollera aktuellt MTU via maximumWriteValueLength, men kan inte ställa in det manuellt. iOS använder MTU upp till 512 byte för BLE 5.0-enheter och upp till 247 för BLE 4.2. För att skriva stora datamängder, använd writeType: .withResponse för garanterad leverans.

// Begär MTU i Android (Kotlin)
val bluetoothGatt: BluetoothGatt = ...

// Begär MTU 517 byte
bluetoothGatt.requestMtu(517)

// Hantera resultat i callback
override fun onMtuChanged(
    gatt: BluetoothGatt,
    mtu: Int,
    status: Int
) {
    if (status == BluetoothGatt.GATT_SUCCESS) {
        println("MTU negotiated: $mtu")
    }
}

Android tillhandahåller BluetoothGatt.requestMtu(int), som möjliggör begäran av valfritt MTU upp till 517 byte. Det faktiska MTU bestäms av den perifera enheten — om den endast stödjer 23 byte kommer Android att returnera MTU 23. För att bestämma aktuellt MTU, använd gatt.requestMtu(0) — detta returnerar aktuellt värde utan att försöka ändra det. Android 12+ stöder automatisk MTU-förhandling vid anslutning via TRANSPORT_LE.

Plattformsoberoende ramverk (Flutter, React Native) tillhandahåller vanligtvis API för requestMTU. I biblioteket FlutterBlue Plus ställs MTU in som anslutningsparameter. I RxAndroidBle — via metoden requestMtu. Det rekommenderas att alltid förhandla maximalt MTU omedelbart efter upptäckt av tjänster, innan dataöverföring påbörjas, för att undvika fragmentering på applikationsnivå.

MTU och OTA-uppdateringar

OTA (Over-The-Air) firmwareuppdateringar — det mest krävande scenariot när det gäller MTU i BLE. Den typiska firmwarestorleken för en IoT-enhet är 100–500 KB. Vid MTU 23 byte och connection interval 30 ms tar överföring av 100 KB cirka 2–3 minuter. Vid MTU 247 byte och DLE 251 byte — 20–40 sekunder. Och vid MTU 512 byte (iOS) — 10–15 sekunder.

OTA-uppdateringsprocessen omfattar vanligtvis: fragmentering av firmware till paket av storlek ≤ MTU, sekventiell sändning via Notify/Write, verifiering av kontrollsumma på varje paket och kvittens. Om ett paket går förlorat begär enheten omöjlig. OTA:s tillförlitlighet beror kritiskt på korrekt val av MTU och connection interval.

Rekommendationer för OTA: förhandla maximalt MTU (247–512 byte), ställ in connection interval till 7.5–15 ms (om enheten stöder), använd DLE (Data Length Extension) för att öka det fysiska paketet till 251 byte. För enheter med begränsat buffertminne (t.ex. BLE-moduler baserade på nRF52), kontrollera maximalt MTU i chipspecifikationen.