Energy harvesting and power constraints

"I do not have a battery. I have a capacitor the size of a lentil and a promise from the sun. Ask me again in the shade and I will have forgotten the question."

A Solar-Powered AI Agent

Harvesting sources: microwatts to milliwatts, and never on demand

Energy harvesting converts ambient energy into electrical power using a transducer, the same class of device that turns a physical quantity into a signal in Chapter 2, run as a generator instead of a sensor. Four sources dominate deployed batteryless sensing, and their yields span four orders of magnitude. Photovoltaic cells are the workhorse: outdoors in full sun a small cell delivers on the order of \(10\ \mathrm{mW/cm^2}\), but indoors under office lighting that collapses to \(10\) to \(100\ \mathrm{\mu W/cm^2}\), a factor of a hundred or more. Thermoelectric generators exploit a temperature difference across the device (the Seebeck effect) and yield roughly \(20\) to \(100\ \mathrm{\mu W/cm^2}\) for a modest few-degree gradient, such as the skin-to-air difference on a wearable. Piezoelectric and kinetic harvesters turn vibration or motion into charge and produce anywhere from a few microwatts to a milliwatt depending on the source's frequency and amplitude. RF harvesting rectifies ambient or dedicated radio energy and is the weakest, typically \(0.1\) to a few \(\mathrm{\mu W/cm^2}\) at usable distances, which is why RFID-scale systems put the transmitter close by.

Two properties matter more than the raw numbers. First, the yield is small: a node that harvests \(50\ \mathrm{\mu W}\) on average has, over a full second, only \(50\ \mathrm{\mu J}\) to spend, and a single neural inference plus a sensor read can cost more than that. Second, and decisively, the supply is uncontrollable. You cannot ask the sun to shine or the motor to vibrate when your scheduler is ready; the source turns on and off on its own timetable. This is the property that makes batteryless computing a distinct discipline rather than merely aggressive low-power design, and it is why the sources here connect directly to the environmental and energy-sensing systems of Chapter 39, where the same ambient conditions are the phenomenon of interest.

Storage is a capacitor, and it holds less than you think

Batteryless nodes buffer energy in a capacitor (increasingly a supercapacitor) rather than a rechargeable battery, and the choice is deliberate. Capacitors charge and discharge in milliseconds, tolerate effectively unlimited cycles, survive cold and heat, and do not wear out over a decade in the field, all properties a lithium cell lacks. The price is that they store very little energy and their voltage sags continuously as they discharge. The energy held in a capacitor of capacitance \(C\) charged to voltage \(V\) is

The quadratic in \(V\) is the whole story. A processor does not run from zero volts: it needs a minimum operating voltage \(V_{\min}\) to stay out of brownout, and the capacitor is charged to some ceiling \(V_{\max}\). The energy you can actually spend is only the slice between those two levels,

which is always less, often far less, than \(\tfrac12 C V_{\max}^2\). Consider a \(100\ \mathrm{\mu F}\) capacitor charged to \(3.3\ \mathrm{V}\) with a brownout floor of \(2.4\ \mathrm{V}\). The total stored energy is about \(545\ \mathrm{\mu J}\), but the usable slice is only \(\tfrac12(100\times10^{-6})(3.3^2 - 2.4^2)\approx 256\ \mathrm{\mu J}\). Nearly half the charge is stranded below the floor. That \(256\ \mathrm{\mu J}\) is your entire working budget between refills, and if one inference costs \(200\ \mathrm{\mu J}\) you get essentially one shot before the node must recharge. This is the hard wall that the intermittent-computing techniques of Section 63.2 exist to work around.

The power constraint: intermittency, brownout, and forward progress

Put the source and the store together and you get the defining operating model of this chapter: harvest, store, use, repeated forever, with the "use" phase gated on having banked enough charge. Because the harvested power \(P_{\text{harvest}}\) is usually far below the active power \(P_{\text{active}}\) an inference draws, the node cannot run continuously. It charges its capacitor slowly, computes in a short burst that drains the capacitor faster than the harvester refills it, browns out when the voltage crosses \(V_{\min}\), and then charges again. The result is an intermittent execution: bursts of activity separated by dead time whose length is set entirely by the weather of the source. The average duty cycle is roughly the ratio of harvested to active power, \(P_{\text{harvest}} / P_{\text{active}}\), which for a \(50\ \mathrm{\mu W}\) harvester feeding a \(5\ \mathrm{mW}\) processor is about one percent: the node is awake one moment in a hundred.

This reframes the central design goal. On a battery node the goal is to minimize average power; on a batteryless node the goal is to guarantee forward progress despite an unpredictable supply, so that useful work accumulates across power failures rather than restarting from scratch each time the lights come back. The energy trace itself becomes an input the system must reason about, much as a signal is reasoned about in Chapter 3. The simulation below makes the harvest-store-use loop concrete: it drives a capacitor with a fluctuating harvest trace, fires an inference whenever enough energy has banked, and counts how often the node actually gets to think.

import numpy as np

C          = 100e-6     # 100 uF storage capacitor
V_MAX      = 3.3        # charge ceiling (V)
V_MIN      = 2.4        # brownout floor (V)
E_INFER    = 220e-6     # energy for one inference + sensor read (J)
DT         = 1e-3       # 1 ms simulation step

def usable(v):                       # energy above the brownout floor
    return 0.5 * C * max(v*v - V_MIN**2, 0.0)

# A flickering indoor-light harvester: mean ~60 uW, occasional shade dips.
rng     = np.random.default_rng(0)
p_harv  = np.clip(60e-6 + 30e-6*rng.standard_normal(20_000), 0, None)

v, inferences, brownouts = V_MAX, 0, 0
for p in p_harv:
    e = usable(v) + p * DT                       # bank incoming energy
    if e >= E_INFER and v >= V_MIN:              # enough to think, and awake
        e -= E_INFER; inferences += 1
    v = np.sqrt(2*e/C + V_MIN**2)                # convert energy back to volts
    if v > V_MAX: v = V_MAX                       # clamp at the ceiling
    if v <= V_MIN: brownouts += 1                 # drooped to the floor

print(f"inferences fired : {inferences}")
print(f"brownout steps   : {brownouts}")
print(f"duty cycle        : {inferences*E_INFER / (p_harv.sum()*DT):.1%} of harvest used")

Listing 63.1.1 shows the two levers that decide whether a batteryless node is viable at all: the usable energy slice of the capacitor (set by \(C\), \(V_{\max}\), and \(V_{\min}\)) and the energy cost of one atomic inference. When the cost exceeds the slice, no amount of patience helps within a single charge cycle, which is precisely why the rest of the chapter turns to splitting work and adapting the model.

// C, on-device: the harvester PMIC gates compute for you.
void on_power_good_irq(void) {   // fires when the cap reaches V_MAX
    read_sensor_window();
    run_inference();             // spend the banked energy in one burst
    enter_deep_sleep();          // let the PMIC recharge; MPPT runs in HW
}

What's Next

In Section 63.2, we confront the consequence that this section set up: when the usable energy slice cannot cover a whole computation, the node browns out mid-task and, on an ordinary microcontroller, loses everything in volatile memory. Intermittent computing and checkpointing is the discipline of saving just enough state to non-volatile memory that work resumes across a power failure instead of restarting, turning a string of disconnected energy bursts into steady forward progress.