A Bluetooth LE firmware update takes minutes when too few image bytes move in each connection event, when events are far apart, or when the device cannot write to flash as fast as data arrives. Throughput is roughly the payload per packet times the packets per connection event times the events per second, minus protocol overhead. The levers that matter most are data length extension with a matching ATT MTU (244 image bytes per packet instead of 20), a short connection interval with several packets per event, unacknowledged writes with enough buffers to keep data in flight, the 2M PHY where both sides support it, and erasing flash progressively instead of all at once. The phone or gateway decides much of this, so you must measure with the devices your customers use.
Our BLE update time calculator puts numbers on it. Its default example moves a 412 KB image in 21.6 seconds with 244-byte payloads, 3 packets per event and a 30 ms interval, and needs 4.4 minutes on the same link with 20-byte payloads. This article explains each link in that chain, which side controls it, and how to find the one that is costing you minutes. We checked the Bluetooth SIG, Zephyr, Android and Apple documents cited here in November 2026.
Where the minutes go: the throughput chain
An update over Bluetooth LE is a chain of stages, and the slowest one sets the speed. Fixing a stage that is not the bottleneck changes nothing, which is why so many forum threads report that raising the MTU “did not help”.
| Stage | What sets it | Who controls it |
|---|---|---|
| Image bytes per packet | Link-layer data length and the ATT MTU | Both sides negotiate; the smaller wins |
| Packets per connection event | Buffers on both sides, event length, the PHY, radio conditions | Both stacks, the controller, the environment |
| Events per second | The connection interval | The central (phone or gateway) decides; the device can request |
| Protocol efficiency | Writes with or without response, chunk size, acknowledgments, retries | The update protocol and the app |
| Device write speed | Flash erase and write times, how the update agent handles them | The device firmware and the chip |
| After the last byte | Signature check, image swap, first boot | The bootloader and the slot layout |
The calculator’s formula is the first three rows multiplied together, times an efficiency figure for the fourth. The last two rows are where devices hide time that the radio numbers never show.
Read the figure from the top. Payload size is worth a factor of 12, packets per event a factor of 3, and the interval a factor of 2 per halving. The worst row is not exotic: it is what you get when neither side negotiates a larger packet and the phone keeps a relaxed interval.
Bytes per packet: data length extension and the ATT MTU
The biggest single lever is how many image bytes each link-layer packet carries, and it depends on two separate negotiations. Most “slow update” reports trace back to one of them silently failing.
The Bluetooth SIG’s explainer on Bluetooth 5 throughput gives the link-layer limits. In Bluetooth Core 4.0 and 4.1, the payload field “shall be less than or equal to 27 octets”. In Core 4.2 the limit rises to 251 octets, the feature usually called data length extension, and the SIG notes that “the packet format from Bluetooth Core 4.2 to Bluetooth Core 5.0 is the same: payload is 251 octets”. Both controllers must support it and agree to use it.
The second negotiation is the ATT MTU, the largest attribute protocol packet either side will accept. Zephyr’s GATT header states the overhead: a notification’s value “can contain up to ATT_MTU - 3 octets (size of opcode and handle)”. With an ATT MTU of 23 bytes, a write or notification therefore carries 20 bytes of data. With an ATT MTU of 247, a 4-byte L2CAP header plus the 247-byte ATT packet exactly fills a 251-byte link-layer payload, leaving 244 bytes of data. That is where the calculator’s 244 comes from.
| Data length | ATT MTU | Image bytes per write | What happens |
|---|---|---|---|
| 27 octets | 23 | 20 | The 4.0 default: small packets, many of them |
| 27 octets | 247 | 244 per write, split across about ten small packets | Better than 20, but each write costs many packets and gaps |
| 251 octets | 23 | 20 | Long packets allowed but never filled |
| 251 octets | 247 | 244 | One write fills one link-layer packet |
| 251 octets | 498 | 495 | One write fills two full link-layer packets |
What the phone does
You do not get to set the MTU alone. On Android, the BluetoothGatt reference says “starting from Android 14, the Android Bluetooth stack requests the BLE ATT MTU to 517 bytes when the first GATT client requests an MTU, and disregards all subsequent MTU requests”. It also warns that for a write without response, “the data sent is truncated to the MTU size”, so an app must size its writes to the negotiated value, not the value it asked for. On iOS, Core Bluetooth reports the usable size through maximumWriteValueLength(for:), “the maximum amount of data, in bytes, you can send to a characteristic in a single write type”. Read it after connecting and chunk to it.
Keep a small table for every phone family you support: operating system version, the MTU it settles on, the connection interval it grants during an update, and the PHY. The rows rarely change between minor releases, but when one does, it explains a sudden wave of support tickets better than any log from the device.
What the device must allow
The device side has to accept large packets too, which means enough buffer memory. Zephyr’s MCUmgr sample server shows a tested set in its Bluetooth configuration: an L2CAP transmit MTU of 498, ACL receive and transmit buffers of 502 bytes, and a controller maximum data length of 251, under the comment “Allow for large Bluetooth data packets.” The arithmetic is deliberate: 498 bytes of ATT plus the 4-byte L2CAP header is 502, exactly two full 251-byte link-layer payloads.
Defaults are small. Zephyr’s L2CAP options set the transmit MTU to 23 unless a feature raises it, for example to 65 when Bluetooth security is enabled. If a firmware build keeps such defaults, the phone can ask for 517 and the device will still answer with something small. Log the negotiated MTU and data length on the device for every connection; it is the cheapest diagnostic you will ever add.
Large buffers cost RAM, which small Bluetooth LE microcontrollers do not have in abundance. The sample’s settings imply several 502-byte ACL buffers plus an SMP buffer of 2,475 bytes for reassembly. On a constrained part, size them for one or two chunks in flight rather than copying the sample blindly, and measure whether the extra buffer actually raised throughput before you keep it.
Connection interval and packets per connection event
Once packets are full, speed depends on how often the two sides meet and how many packets they exchange each time. The connection interval sets the first, and the central (the phone or gateway) chooses it.
For most devices in the field today, the interval is at least 7.5 ms in steps of 1.25 ms. The Bluetooth SIG’s Core 6.2 feature overview describes this as the historical minimum and introduces Shorter Connection Intervals, which reduce “the minimum connection interval from 7.5 ms to 375 µs” with 125 µs resolution, aimed at low-latency uses such as input devices and real-time sensing. Both sides must support the feature; otherwise the connection stays on the baseline values. Do not plan a 2027 product’s update time around it until your chips and your customers’ phones support it.
The device asks, the central decides
The same overview spells out the division of roles in its new procedure: the peripheral sends a proposal with a range of acceptable intervals, and “the Central must choose a value within these bounds” or reject the request. In practice, ordinary connection updates feel the same from firmware: you request, you then read back what you got.
Zephyr’s MCUmgr transport can make that request automatically during an update. Its Bluetooth transport options include connection parameter control that requests specific parameters while SMP commands are handled, described as an option that “allows to speed up the command exchange process” and “recommended to enable this if SMP is used for DFU”. The default request is 12 units of 1.25 ms, a 15 ms interval, and the device restores its preferred parameters after 5,000 ms without SMP traffic.
On Android, the app side of the same idea is requestConnectionPriority. The reference describes CONNECTION_PRIORITY_HIGH as “a high priority, low latency connection” that an app “should only request” to “transfer large amounts of data over LE quickly”, and tells the app to return to CONNECTION_PRIORITY_BALANCED afterward “to reduce energy use”. An update app that never makes this call leaves Android at the balanced default unless the device’s own request changes it.
Packets per event: buffers, PHY and the air
Packets per connection event is the least predictable input. It depends on how many buffers each stack has queued, how long the controller lets an event run, the PHY, and retransmissions when the channel is noisy. The SIG’s explainer gives the timing that bounds it: the inter-frame space between packets “should be 150 µs”, a full 265-octet packet on the 2M PHY “will consume 1060 µs”, and an empty acknowledgment packet takes 80 µs at 1 Mb/s and 40 µs at 2 Mb/s.
From those figures, one full data packet plus its acknowledgment and two inter-frame spaces takes about 2.5 ms on the 1M PHY (2,120 µs for the 265-octet packet at 1 Mb/s, plus 80 µs and 300 µs) and about 1.4 ms on 2M. In a 15 ms interval, that is a theoretical ceiling of 6 exchanges on 1M and 10 on 2M if the whole interval could be used. Real stacks schedule shorter events and fewer buffers, so treat these as upper bounds and measure the real count with a sniffer or your stack’s logs.
The 2M PHY: shorter packets, more of them per event
The LE 2M PHY halves the airtime of each packet, which mainly raises the number of packets that fit in an event. The Bluetooth SIG puts the theoretical gain at “~4.6 times greater than Bluetooth Core 4.0/Bluetooth Core 4.1 and ~1.7 times greater than 4.2”, and names “over-the-air firmware upgrades” as one of the beneficiaries.
Three cautions keep that number honest:
- It is optional. The SIG’s companion article on range says support for the LE 2M PHY “in a stack implementation is optional”, while LE 1M support “is mandatory”. Check every chip and every phone you support.
- It is a request. Android’s
setPreferredPhynotes that “this is just a recommendation, whether the PHY change will happen depends on other applications preferences, local and remote controller capabilities. Controller can override these settings.” Log the PHY you actually get. - It does not fix a long interval. If the phone holds a 45 ms interval and your stack sends one packet per event, a faster PHY only makes the radio idle longer.
Where it does work, the 2M PHY pays off through packets per event. In the figure at the top of this article, going from 3 to 6 packets per 15 ms event halves the transfer from 10.8 to 5.4 seconds; on the 1M PHY the theoretical ceiling of about 6 full exchanges in 15 ms leaves no room for that, while 2M raises the ceiling to about 10.
The coded PHY works the other way. The SIG says it “allows range to be quadrupled (approximately), compared to Bluetooth Core 4.0”, at the cost of much lower data rates. A device that falls back to coded PHY at the edge of range will update slowly there; for updates, move closer or accept the time.
Further out, the SIG announced on July 28, 2026 an upcoming LE High Data Throughput feature that it says will raise the maximum data rate “from 2 Mbps today to up to 7.5 Mbps”. It is described as upcoming, so it belongs in a roadmap note, not in this year’s update budget.
The update protocol: writes, acknowledgments and flow control
How the update protocol uses the link can waste most of what the radio settings bought. The rule is simple: keep data in flight, and never wait for a round trip per small chunk.
Zephyr’s SMP transport specification describes how MCUmgr’s Simple Management Protocol (SMP) uses Bluetooth LE. “All SMP communication utilizes a single GATT characteristic. An SMP request is sent via a GATT Write Without Response command. An SMP response is sent in the form of a GATT Notification.” Requests larger than one write are split across several packets with no extra framing, and the SMP header in the first fragment carries what the device needs to reassemble them.
The image management group then defines the upload: “The image upload request is sent for each chunk of image that is uploaded, until complete image gets uploaded to a device.” Each request carries an offset and data; the first one also carries the image length and, optionally, a SHA-256 of the whole image. That hash lets the device resume a broken session: if a client restarts at offset zero with the same hash, the device answers with the offset to continue from.
Chunk size and how many chunks are in flight
Two client choices dominate protocol efficiency:
- Chunk size. Each upload request has an SMP header and CBOR encoding around the data. Bigger chunks spread that overhead over more image bytes, up to what the device can buffer. Zephyr’s sample enables packet reassembly over Bluetooth and sizes its buffer “to fit one SMP packet divided into five Bluetooth Write Commands, transmitted with the maximum possible MTU value: 498 bytes”.
- Chunks in flight. A client that sends one chunk and waits for its notification before sending the next pays a full round trip per chunk, typically one or two connection intervals. A client that keeps several chunks queued needs the device to have buffers for them. Zephyr’s OS management group has an “MCUmgr parameters” command that returns
buf_sizeandbuf_count, so a client can size chunks and the number in flight to the device instead of guessing.
Flow control on the phone
Writes without response still need flow control, or the app outruns the phone’s transmit queue. On iOS, Core Bluetooth exposes canSendWriteWithoutResponse and a delegate callback, peripheralIsReady(toSendWriteWithoutResponse:), that tells the app the peripheral “is again ready”. An app that writes in a tight loop without checking these can see stalls that look like radio problems. On Android, the reference lists a GATT_CONNECTION_CONGESTED status for “a remote device connection is congested”, which an update loop must handle by waiting rather than resending blindly.
Design the app for the slowest phone
The phone app is half of the update path, and most of its speed problems are really timeout and recovery problems. Four habits make updates both faster and less fragile:
- Size timeouts to the device, not the radio. The first chunk may wait for an erase and the last step waits for verification. A timeout tuned for a 50 ms round trip turns a slow erase into a failed update.
- Resume instead of restarting. Send the image’s SHA-256 in the first upload request. Zephyr’s image management uses it “to identify an upload session (e.g. to allow MCUmgr to continue a broken session)”, so after a dropped connection the device answers with the offset to continue from. Without the hash, every disconnect restarts the transfer from zero.
- Reject a wasted transfer early. The upload request has an optional “upgrade” flag; with it set, “if the version of uploaded software is not higher then already on a device, the image upload will be rejected”. The app learns this on the first chunk, not after a full transfer.
- Show progress from the device’s offsets. The offset in each response is the device’s own count of what it has stored, which is the honest number to show a user.
Flash: erase and write on the device
The radio can deliver data faster than many microcontrollers can erase flash, and an update agent that erases the whole slot before accepting data adds a long pause at the start. Zephyr’s SMP image management documentation warns that its explicit image erase command “is synchronous command which means that a sender of request will not receive response until the command completes, which can take a long time”. A phone app waiting through that pause may time out and report a failed update.
Zephyr’s answer is a configuration option, CONFIG_IMG_ERASE_PROGRESSIVELY. Its help text says: “If enabled, flash is erased as necessary when receiving new firmware, instead of erasing the whole image slot at once. This is necessary on some hardware that has long erase times, to prevent long wait times at the beginning of the DFU process.” Progressive erase spreads the same total erase time across the transfer, where it overlaps with radio time that would otherwise be spent waiting.
The total still has to be paid somewhere, so do the arithmetic for your chip. Suppose, hypothetically, a chip erases a 4 KB page in 80 ms. Loamwick’s 448 KB slot holds 112 such pages, so erasing it up front costs about 9 seconds before the first chunk is accepted; erased progressively, the same 9 seconds hide inside a 21.6-second transfer. Take the real page erase and write times from your chip’s datasheet, and remember that an external SPI flash chip holding the second slot has its own, often different, figures.
After the last byte: verify, swap and reboot
The calculator adds 15 seconds for the work after the transfer, and that figure deserves its own measurement. The bootloader checks the signature over the whole image, then, in a swap-based layout, moves sectors between slots. MCUboot’s design documentation describes its swap-using-offset algorithm, now preferred over swap-using-move for new products, as copying each sector from the primary slot to the secondary and the next sector from the secondary back to the primary until all sectors are swapped. Every sector is erased and written on both sides, so swap time grows with image size and with your chip’s erase time.
Layouts that avoid the swap, such as overwrite-only or running directly from either slot, shorten this step but change what happens when an update fails. Our article on A/B versus single-slot updates compares those trade-offs; do not pick a layout to save seconds and lose your rollback.
Security and recovery: time well spent
Some steps make an update slower on purpose, and they should stay. The goal is to keep them from looking like bugs to the user.
Pairing and encryption. Zephyr’s MCUmgr Bluetooth transport offers three permission levels for the SMP characteristic: read and write allowed, encryption required, or “encryption and authentication” required. When Bluetooth security is enabled in the build, the default is the strictest one. An unauthenticated update characteristic lets anyone in radio range try to push an image, so the device must rely entirely on the bootloader’s signature check. Keep the signature check in every case, and add link security where a stranger’s connection attempt is a real risk. With bonding, pairing happens once rather than at every update, so it rarely matters for speed.
Signature verification. The bootloader checks the signature over the whole image before it runs it, and that time grows with image size. It is the step that refuses an image signed with any other key, so it is not a candidate for skipping; measure it and include it in the user’s progress display.
Recovery from interruption. A dropped connection, a phone call or a user walking away is normal. The SHA-based resume described above turns those events into a short pause instead of a full restart. On the device, a slot layout that keeps the running image intact until the new one is complete and verified means an interrupted transfer costs only time. Our overview of what it takes to ship firmware you can safely update covers the rest of that path.
Image size: when smaller beats faster
Everything above divides the image size by a rate, so a smaller image helps every row of the chain. On a fast Bluetooth LE link, though, the savings are usually modest. Our article on delta firmware updates works the fictional Loamwick probe through it: a 30 percent delta of the 412 KB image would save about 15 seconds of connection time per probe per release, which is too little to justify the added complexity on that link.
Size matters more in three cases:
- Slow or long-range links, such as coded PHY at the edge of range or a phone that holds a long interval, where each kilobyte costs real time.
- Gateways updating many devices in turn, where per-device time multiplies by the fleet.
- Coin cell devices, where every second of radio and every erase cycle comes out of a small battery.
Cheap size reductions come before deltas: strip debug logging and unused features from release builds, check link maps for large libraries pulled in by one function, and keep calibration data and certificates out of the image.
The payoff scales with how slow the link is. For example, trimming a 412 KB image to a hypothetical 360 KB, about 13 percent smaller, saves under 3 seconds at the calculator’s default settings but about 33 seconds on the 20-byte, 3-packet link in the figure above, and nearly 3 minutes on the worst row. Fix the link first; then size reductions are a bonus rather than a rescue.
When you control the central: gateways and test fixtures
Everything changes when the central is your own device: a gateway, a hub or a factory test fixture. You then choose the connection interval, the ATT MTU you request, the PHY and the number of packets your side will queue, instead of hoping a phone grants them.
That control comes with two duties. First, the peripheral still has to accept large packets and keep up with flash writes, so the device-side settings above still apply. Second, a gateway usually updates many devices, so per-device time multiplies. A gateway that updates one device at a time for 36.6 seconds each spends about 24 minutes on 40 devices; halving the transfer saves real gateway radio time and, for a solar or battery gateway, real energy.
Three gateway habits pay off:
- Request fast parameters only for updates. Use a short interval and the largest data length during the transfer, then return to the device’s low-power parameters, the same pattern Zephyr’s MCUmgr connection parameter control follows on the peripheral side.
- Schedule updates around the device’s job. A sensor that must report every 5 minutes should not lose a reading to an update; start the transfer right after a report.
- Keep staged rollouts. A faster transfer is not a reason to update every device at once. Waves still catch a bad release before it reaches the whole fleet.
Example (fictional). Loamwick’s gateway updates its LW-1 probes over Bluetooth LE. Because the gateway is Loamwick’s own central, the team controls both ends: it requests a 15 ms interval, an ATT MTU of 247 and the 2M PHY from the gateway side, and logs what each probe negotiates. With 244-byte payloads, 3 packets per event and 80% efficiency, the calculator gives 10.8 seconds for the 412 KB image, half the 21.6 seconds of its default at 30 ms, and about 25.8 seconds with the 15-second verify, swap and reboot. Across the pilot’s 40 probes updated one at a time, that is about 17 minutes instead of about 24. The team keeps the probes’ rollout in waves of 4, 12 and 24 with 48 hours between them, so the gain shows up as shorter radio time per probe rather than a faster rollout.
Measure before you tune
The fastest way to a faster update is to find out which stage is slow on your real devices. A one-hour measurement session usually names the culprit; tuning without one usually moves the wrong setting.
- Log the negotiated link on the device for every update connection: ATT MTU, data length in both directions, PHY, connection interval and peripheral latency. These are the values you got, not the ones you asked for. In Zephyr, the connection callbacks
le_param_updated,le_phy_updatedandle_data_len_updatedand the GATT callbackatt_mtu_updatedreport each change as it happens. - Timestamp the phases: connect, service discovery, MTU and parameter negotiation, first chunk, last chunk, verify, swap, first boot of the new image. Each phase is a separate problem.
- Count packets per event with a Bluetooth sniffer or your stack’s controller statistics during the upload.
- Record chunk round trips in the app: time from sending each upload request to receiving its response.
- Repeat on every phone family you support, including the oldest Android and iOS versions, and on your own gateway if you have one.
- Compare with the calculator. Enter the negotiated values in the BLE update time calculator, then adjust its efficiency figure until it matches your measured transfer time. The gap between your efficiency and the default 80 percent is protocol overhead you can attack.
| Symptom | Likely bottleneck | First thing to check |
|---|---|---|
| Fast on one phone, slow on another | Phone-side interval, MTU or PHY | The negotiated values per phone |
| Long pause before progress starts | Full-slot erase before the first chunk | Progressive erase, app timeouts |
| Steady but slow progress with 20-byte writes | MTU or data length negotiation failed | Device buffer sizes, the app’s MTU request |
| Progress in bursts with stalls | Flow control or flash writes blocking the receive path | Write-without-response readiness, chunk buffers, flash write path |
| Fast transfer, then a long wait | Signature check and swap | Bootloader timing, slot layout |
| Slower at the edge of range | Retransmissions or coded PHY | PHY in use, packet error counts |
What to change first
Work down the chain in order, measuring after each change, and stop when the transfer is no longer the slowest part of your update.
- Confirm 244-byte or larger writes. Enable data length extension, set device buffers for a 247-byte or larger ATT MTU, request a large MTU from the app, and chunk to the negotiated size.
- Shorten the interval during updates only. Request a short interval when the update starts (Zephyr’s MCUmgr connection parameter control does this) and call
requestConnectionPrioritywith high priority on Android, then return to balanced when done. - Keep chunks in flight. Use write without response, respect the phone’s flow control, and size chunks and queue depth from the device’s reported buffers.
- Ask for the 2M PHY where both sides support it, and log whether you got it.
- Erase progressively so the first chunk is accepted immediately, and measure the verify and swap time separately.
- Shrink the image where it is cheap, and consider deltas only on slow links or large fleets.
Where each setting lives
| Setting | Zephyr device | Android app | iOS app |
|---|---|---|---|
| Large packets | CONFIG_BT_CTLR_DATA_LENGTH_MAX=251; ACL buffers sized for the MTU (the sample uses 502) |
Negotiated by the stack | Negotiated by the system |
| ATT MTU | CONFIG_BT_L2CAP_TX_MTU (the sample uses 498) |
requestMtu; Android 14 and later request 517 once |
Read maximumWriteValueLength(for:) and chunk to it |
| Connection interval | CONFIG_MCUMGR_TRANSPORT_BT_CONN_PARAM_CONTROL (requests 15 ms by default) |
requestConnectionPriority(CONNECTION_PRIORITY_HIGH), then balanced |
Decided by the system |
| PHY | Request 2M after connecting | setPreferredPhy, a recommendation only |
Decided by the system |
| Chunks in flight | CONFIG_MCUMGR_TRANSPORT_BT_REASSEMBLY, CONFIG_MCUMGR_TRANSPORT_NETBUF_SIZE, CONFIG_MCUMGR_GRP_OS_MCUMGR_PARAMS |
Write without response; wait on congestion | canSendWriteWithoutResponse and the ready callback |
| Flash erase | CONFIG_IMG_ERASE_PROGRESSIVELY |
Timeouts long enough for erase and verify | Timeouts long enough for erase and verify |
The Zephyr values come from the MCUmgr sample server’s Bluetooth configuration and the transport options cited above; treat them as a tested starting point, then size buffers to your RAM.
Fumbar writes embedded firmware and update systems for hardware startups. Our connectivity work covers Bluetooth LE connection parameters, phones and gateways, and our over-the-air updates service covers the bootloader, signing and the update protocol on the device. Consumer devices updated from a phone app are a common case on our connected consumer products page. If you want your update path measured and read alongside your code, a firmware review is a short, fixed-scope first engagement that ends in a written plan.
