MTU no BLE: o que é, tamanho do pacote e negociação

O que é MTU no BLE?

Maximum Transmission Unit (MTU) no contexto do BLE é o tamanho máximo de uma Unidade de Dados do Protocolo de Aplicação (APDU) que um dispositivo pode aceitar em uma única solicitação GATT. O MTU é definido no nível ATT (Attribute Protocol) e inclui o cabeçalho ATT (1 byte) + dados úteis. Por padrão, todos os dispositivos BLE suportam MTU de 23 bytes (23 = 1 byte de cabeçalho ATT + 22 bytes de dados).

O MTU não é um limite físico do canal de rádio, mas sim um acordo entre dispositivos no nível GATT. O tamanho físico do pacote BLE na camada de enlace (Link Layer) pode ser maior (até 27 bytes no BLE 4.0, até 257 bytes no BLE 5.0 com Data Length Extension), mas a camada GATT limita quantos dados são transmitidos por transação. O Data Length Extension (DLE) é um mecanismo separado da camada de enlace que aumenta o pacote físico para 251 bytes e deve ser negociado de forma independente.

A diferença entre MTU e DLE: ATT MTU — quantos dados são transmitidos por solicitação GATT, DLE — quantos dados cabem em um pacote da camada de enlace. Para velocidade máxima, é necessário negociar ambos os parâmetros. Sem DLE, mesmo com MTU de 247 bytes, os dados serão fragmentados em vários pacotes de 27 bytes da camada de enlace, reduzindo a taxa de transferência.

Negociação de MTU: procedimento e protocolo

MTU Size Request — um procedimento iniciado pelo Central após estabelecer uma conexão GATT. O Central envia uma solicitação MTU Request especificando sua capacidade MTU (o tamanho máximo que pode aceitar). O Peripheral responde com uma MTU Response com seu próprio valor. O MTU resultante é o mínimo dos dois valores. Se o Central oferecer MTU 512 e o Peripheral suportar apenas 128, a conexão usará MTU 128.

import CoreBluetooth

// Solicitar MTU máximo no iOS
func requestMTU(central: CBCentralManager,
                    peripheral: CBPeripheral) {
    peripheral.maximumWriteValueLength(
        for: .withoutResponse
    )

// O iOS negocia o MTU automaticamente ao conectar
            // MTU = 512 para dispositivos BLE 5.0
    let mtu = peripheral.maximumWriteValueLength(
        for: .withResponse
    )

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

Momento da negociação: a solicitação MTU Request deve ser enviada após a descoberta de serviços (discoverServices), mas antes do início da transmissão ativa de dados. No iOS Core Bluetooth, o MTU é negociado automaticamente ao conectar — o desenvolvedor não precisa enviar uma MTU Request manualmente. No Android, é necessário chamar requestMTU explicitamente. Uma vez negociado, o MTU permanece fixo para essa conexão — não é possível renegociá-lo sem desconectar e reconectar.

Limitações do ATT: por que o MTU não pode exceder 251 bytes

ATT (Attribute Protocol) — o protocolo sobre o qual o GATT é construído. Um pacote ATT tem um tamanho máximo de 257 bytes (ATT_MTU-1). Destes, 1 byte é Opcode (tipo de operação), 1 byte é Handle, e até 255 bytes são Value. Portanto, o MTU máximo permitido pela especificação ATT é de 257 bytes (mas na prática são usados até 251 bytes, pois alguns campos de overhead ainda são necessários).

Para enviar dados maiores que o MTU, utiliza-se a fragmentação no nível da aplicação. O desenvolvedor divide manualmente os dados em fragmentos de tamanho ≤ MTU e os envia sequencialmente. Cada fragmento é enviado como uma solicitação GATT Write Request independente. O lado receptor monta os fragmentos em um único buffer. Não há suporte embutido para fragmentação no GATT — é responsabilidade do desenvolvedor.

Fato interessante: iOS e Android solicitam MTU de 512 e 517 bytes respectivamente, mas esse valor excede o limite ATT. Na prática, a pilha BLE fragmenta esses dados automaticamente, enviando-os como múltiplas solicitações GATT sequenciais de até 251 bytes cada. Para o desenvolvedor, a diferença é transparente — writeValue funciona com qualquer tamanho de até 512 bytes no iOS.

Impacto do MTU no desempenho

O tamanho do MTU afeta diretamente a taxa de transferência da conexão BLE. Com MTU de 23 bytes, a taxa de transferência útil máxima é de aproximadamente 7–10 KB/s em condições ideais. Aumentar o MTU para 247 bytes eleva a velocidade para 60–90 KB/s (com DLE e intervalo de conexão ideal). Isso é especialmente importante para aplicações que transmitem imagens, fragmentos de áudio ou logs.

O desempenho da transmissão BLE depende de três fatores: MTU (quantos dados por solicitação ATT), intervalo de conexão (com que frequência ocorrem os eventos de troca) e DLE (quantos dados por pacote da camada de enlace). A configuração ideal para velocidade máxima: MTU = 247, DLE = 251, intervalo de conexão = 7.5 ms (valor mínimo).

De acordo com o Bluetooth SIG White Paper (2023), aumentar o MTU de 23 para 247 bytes com um intervalo de conexão de 30 ms aumenta a taxa de transferência de 8 KB/s para 42 KB/s — um aumento de 5 vezes. Com um intervalo de conexão de 7.5 ms, a taxa de transferência atinge 88 KB/s. Para aplicações que não exigem alta velocidade (sensores de temperatura, beacons BLE), o MTU padrão de 23 bytes continua sendo suficiente.

Configuração do MTU no iOS e Android

iOS Core Bluetooth negocia automaticamente o MTU ao conectar a um Peripheral. O desenvolvedor pode consultar o MTU atual através do maximumWriteValueLength, mas não pode configurá-lo manualmente. O iOS usa MTU de até 512 bytes para dispositivos BLE 5.0 e até 247 para BLE 4.2. Para escrever grandes volumes de dados, use writeType: .withResponse para entrega garantida.

// Solicitar MTU no Android (Kotlin)
val bluetoothGatt: BluetoothGatt = ...

// Solicitar MTU 517 bytes
bluetoothGatt.requestMtu(517)

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

Android fornece BluetoothGatt.requestMtu(int), que permite solicitar qualquer MTU de até 517 bytes. O MTU real é determinado pelo dispositivo periférico — se ele suportar apenas 23 bytes, o Android retornará MTU 23. Para determinar o MTU atual, use gatt.requestMtu(0) — isso retorna o valor atual sem tentar alterá-lo. O Android 12+ suporta negociação automática de MTU na conexão via TRANSPORT_LE.

Os frameworks multiplataforma (Flutter, React Native) geralmente fornecem uma API para requestMTU. Na biblioteca FlutterBlue Plus, o MTU é definido como um parâmetro de conexão. No RxAndroidBle — através do método requestMtu. Recomenda-se sempre negociar o MTU máximo imediatamente após a descoberta de serviços, antes do início da transmissão de dados, para evitar fragmentação no nível da aplicação.

MTU e atualizações OTA

Atualizações de firmware OTA (Over-The-Air) — o cenário que mais exige MTU no BLE. O tamanho típico do firmware de um dispositivo IoT é de 100–500 KB. Com MTU de 23 bytes e intervalo de conexão de 30 ms, transferir 100 KB leva cerca de 2–3 minutos. Com MTU de 247 bytes e DLE de 251 bytes — 20–40 segundos. E com MTU de 512 bytes (iOS) — 10–15 segundos.

O processo de atualização OTA geralmente inclui: fragmentação do firmware em pacotes de tamanho ≤ MTU, envio sequencial via Notify/Write, verificação de soma de verificação em cada pacote e confirmação de recebimento. Se um pacote for perdido, o dispositivo solicita retransmissão. A confiabilidade do OTA depende criticamente da seleção correta do MTU e do intervalo de conexão.

Recomendações para OTA: negocie o MTU máximo (247–512 bytes), defina o intervalo de conexão para 7.5–15 ms (se o dispositivo suportar), use DLE (Data Length Extension) para aumentar o pacote físico para 251 bytes. Para dispositivos com memória de buffer limitada (por exemplo, módulos BLE baseados em nRF52), verifique o MTU máximo na especificação do chip.