Compute or Communicate? A Break-Even Criterion for Splitting Wearable AI Between Microcontrollers and Body-Coupled Links

Meghna Roy Chowdhury1, Gourav Datta2 and Shreyas Sen1

1Elmore Family School of Electrical and Computer Engineering, Purdue University
2Department of Electrical, Computer, and Systems Engineering, Case Western Reserve University

Summary

We show that the wireless link determines where a wearable should run its neural network. Over Bluetooth Low Energy (BLE), running the first layers on the wearable reduces energy for networks that compress their input early. Over Wi-R, a body-coupled link, streaming the raw sensor data uses the least energy for all six networks and 19 microcontrollers we model.

Wi-R couples the signal through the body instead of radiating it, which lowers the energy per transmitted bit by about 15× relative to BLE in our model. A split saves energy only when the transmission it removes costs more than the multiply-accumulate operations (MACs) it adds on the microcontroller (MCU).

(a) A wearable AI model split at layer k: the wearable runs layers 1 to k and sends B_k bits, the hub runs the rest; the wearable can send the input, a feature or the result. (b) For SleepFM on the STM32U385 (81 pJ/MAC), computing features locally pays only below 123.3 pJ/MAC over BLE (10.9 nJ/bit) and below 8.35 pJ/MAC over Wi-R (0.73 nJ/bit), so over Wi-R sending the input uses less energy.
Figure 1. (a) Wearable inference placements. (b) Lowest-node-energy placement for SleepFM on STM32U385 as only its energy per MAC varies, at the effective link energies. The break-even for local feature extraction falls from 123.3 pJ/MAC over BLE to 8.35 over Wi-R, below every evaluated MCU. The complete model fits no MCU.
11 → 0network–MCU pairs, of 114, in which on-wearable computation minimizes energy: over BLE and over Wi-R
7.17 nJ/bitcrossover energy per bit for SleepFM on the STM32U385. Above it, computing first minimizes energy; below it, streaming does. BLE: 10.9; Wi-R: 0.73.
6.1–13.5×median energy reduction of Wi-R streaming relative to the best BLE option, for BLE keep-alive intervals of 30 ms to 4 s

All results come from an analytical energy model based on datasheets, MLPerf Tiny measurements and Ixana's public power calculator; we have not measured them on hardware. The model counts only the wearable. It excludes the receiving phone or hub, and because phones have no Wi-R radio, a Wi-R deployment needs a body-worn hub. Disclosure: S. Sen founded Ixana, which makes Wi-R.

Motivation

Wearables offload most of a modern neural network because they lack the memory and energy to run it. The largest of the 19 microcontrollers we evaluate has 4 MB of memory, whereas recent wearable foundation models exceed 100 million parameters. Most of the network therefore runs on a phone or an on-body hub.

The common design response is to compute part of the network on the wearable so that it transmits fewer bits. The reason is the cost of radios. Chatterjee et al. estimate that transmitting a bit costs about 104 times the energy of switching a bit in a 45–65 nm chip, and that BLE-class radios draw two to three orders of magnitude more power than sensing and computation [1]. Splitting a network and transmitting an intermediate feature map applies the same in-sensor analytics principle.

However, computation on a commercial microcontroller is not free: it costs tens to hundreds of picojoules per MAC, far more than switching a single bit. A split therefore saves energy only when the transmission it removes costs more than the computation it adds, and this comparison depends on the link. Figure 2 shows it for one network on one microcontroller.

Figure 2 · SleepFM on the STM32U385, energy per 5-min window
Over BLE, transmission dominates and computing the tokens first reduces energy. Over Wi-R, the same computation increases energy.
Over BLESend the raw input204 mJCompute tokens, then send157 mJlowestOver Wi-RSend the raw input13 mJlowestCompute tokens, then send95 mJcomputing on the wearablesending over BLEsending over Wi-R
Computing SleepFM's tokens on the wearable costs 91 mJ and reduces the data 10×. Over BLE, this removes 139 mJ of transmission, a net saving. Over Wi-R, the entire raw stream costs 13.4 mJ, so the tokenizer removes only 9 mJ of transmission while adding 91 mJ of computation.

Expressed in MACs, one bit transmitted over BLE costs the STM32U385 as much energy as 135 MACs, and one bit over Wi-R as much as 9, including the MCU time spent transmitting. SleepFM's tokenizer spends 89 MACs per bit it removes. The tokenizer therefore saves energy over BLE but not over Wi-R. The next section formalizes this comparison.

Break-even condition

We split the network after layer k. The wearable then computes Ck MACs and transmits Bk bits instead of the raw B0 bits. The split reduces energy when the following holds.

Step 1 · Energy comparison
Ck · eMAC  <  (B0 − Bk) · ēbit  +  Ck · Psl / Θ
The left side is the energy of the Ck MACs. The right side is the energy of the B0 − Bk bits no longer transmitted, plus the MCU sleep energy that the computation time displaces; Psl is the MCU's sleep power and Θ its MAC throughput in MACs per second, so Ck/Θ is the computation time.
Step 2 · Per-MAC form
eMAC  <  ēbit · (B0 − Bk) / Ck  +  Psl / Θ
Dividing by Ck expresses both sides in energy per MAC. The left side is what the microcontroller spends; the right side is the largest energy per MAC at which the split still saves energy.
Step 3 · Network and link terms
ρk = (B0 − Bk) / Ck   bits removed per MAC, a property of the network
ρk measures how efficiently the first k layers compress the input. Its inverse, 1/ρk, is easier to read: the number of MACs the network spends to remove one bit. SleepFM's tokenizer removes 12.72 Mbit with 1.13 billion MACs, so it spends 89 MACs per bit removed (ρ = 11.3 bits per 1,000 MACs). A network that needs many MACs to shrink its data slightly spends many MACs per bit, and a layer that does not shrink the data removes no bits at all.
ecrit = ēbit · ρk + Psl / Θ   the break-even energy per MAC
On-wearable computation reduces energy when eMAC < ecrit.
Step 4 · Cost of removing a bit against cost of sending it
1 / ρk  <  ēbit / (eMAC − Psl / Θ)
The same condition, rearranged. The left side is the number of MACs the network spends to remove one bit. The right side is the number of MACs whose energy equals one transmitted bit. Computing first reduces energy when removing a bit costs fewer MACs than sending it. On the STM32U385, one BLE bit is worth 135 MACs and one Wi-R bit 9; SleepFM's tokenizer spends 89, so it pays over BLE and not over Wi-R (Figure 3).
Per-bit link energy
ēbit = etx + (Ph − Psl − Plink) / R
ēbit is the all-in energy of one transmitted bit: radio energy, plus the MCU held awake during transmission, minus the MCU sleep and link keep-alive that the transmission time replaces.
TermMeaningSet by
eMACMCU energy per multiply-accumulateMCU
ρkBits removed per MAC spent, up to split kNetwork
ēbitFull energy of one sent bit: radio energy (etx) plus the MCU kept awake while sending (Ph), minus the MCU sleep and link keep-alive that the sending time replaces, at data rate RLink and MCU
Psl / ΘMCU sleep energy that each MAC displaces (about 0.1 pJ): sleep power Psl divided by MAC throughput Θ, in MACs per secondMCU
Figure 3 · MACs each network spends to remove one bit, STM32U385
SleepFM removes a bit for fewer MACs than a BLE bit is worth, but not for fewer than a Wi-R bit is worth. The other networks spend thousands of MACs per bit.
Each dot is a network at its most compressing cut. The dashed lines mark how many MACs one transmitted bit is worth on the STM32U385: 135 for BLE and 9 for Wi-R. A network left of a line removes bits more cheaply than that link sends them, so computing first pays on that link. SleepFM (89) lies between the lines. EnsembleSleepNet (138) sits just right of the BLE line on this MCU and crosses it on 3 of the 19 MCUs.
Design implication. The break-even is the product of a link term and a network term, so lowering the link's energy per bit lowers the threshold for every network at once. With ēbit in nJ/bit and ρk in bits per 1,000 MACs, ecrit in pJ/MAC equals their product plus about 0.1. Below the crossover ēcross = (eMAC − Psl/Θ) / ρk, streaming the raw input minimizes energy.
Worked example: every number for SleepFM on the STM32U385

SleepFM reads 23 sleep-lab channels at 128 Hz in 5-min windows, which amounts to 14.13 Mbit of 16-bit samples. Its CNN tokenizer reduces them to 1.41 Mbit of 8-bit tokens with 1.13 GMAC, so ρ = 11.3 bits per 1,000 MACs. The STM32U385 spends 81 pJ per MAC (MLPerf Tiny measurement).

BLEWi-R
ēbit (nJ/bit)10.90.73
Break-even ecrit = ēbit × ρ + 0.1 (pJ/MAC)123.38.35
STM32U385 eMAC (pJ/MAC)8181
Energy, stream the raw input (mJ per 5 min)204.413.4
Energy, send the tokens (mJ per 5 min)156.795.3
Lower-energy optionSend the tokens (23% less energy)Stream the raw input (7.1× less energy)

For this network and MCU, ēcross = (81 − 0.11) / 11.3 = 7.17 nJ/bit. BLE lies above the crossover and Wi-R below it, so the optimal placement changes when only the link changes. Wi-R streaming is also the lowest of the four options: 13.4 mJ, 11.7× below the better BLE option (156.7 mJ).

Interactive explorer

The explorer applies the break-even condition to any of the 114 network–MCU pairs. Select a network, a microcontroller and the BLE keep-alive interval. The two panels evaluate BLE and Wi-R with the full model, including sleep and link maintenance between inferences. The chart below them evaluates an arbitrary link from its energy per bit.

Network
BLE keep-alive between inferences

Arbitrary link energy per bit

ēbit is the all-in energy of one transmitted bit, including the MCU time spent transmitting. Drag the slider or the chart to set a hypothetical link: the optimal cut changes at the crossover. The BLE and Wi-R buttons jump to the real values for the selected MCU.

Stream the raw inputCompute first (best cut)lower-energy option

Results across six networks and 19 microcontrollers

Across all 114 network–MCU pairs, on-wearable computation minimizes energy in 11 pairs over BLE and in 0 over Wi-R. We define a network's crossover as the energy per bit above which computing first reduces energy. Only SleepFM and EnsembleSleepNet, which compress their data in early layers, have crossovers near BLE's energy per bit. Every crossover lies above Wi-R's.

NetworkTaskBest cutMACs per bit removedCrossover on STM32U385 (nJ/bit)Compute wins on BLECompute wins on Wi‑R
SleepFM encoderSleep foundation model on 23 polysomnography channels (EEG, ECG, respiration and others), 5-min windows5-s tokens (one per channel per 5 s)897.1780
EnsembleSleepNetSleep staging from 9 channels with 3 sub-models, 30-s epochsPer-channel CNN outputs (27 branches) †13811.130
AttX (VGG)3-class classification from ECG and electrodermal activity, 4-s hopsFinal class scores (3 classes) †3,30026600
AttX (ResNet)Same task with a ResNet backbone, 4-s hopsFinal class scores (3 classes) †3,50028000
LSM-BaseWearable-sensor foundation model, 5-h windowsFinal embedding (average over all tokens) †133,90010,83400
SensorLM-B sensor towerSensor encoder of a sensor–language model, 1-day windowsFinal sensor embedding (average + projection) †466,60037,74000

The best cut spends the fewest MACs per bit removed (1/ρ). Crossover = (eMAC − Psl/Θ) / ρ on the STM32U385, where BLE costs 10.9 and Wi-R 0.73 nJ/bit; † marks cuts that exceed its memory. The last two columns count the MCUs, of 19, on which computing first minimizes energy; each MCU uses its own link energy.

Robustness

We test each main result against parameter error and against the modeling choices most likely to change it.

ResultCondition under which it changes
Over Wi-R, raw streaming outperforms on-wearable computation in all 114 pairsThe result changes only if MCU compute energy is 3.9× lower than assumed or Wi-R energy per bit is 3.9× higher. It also requires a Wi-R rate of at least 2.5 Mb/s (at 1 Mb/s, one pair flips) and packet delivery of at least 99%. Because Wi-R has no acknowledgments, one pair flips at 95% delivery, two at 90% and four at 80%. In random draws that vary every MCU's compute energy and each link's energy by up to 2×, the result holds in 99.95% of cases.
Wi-R streaming uses less energy than the best BLE optionThis holds in all 114 pairs at a BLE keep-alive interval of 30 ms (median 13.5×) or 1 s (median 6.1×). At 4 s, the longest interval BLE allows, it holds in 92 pairs (median 6.1×). For LSM-Base and SensorLM-B on the 11 MCUs with a built-in BLE radio, BLE streaming then requires 6–43% less energy, because sleep dominates their hours-long inference periods. At 90% packet delivery on both links, it holds in 112 pairs.
Over BLE, SleepFM on the STM32U385 computes firstThe result changes if the STM32U385 spends 1.52× more energy per MAC than its measured 81 pJ. It holds in 75% of the random draws.
Over BLE, computing first minimizes energy in 11 pairsThe count is unchanged for BLE keep-alive intervals from 30 ms to 4 s, and random draws give 5 to 19 pairs (median 11). With an fp32 model instead of int8, the count falls to 1, because each MAC costs 2.2–20× more and each cut transmits 4× the bits.

Results from the model's parameter sweeps (robustness.py, sweeps.js). The sweeps test parameter values, not the structure of the model.

Direction of each modeling assumption

Favors raw streaming over Wi-RFavors on-wearable computation
BLE maintains its connection between inferences (30-ms default), whereas Wi-R sleeps between inferences with no link-maintenance costOnly MACs are counted, so compute energy is a lower bound
Packet delivery defaults to 100%, although Wi-R has no acknowledgmentsThe memory check excludes runtime buffers, so more cuts fit than in practice
The receiving phone or hub is excluded; raw streaming moves all computation to itThe model uses int8; fp32 would cost 2.2–20× more per MAC and transmit 4× the bits
Wi-R parameters come from the manufacturer's public calculator, and its wake-up energy is a model estimateThe MCU remains awake during the entire transfer, which raises the energy of every transmitted bit
AttX's raw input is counted over its full 10-s window, although consecutive windows overlap by 6 s

Assumptions

All numbers are model estimates based on datasheets, Ixana's public power calculator [2] (screenshot below) and MLPerf Tiny benchmarks; we have not measured them on hardware. Ixana makes Wi-R, and one of the authors (S. Sen) founded it.

The numbers apply to the parameter values below and are not fixed properties of BLE, Wi-R or any MCU; the calculator recomputes them for any setting. The method carries over to other designs: compare the bits a split removes per MAC with the MCU's energy per MAC and the link's energy per bit.

What we count

  • Only the wearable's chip and radio, over one inference period
  • Not the receiving phone or hub. Phones have no Wi-R radio, so Wi-R needs a body-worn hub, and raw streaming moves all computation to it
  • Not the sensors or the model's accuracy
  • Every packet arrives (no losses)

The wearable

  • 8-bit (int8) network, 16-bit sensor data
  • Energy per MAC: measured by MLPerf Tiny where available, otherwise from the datasheet
  • Computes, then transmits; stays awake during transmission and sleeps otherwise

BLE

  • 2 Mb/s, one connection event every 30 ms, up to 6 packets per event
  • 244 bytes of data per packet
  • Stays connected between inferences: one empty connection event every 30 ms (about 160 µW)

Wi-R

  • 5 Mb/s, 255 bytes of data plus a 40-byte header per packet
  • 2.3 mW while sending, 3 µW asleep
  • No acknowledgments; sleeps between inferences
Source of the radio values · Ixana Wi-R Power Profiler, default view · 20 Oct 2026

Every radio current in our model appears in this calculator. We do not use its energy-per-bit, battery-life or ratio outputs, which follow its own default settings.

In the calculatorIn our model
1BLE: typical nRF52-class SoCThe external BLE radio for MCUs without one, such as the STM32U385. MCUs with built-in BLE use their own datasheet currents.
2BLE sleep current, 1.9 µARadio sleep current, 1.9 µA
3BLE peak current, 9000 µA at +8 dBmThe same transmit-current table. We transmit at 0 dBm, where it gives 4.6 mA.
4Wi-R data: YR23 datasheet v1.3Ixana YR23, normal mode (2.2 V I/O)
5Wi-R sleep current, 2.6 µADeep sleep, 3.08 µW (2.3 µA at the 1.1 V core + 0.25 µA at the 2.2 V I/O)
6Wi-R peak current, 1127 µATransmit, 2.32 mW (0.146 mA at 1.1 V + 0.981 mA at 2.2 V)
Average current, energy per bit, battery life, “15.0× lower current” and “65.3× lower energy”Not used. They follow the calculator's default settings: +8 dBm, 128-byte packets and one packet every 50 ms. At our settings, BLE costs 10.9 and Wi-R 0.73 nJ per sent bit (SleepFM on the STM32U385).
Default view of Ixana's public calculator [2], captured on 20 Oct 2026. The calculator models the current YR23 chip from its datasheet v1.3, and Ixana may revise it, so the screenshot records the version behind our numbers. We took the values on 6 Oct 2026 and checked them again on 21 Oct 2026, when the calculator still used the same constants. Ixana makes Wi-R, and S. Sen founded it. Select the screenshot to enlarge it; hover over or tap a row to outline its value.
All fixed values and their sources
What the numbers are
StatusModel estimatesBuilt from datasheets, Ixana's public power calculator and MLPerf Tiny results. Nothing is measured on hardware.
What is countedThe wearable onlyIts MCU and radio. The phone or hub, the sensors and the analog front end are not counted.
Energy boundaryChip supply pinsBattery energy = supply energy ÷ power conversion efficiency + regulator quiescent draw. Settings; the defaults, 100% and 0, give energy at the chip supply pins, as in the paper. About 85% is typical for a regulator.
AccuracyNot modelledModel weights are random; only sizes and MAC counts are used.
Workload
Number formats16-bit raw input; int8 modelSettings. Weights and every layer output sent use the model format.
MAC countsOne PyTorch forward pass per modelOnly multiply-accumulates are counted; softmax, normalisation and activations are not, so compute energy is a lower bound.
Memory checkWeights in flash; largest layer's input + output in SRAMRuntime buffers are not counted, so the check is optimistic.
Order of workCompute, then sendThe wearable finishes its layers before the radio starts.
AttX inputFull 10-s window per inferenceSuccessive windows overlap by 6 s; reusing the overlap at the phone is not modelled, which makes streaming no cheaper than it is.
LSM-Base and SensorLM-B inputMinute-level featuresBoth models read precomputed minute-level features, not raw sensor signals. Computing those features on the wearable is not counted.
SleepFM last splitNot usedThe final five-minute pooling discards the per-5-s token sequence that the downstream sleep heads need, so it is not a valid place to split.
Wearable MCU
Energy per MACMLPerf Tiny where measuredMeasured for 5 MCUs. Otherwise run current × supply voltage ÷ MACs per cycle, with 0.1 (Cortex-M0+), 0.6 (M4), 0.69 (M33), 1.5 (M55) MACs per cycle.
While a radio sendsAwake at 16 MHz for the whole transferSettings; per-packet and DMA options are available.
Between inferencesDatasheet sleep currentPer MCU preset, with RAM retained.
BLE
PHY, transmit power, supply2 Mbps, 0 dBm, 3 V2 Mbps and 3 V are the calculator's defaults. We use 0 dBm instead of its +8 dBm default, which draws 4.6 mA instead of 9 mA (Settings).
Connection interval30 msOur choice (Settings); the calculator defaults to 50 ms, and BLE allows 7.5 ms to 4 s.
Packet payload251 B, of which 244 B data251 B is the maximum with Data Length Extension; 4 B L2CAP + 3 B ATT notification headers.
On-air overhead11 B at 2 Mbps, 10 B at 1 MbpsPreamble, access address, header and CRC (Bluetooth Core Specification); no encryption bytes.
Packets per connection event6Our choice (Settings); the calculator sends one packet per interval. Up to 21 fit in 30 ms at 2 Mbps (1.37 Mbps) if the phone allows it.
Radio currents4.6 mA transmit (0 dBm) and receiveIxana's nRF52-class values for MCUs without a radio (e.g., STM32U385). MCUs with built-in BLE use their datasheet currents.
Event timing and processing130 µs ramp-up, 150 µs gaps, 100 µs post-processing at 3 mAIxana calculator; the 150 µs inter-frame space is from the Bluetooth Core Specification.
Radio sleep1.9 µAIxana calculator; not added for MCUs with built-in BLE, whose sleep current already covers it.
Between inferencesOne empty connection event every 30 ms (≈160 µW)BLE must stay connected (Settings). A longer interval costs less; reconnection cost is not modelled.
Lost packetsNone by defaultSettings; a lost packet is sent again, because BLE acknowledges every packet.
Wi-R
Module and modeIxana YR23, normal modeValues from Ixana's calculator [2], which cites the YR23 datasheet v1.3; see the screenshot above.
Rate and packet5 Mbps; 255 B payload + 40 B headerThe calculator's fastest rate and largest packet; its default view uses 128 B (Settings).
PowerTransmit 2.32 mW; idle 44.6 µW; deep sleep 3.08 µWComputed from the YR23 currents at the 1.1 V core and 2.2 V I/O supplies (e.g., 1.1 V × 0.146 mA + 2.2 V × 0.981 mA).
Wake-up2 ms from deep sleep, then 16 µsIxana calculator: 10 µs settling and a 6 µs timing term.
Wake-up energy12.3 nJModel estimate, 2 × sleep power × wake time; not measured (Settings).
Rate dependenceNoneTransmit power is assumed the same at every data rate.
Lost packetsNone by defaultSettings. With no acknowledgments, each packet is sent enough times to deliver the whole feature map with the target probability.
Between inferencesDeep sleepNo link-maintenance cost is assumed.
Full calculatorevery setting, every split and every layer, for checking the details

It runs the same model as the numbers above and opens on the SleepFM example. Change the MCU, the radios or the battery and see the energy of every split.

Settings

Data format

Bits per raw input value sets the size of the raw input (sensor samples, or per-minute features for LSM and SensorLM). The model number format sets the size of the weights, the working memory and every layer output that is sent. fp16 and fp32 also make compute slower and cost more energy than int8: ×2.2 on Cortex-M7, ×2.7 on M4/M33, ×20 on M0+ (no floating-point unit). int4 halves memory and data sent compared with int8, but Cortex-M cores have no 4-bit arithmetic, so compute runs at int8 speed and energy.

Wearable MCU STM32H7A3ZI

“(BLE)” = the chip has a built-in BLE radio. “CPU only” = the chip's neural-network accelerator is not used. MVP = SiLabs' matrix accelerator, which its measured result uses.

A MAC (multiply-accumulate, a × b + c) is the basic operation of a neural-network layer. MACs per clock cycle is how many the core completes per cycle on real neural-network code.

BLE wearable → phone

BLE sends data in short bursts called connection events, one per connection interval, each carrying a few packets. Six packets per event is a common phone setting; at 2 Mbps and 30 ms up to 21 fit (1.37 Mbps; Nordic reports 1.32 Mbps for a documented LE 2M setup), so state which one your phone supports. Lost packets are sent again, because BLE acknowledges every packet. Transmit-power levels follow Ixana's nRF52-class table (check that your chip supports the level). Higher power only adds energy here, because range is not modelled.

Wi-R Ixana YR23, wearable → on-body hub

Wi-R has no acknowledgements, so a lost packet cannot be sent again on request. Below 100% delivery every packet is sent k times, with k the fewest copies that deliver the whole feature map with the target probability (losses assumed independent). Each Wi-R packet also carries a 40-byte header. The blank wake-up energy uses the legacy model, 2 × sleep power × wake time, which is an assumption rather than a measurement. Transmit power is assumed not to change with data rate.

Idle time & battery

Every part of the wearable is counted over the whole time between inferences. The BLE link keeps its connection (one empty connection event every keep-alive interval) and Wi-R sleeps, including while the MCU computes. A longer keep-alive interval (or BLE peripheral latency) lowers that cost; disconnecting between inferences would add a reconnection cost that is not modelled. “Awake only to hand each packet over” charges a wake-up per packet plus the time to move the data over the MCU-to-radio link, and sleeps otherwise. With DMA, check that the chosen sleep mode keeps DMA and the link running; DMA and bus energy are not modelled. Energy at the battery = energy at the chip supplies ÷ conversion efficiency + regulator quiescent draw. Battery life counts the MCU and radio only, not the sensors or analog front end.

Each bar is one split, in the order the model runs. Bar height and the number on top show how much data the wearable sends if the model is split there (log scale; B = bytes, K = KB, M = MB). Layers up to the dashed SEND marker run on the wearable; the rest run on the phone. Click a bar to choose the split; the cards below update.

runs on the wearableruns on the phoneruns on the wearable but doesn't fit its memorySEND = the split, where the data leaves the wearable
Formulas used on this page· every number above comes from these lines
Bars = energy per inference (log scale):computeBLE sending + idleWi-R sending + idle

Model
MCU comparison

The current model and radio settings, run on each MCU preset. Energy per MAC is the MLPerf Tiny measurement where marked “measured”; otherwise run current × supply voltage ÷ MACs per cycle, from the datasheet. “Best split” is the lowest-energy split that fits the MCU's memory. Click a row to switch to that MCU.

How this is calculated
  • Model sizes. We ran each model once in PyTorch on one input and recorded, for every layer, its output size, its MAC count and its weight count (script: feature_map_tx_energy.py, PyTorch 2.10). The weights are random, which does not change any size or count; accuracy is not modelled.
  • Compute energy = MACs × energy per MAC. Energy per MAC is the chip's MLPerf Tiny measurement (an industry benchmark that measures whole-chip energy on small neural networks) where one exists; otherwise run current × supply voltage ÷ MACs per cycle, from the datasheet. Example: 10.5 M MACs × 478 pJ = 5.01 mJ on the STM32H7A3ZI. Floating point costs more than int8: ×2.2 on Cortex-M7 (MLPerf Tiny on the STM32H7A3 shows 1.9–3.9×), ×2.7 on M4/M33 (≈2.7× measured on a PSoC 6 M4), ×20 on M0+/M23 (no floating-point unit; rough estimate), and ×1.1 (fp16) or ×2.2 (fp32) on M55/M85. Only MACs are counted; softmax, normalisation and activation functions also take time, so compute is a lower bound. MLPerf Tiny uses small CNNs, so transformer models (LSM, SensorLM, SleepFM) may run less efficiently than this.
  • Overlapping windows. For AttX every option, the raw input included, sends data for the full 10-s window, although successive windows overlap by 6 s. Reusing the overlap at the phone is not modelled. This makes streaming no cheaper than it is: a phone that kept the previous 6 s would need only the new 4 s.
  • Fits the MCU? The weights of every layer up to the split must fit in Flash, and the working memory must fit in SRAM, both at the chosen number format. Working memory = the largest single layer's input + output. We assume element-wise layers overwrite their input, attention runs one head at a time, and SleepFM's tokenizer runs one 5-s window at a time. Skip-connection buffers and the input buffer are not counted, so this check is optimistic.
  • BLE, all-at-once mode. Data goes out in connection events, one every connection interval, each carrying up to the set number of packets, and never more than fit the interval. Each packet carries the max payload minus 7 B of L2CAP and ATT-notification headers: 251 − 7 = 244 B. In each exchange the radio receives the phone's empty packet, waits 150 µs and transmits its own packet; 150 µs separate exchanges, with no gap after the last one. Every packet carries 10 B on air besides its payload at 1 Mbps and 11 B at 2 Mbps (2-byte preamble), without encryption. Each event adds 130 µs of ramp-up and 100 µs of post-processing, and the radio sleeps for the rest of the interval. The last event carries only the packets and bytes that are left. The transfer ends when the last packet has been sent; the phone acknowledges it at the next connection event. Example: 4096 B ÷ 244 B = 17 packets; at 6 per event that is 3 events, and the last packet ends 66.7 ms after the first event starts. Transmit and receive currents come from the selected MCU's built-in radio, or from Ixana's nRF52-class values if it has none; transmit current scales with transmit power using Ixana's table.
  • Wi-R, all-at-once mode. The radio wakes from deep sleep once per transfer (2 ms), settles (16 µs), then sends packets back to back, each with up to 255 B of data plus a 40-B header, with no acknowledgements. Gaps, if set, come only between packets. Example: 4096 B in 17 packets = (4096 + 17 × 40) B × 8 ÷ 5 Mbps = 7.64 ms, plus 2.02 ms of wake-up and settling = 9.66 ms. Transmit power is assumed not to change with data rate. The default wake-up energy is the legacy model's 2 × sleep power × wake time (12.3 nJ for a deep-sleep wake), an assumption rather than a measurement; enter your own value in the Wi-R settings to test it.
  • Lost packets. BLE acknowledges every packet and sends lost ones again, so attempts = packets ÷ share delivered. Wi-R cannot resend on request, so each packet is sent k times, with k the fewest copies for which the whole feature map of M packets arrives with the target probability, [1 − (1 − p)k]M, where p is the single-attempt delivery. Losses are assumed independent; bursts of loss would be worse. 100% delivery is the ideal no-loss baseline.
  • Packet count = bytes ÷ data per packet, rounded up; the last packet carries only what is left.
  • Total energy per inference. Every part of the wearable is counted over the whole time between inferences, so its states add up to that time. MCU: computing, then each transfer (awake throughout, awake only to hand packets to the radio, or asleep while DMA does it, per the setting), asleep for the rest. BLE radio: the transfer's connection events, then one empty connection event every keep-alive interval for all other time, including while the MCU computes (a long-run average). Wi-R: the transfer, then sleep for all other time, including while the MCU computes. These are energies at the chip supplies. The battery feeds them through a regulator, so energy at the battery = supply energy ÷ conversion efficiency (100% by default, so no loss, as in the paper; about 85% is typical for a regulator) + the regulator's quiescent draw. A uniform efficiency changes every total by the same factor, so it does not change which split is best. Battery life = battery capacity × battery voltage ÷ average power at the battery. It counts the MCU and radio only, not the sensors or analog front end, so it is a compute-and-communication estimate, not a device lifetime.
  • Latency and feasibility. Latency = wearable compute time + waiting for the first BLE connection event (per the setting) + transfer time; the phone's part is not included. A split is feasible if its latency fits the time between inferences (4 s for AttX, 30 s for EnsembleSleepNet, 5 h for LSM, 5 min for SleepFM, 1 day for SensorLM), every connection event fits its interval, the MCU can feed the radio fast enough, and Wi-R meets its delivery target. Infeasible splits are flagged, get no battery life and are never picked as best.
  • Simplifications. Compute and sending happen one after the other. For an MCU with a built-in BLE radio, its datasheet transmit and receive currents are used and a separate radio's 1.9 µA sleep current is not added, since the chip's sleep current covers it; the 3-mA radio-processing current and the timing still come from Ixana's nRF52-class model and may overlap with the MCU's own run current. The memory check is a lower bound until runtime buffers are counted. EnsembleSleepNet's spectrogram (STFT) is costed at the neural-network energy per MAC, though an optimised FFT library (CMSIS-DSP) may be cheaper.
  • One-packet-per-interval mode (not shown in Settings; the mode control in the page's code) follows the scheduling of Ixana's online calculator: one packet per interval on both radios, with the same packet exchange as above and Wi-R energy counted over a full wake-send-sleep cycle by default. A Wi-R interval shorter than wake-up + settle + send time is flagged as impossible.
  • Sources. BLE and Wi-R timing, BLE processing and sleep currents, the 4.6 mA default, the transmit-power table and the Wi-R currents all come from Ixana's public power calculator (Ixana makes Wi-R; the calculator cites the YR23 datasheet v1.3). Wi-R carries no link-maintenance or synchronisation cost here, and its packets-delivered term is a best case without acknowledgements. Nothing has been checked against independent measurements yet. MCU figures come from each chip's datasheet (cited in the MCU settings card) and from MLPerf Tiny results.
  • Related work on splitting models between devices: Kang et al., "Neurosurgeon", ASPLOS 2017; Shao & Zhang, "BottleNet++", 2020; Matsubara et al., "Split computing and early exiting for deep learning applications: survey", ACM Computing Surveys 2022.

Code and data

Cite

@misc{roychowdhury2026compute,
  title  = {Compute or Communicate? A Break-Even Criterion for Splitting Wearable AI
            Between Microcontrollers and Body-Coupled Links},
  author = {Roy Chowdhury, Meghna and Datta, Gourav and Sen, Shreyas},
  year   = {2026},
  note   = {Manuscript under review}
}

References

  1. B. Chatterjee, P. Mohseni and S. Sen, “Bioelectronic Sensor Nodes for the Internet of Bodies,” Annual Review of Biomedical Engineering, vol. 25, 2023. doi:10.1146/annurev-bioeng-110220-112448
  2. Ixana, “Wi-R Power Profiler and Tools,” 2026; calculator based on the YR23 datasheet v1.3. https://ixana.ai/resources/tools. Accessed 6 Oct 2026; rechecked 21 Oct 2026. Screenshot of the default view, 20 Oct 2026.

Radio parameters follow Ixana's public power calculator (YR23 datasheet v1.3; [2], accessed 6 Oct 2026) and the Bluetooth Core Specification. MCU parameters follow each chip's datasheet and MLPerf Tiny results.