1Elmore Family School of Electrical and Computer Engineering, Purdue University
2Department of Electrical, Computer, and Systems Engineering, Case Western Reserve University
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).
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.
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.
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.
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.
| Term | Meaning | Set by |
|---|---|---|
| eMAC | MCU energy per multiply-accumulate | MCU |
| ρk | Bits removed per MAC spent, up to split k | Network |
| ēbit | Full 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 R | Link and MCU |
| Psl / Θ | MCU sleep energy that each MAC displaces (about 0.1 pJ): sleep power Psl divided by MAC throughput Θ, in MACs per second | MCU |
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).
| BLE | Wi-R | |
|---|---|---|
| ēbit (nJ/bit) | 10.9 | 0.73 |
| Break-even ecrit = ēbit × ρ + 0.1 (pJ/MAC) | 123.3 | 8.35 |
| STM32U385 eMAC (pJ/MAC) | 81 | 81 |
| Energy, stream the raw input (mJ per 5 min) | 204.4 | 13.4 |
| Energy, send the tokens (mJ per 5 min) | 156.7 | 95.3 |
| Lower-energy option | Send 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).
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.
ē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.
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.
| Network | Task | Best cut | MACs per bit removed | Crossover on STM32U385 (nJ/bit) | Compute wins on BLE | Compute wins on Wi‑R |
|---|---|---|---|---|---|---|
| SleepFM encoder | Sleep foundation model on 23 polysomnography channels (EEG, ECG, respiration and others), 5-min windows | 5-s tokens (one per channel per 5 s) | 89 | 7.17 | 8 | 0 |
| EnsembleSleepNet | Sleep staging from 9 channels with 3 sub-models, 30-s epochs | Per-channel CNN outputs (27 branches) † | 138 | 11.1 | 3 | 0 |
| AttX (VGG) | 3-class classification from ECG and electrodermal activity, 4-s hops | Final class scores (3 classes) † | 3,300 | 266 | 0 | 0 |
| AttX (ResNet) | Same task with a ResNet backbone, 4-s hops | Final class scores (3 classes) † | 3,500 | 280 | 0 | 0 |
| LSM-Base | Wearable-sensor foundation model, 5-h windows | Final embedding (average over all tokens) † | 133,900 | 10,834 | 0 | 0 |
| SensorLM-B sensor tower | Sensor encoder of a sensor–language model, 1-day windows | Final sensor embedding (average + projection) † | 466,600 | 37,740 | 0 | 0 |
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.
We test each main result against parameter error and against the modeling choices most likely to change it.
| Result | Condition under which it changes |
|---|---|
| Over Wi-R, raw streaming outperforms on-wearable computation in all 114 pairs | The 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 option | This 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 first | The 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 pairs | The 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.
| Favors raw streaming over Wi-R | Favors on-wearable computation |
|---|---|
| BLE maintains its connection between inferences (30-ms default), whereas Wi-R sleeps between inferences with no link-maintenance cost | Only MACs are counted, so compute energy is a lower bound |
| Packet delivery defaults to 100%, although Wi-R has no acknowledgments | The 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 it | The 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 estimate | The 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 |
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.
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 calculator | In our model | |
|---|---|---|
| 1 | BLE: typical nRF52-class SoC | The external BLE radio for MCUs without one, such as the STM32U385. MCUs with built-in BLE use their own datasheet currents. |
| 2 | BLE sleep current, 1.9 µA | Radio sleep current, 1.9 µA |
| 3 | BLE peak current, 9000 µA at +8 dBm | The same transmit-current table. We transmit at 0 dBm, where it gives 4.6 mA. |
| 4 | Wi-R data: YR23 datasheet v1.3 | Ixana YR23, normal mode (2.2 V I/O) |
| 5 | Wi-R sleep current, 2.6 µA | Deep sleep, 3.08 µW (2.3 µA at the 1.1 V core + 0.25 µA at the 2.2 V I/O) |
| 6 | Wi-R peak current, 1127 µA | Transmit, 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). |
| What the numbers are | ||
| Status | Model estimates | Built from datasheets, Ixana's public power calculator and MLPerf Tiny results. Nothing is measured on hardware. |
| What is counted | The wearable only | Its MCU and radio. The phone or hub, the sensors and the analog front end are not counted. |
| Energy boundary | Chip supply pins | Battery 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. |
| Accuracy | Not modelled | Model weights are random; only sizes and MAC counts are used. |
| Workload | ||
| Number formats | 16-bit raw input; int8 model | Settings. Weights and every layer output sent use the model format. |
| MAC counts | One PyTorch forward pass per model | Only multiply-accumulates are counted; softmax, normalisation and activations are not, so compute energy is a lower bound. |
| Memory check | Weights in flash; largest layer's input + output in SRAM | Runtime buffers are not counted, so the check is optimistic. |
| Order of work | Compute, then send | The wearable finishes its layers before the radio starts. |
| AttX input | Full 10-s window per inference | Successive 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 input | Minute-level features | Both models read precomputed minute-level features, not raw sensor signals. Computing those features on the wearable is not counted. |
| SleepFM last split | Not used | The 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 MAC | MLPerf Tiny where measured | Measured 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 sends | Awake at 16 MHz for the whole transfer | Settings; per-packet and DMA options are available. |
| Between inferences | Datasheet sleep current | Per MCU preset, with RAM retained. |
| BLE | ||
| PHY, transmit power, supply | 2 Mbps, 0 dBm, 3 V | 2 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 interval | 30 ms | Our choice (Settings); the calculator defaults to 50 ms, and BLE allows 7.5 ms to 4 s. |
| Packet payload | 251 B, of which 244 B data | 251 B is the maximum with Data Length Extension; 4 B L2CAP + 3 B ATT notification headers. |
| On-air overhead | 11 B at 2 Mbps, 10 B at 1 Mbps | Preamble, access address, header and CRC (Bluetooth Core Specification); no encryption bytes. |
| Packets per connection event | 6 | Our 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 currents | 4.6 mA transmit (0 dBm) and receive | Ixana's nRF52-class values for MCUs without a radio (e.g., STM32U385). MCUs with built-in BLE use their datasheet currents. |
| Event timing and processing | 130 µs ramp-up, 150 µs gaps, 100 µs post-processing at 3 mA | Ixana calculator; the 150 µs inter-frame space is from the Bluetooth Core Specification. |
| Radio sleep | 1.9 µA | Ixana calculator; not added for MCUs with built-in BLE, whose sleep current already covers it. |
| Between inferences | One empty connection event every 30 ms (≈160 µW) | BLE must stay connected (Settings). A longer interval costs less; reconnection cost is not modelled. |
| Lost packets | None by default | Settings; a lost packet is sent again, because BLE acknowledges every packet. |
| Wi-R | ||
| Module and mode | Ixana YR23, normal mode | Values from Ixana's calculator [2], which cites the YR23 datasheet v1.3; see the screenshot above. |
| Rate and packet | 5 Mbps; 255 B payload + 40 B header | The calculator's fastest rate and largest packet; its default view uses 128 B (Settings). |
| Power | Transmit 2.32 mW; idle 44.6 µW; deep sleep 3.08 µW | Computed 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-up | 2 ms from deep sleep, then 16 µs | Ixana calculator: 10 µs settling and a 6 µs timing term. |
| Wake-up energy | 12.3 nJ | Model estimate, 2 × sleep power × wake time; not measured (Settings). |
| Rate dependence | None | Transmit power is assumed the same at every data rate. |
| Lost packets | None by default | Settings. With no acknowledgments, each packet is sent enough times to deliver the whole feature map with the target probability. |
| Between inferences | Deep sleep | No link-maintenance cost is assumed. |
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.
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.
“(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 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 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.
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.
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.
node analysis/reproduce.js and python3 analysis/robustness.py@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}
}
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.
Screenshot taken 20 Oct 2026 from ixana.ai/resources/tools.