Successful wireless communication requires that sender and receiver are operational at the same time. This requirement is difficult to satisfy in battery-free networks, where the energy harvested from ambient sources varies across time and space and is often too weak to continuously power the devices.
Bonito is the first connection protocol for battery-free systems that enables reliable and efficient bi-directional communication between intermittently powered nodes. It learns a model of a node's charging time distribution online and adapts the nodes' wake-up times so that sender and receiver are operational at the same time, enabling successful communication.

We provide energy harvesting traces from a variety of scenarios and a Python implementation of Bonito as open source. If you want to learn more, read our detailed description.


Why go battery-free?

As the Internet of Things (IoT) grows to trillions of devices, sustainability and reliability of this computing infrastructure become matters of utmost importance. One possible path to sustainability is the adoption of battery-free devices that buffer energy harvested from the environment in a capacitor. Battery-free devices promise to overcome the drawbacks of (rechargeable) batteries, such as bulkiness, wear-out, toxicity, uncertain remaining charge, etc. Leaving batteries behind allows for building cheap, tiny, and maintenance-free devices that can be embedded into smart textiles, intelligent surfaces, or even the human body.

What is intermittency?

The power that can be harvested from ambient energy sources can vary significantly across time and space, and is often too weak to directly power a battery-free node. Thus, as illustrated in the figure below, a battery-free device first needs to buffer sufficient energy in its capacitor before it can operate for a short period of time; then the device turns off until the capacitor is sufficiently charged again. As a result, battery-free devices operate intermittently.

Battery-free Communication

Just like in conventional battery-supported networks, direct communication between battery-free devices is desirable, for example, to increase the availability of the system, to enable novel applications, and to reduce infrastructure costs. However, to communicate with one another, sender and receiver must be active simultaneously for at least the airtime of one complete packet. This is difficult in battery-free networks for three reasons:

  • Battery-free nodes can only become active when they have accumulated sufficient energy in their capacitors.
  • They may only be active for a short period.
  • Their duty cycles are often low and vary randomly.
The resulting key challenge is that the short activity phases of different nodes are generally interleaved. Therefore, it can take a very long time until nodes encounter each other. Moreover, after an encounter, the nodes quickly get out of sync, as illustrated in the figure below. This is because ambient energy varies across time and space, which leads to fluctuating and different charging times between the nodes.

What is Bonito?

Bonito is the first connection protocol for battery-free wireless devices. It provides reliable and efficient bi-directional communication despite the time-varying intermittency of battery-free devices. Unlike the state of the art, Bonito enables two battery-free nodes, after an initial encounter, to maintain a connection across multiple consecutive encounters. To this end, Bonito continually adapts the connection interval, which is the time between the end of an encounter and the beginning of the next encounter. Instead of waking up right after reaching the turn-on threshold, nodes delay their wake-up until the connection interval has passed.

A shorter connection interval provides more communication opportunities in the long run. However, a connection interval that is shorter than any of the nodes' charging times breaks the connection and requires the nodes to wait for a long time until they encounter each other again. Thus, the challenge is to keep the connection interval as short as possible without losing the connection, which is difficult in the face of time-varying charging times.

With Bonito, each node continuously learns and tracks the parameters of a model that approximates the distribution of locally observed charging times against non-stationary effects (e.g., changes in mean or variance). Then, to maintain an efficient and reliable connection, the nodes exchange at every encounter their current model parameters and jointly adapt the connection interval.

Open Source

We provide real-world energy-harvesting traces from five diverse scenarios involving solar panels and piezoelectric harvesters on Zenodo and a Python implementation of the Bonito protocol under an MIT license in our GitHub repository.

Energy harvesting traces

We collect 32h of time-synchronized energy-harvesting traces from 5 different scenarios involving solar panels and piezoelectric harvesters.
  • The jogging dataset comprises traces from two participants, each equipped with two piezoelectric harvester at the ankles and a solar panel at the left wrist. The two participants run together for an hour in a public park, including short walking and standing breaks.
  • For the stairs dataset, we recorded traces from six solar panels that are embedded into the surface of an outdoor stair in front of a lecture hall. Over the course of one hour, numerous students pass the stairs, leading to temporary shadowing effects on some or all of the solar panels.
  • The office dataset comprises traces from five solar panels mounted on the doorframe and walls of an office with fluorescent lights. During the one-hour recording, people enter and leave the office and operate the lights.
  • The cars dataset contains traces from two cars. Each car is equipped with three piezoelectric harvesters mounted on the windshield, the dashboard, and in the trunk. The cars drive for two hours in convoy over a variety of roads.
  • The washer dataset includes five traces from piezoelectric harvesters mounted on a WPB4700H industrial washing machine, while the machine runs a washing program with maximum load for 45 minutes.

The data is provided as one hdf5 file per dataset containing time-synchronized power traces with a sampling rate of 100kSps.

Bonito Python implementation

We provide a Python implementation of the Bonito protocol and two baseline approaches. The provided code allows converting harvesting power traces of two nodes to sequences of charging times of the two nodes. The resulting charging time traces can be analyzed and used to learn the parameters of a charging time distribution with stochastic gradient descent. The learned parameters at every step can be used to compute a connection interval. If the resulting connection interval is greater than the charging times of both devices, the encounter is considered successful.


pip install neslab.bonito[examples]


Plot the first 10 minutes of harvesting power trace of two nodes:

import h5py
import matplotlib.pyplot as plt

with h5py.File("pwr_stairs.h5", "r") as hf:
	ptimes = hf["time"][:60_000_000]
	pwr1 = hf["data"]["node0"][:60_000_000]
	pwr2 = hf["data"]["node4"][:60_000_000]

plt.plot(ptimes, pwr1)
plt.plot(ptimes, pwr2)
Convert the power traces of two nodes to sequences of charging times and plot the results (this can take a long time):
from neslab.bonito import pwr2time

ctimes, tchrg1, tchrg2 = pwr2time(ptimes, pwr1, pwr2)

plt.plot(ctimes, tchrg1)
plt.plot(ctimes, tchrg2)
Learn the parameters of a normal distribution from one of the charging time traces using stochastic gradient descent and plot the results.
import numpy as np
from neslab.bonito import NormalDistribution as NrmDst

means = np.empty((len(ctimes),))

dist_model = NrmDst()
for i, c in enumerate(tchrg1):
	means[i] = dist_model._mp[0]

plt.plot(ctimes, tchrg1)
plt.plot(ctimes, means)
Run the Bonito protocol on the two charging time traces and plot the resulting connection:
from neslab.bonito import bonito

cis = np.empty((len(ctimes),))
for i, (ci, success) in enumerate(bonito((tchrg1, tchrg2), (NrmDst, NrmDst))):
	if success:
		cis[i] = ci
		cis[i] = np.nan

plt.plot(ctimes, tchrg1)
plt.plot(ctimes, tchrg2)
plt.plot(ctimes, cis)


Learning to Communicate Effectively Between Battery-free Devices
K. Geissdoerfer and M. Zimmerling
USENIX Symposium on Networked Systems Design and Implementation (NSDI), Renton, USA, April 2022
[ pdf ]