Adapting Task Utility in Externally TriggeredEnergy Harvesting Wireless Sensing Systems

Jamie Bradley SteckDepartment of Computer Science and Engineering

University of California, San Diegojlbradle@ucsd.edu

Tajana Simunic RosingDepartment of Computer Science and Engineering

University of California, San Diegotajana@ucsd.edu

Abstract—Energy harvesting sensor nodes eliminate the needfor post-deployment physical human interaction by using en-vironmental power and wireless communication; however, theymust adapt the utility of their tasks to accommodate the energyavailability. For example, on sunny days, a solar-powered sensornode can perform highly accurate tasks requiring more extensivecomputation and communication, but on cloudy days, it mustreduce utility due to a decrease in harvested energy. In this paper,we present a controller that uses two algorithms to balance taskutility and execution time subject to an energy constraint. Onealgorithm determines the total execution time of a set of taskssuch that desired task utilities are met, while the other solves theconverse problem by approximating the maximum task utilitiesachievable within a global deadline. We apply our methods to aprototype Structural Health Monitoring system, demonstratingthe controller’s ability to adapt at runtime.

Index Terms—sensor system, structural health monitoring,utility, energy harvesting

I. INTRODUCTION

The scope of use for wireless sensor networks (WSNs)is continuously expanding, from environmental and structuralmonitoring to robotics. One of the most attractive featuresof these types of networks is their ability to operate withouthuman intervention, enabling them to be placed in obscure,inaccessible areas resulting in the lack of a constant supply ofpower. In the past, this lack of power has been compensatedfor through the use of batteries, but even batteries periodicallyrequire human interaction.

A promising area of research and a solution to this problemis the use of energy harvesting, such as gathering power fromlight or vibrations [9]. Because an energy harvesting systemobtains power from an external source, it can operate withouthuman intervention for long periods of time. A significantchallenge in this type of system is the management andconservation of energy. The system must maintain energyneutrality, meaning that it can only consume as much energyas it can harvest. Typically, the goal of a sensor system is tocomplete a sequence of tasks within a designated period oftime; however, to maintain energy neutrality, the system mayhave to reduce the utility of tasks or wait to complete all tasksuntil additional energy can be obtained. Therefore, when givena sequence of tasks, the system must find a way to completethe tasks while respecting the system’s unique constraints.

In this paper, we propose a method for adapting taskutility and execution time in an externally triggered, energy-harvesting system. Our method provides a controller that given

a request from an external device can determine the achievableutility, execution time, and energy consumption of a sequenceof tasks. These methods not only provide valuable informationto the external device but also guarantee that the systemmaintains energy neutrality.

The concept of energy neutrality is discussed in detail in [3]and [4]. To guarantee energy neutral operation, Kansal et al.[4] present a harvesting theory that characterizes an energysource and energy consumer and determines the necessarystorage capacity needed to ensure a desired performance level.Furthermore, in [3], Kansal et al. prove that a system canachieve energy neutrality using these characterizations and amethod of duty cycling. They present an algorithm that altersthe node’s duty cycle using an estimation of future harvestedenergy. While both [3] and [4] adapt the duty cycle to accountfor changes in harvested energy, for many applications, dutycycling alone is not sufficient. Systems containing a variety ofinterdependent tasks require a more detailed task model.

Moser et al. [7] present the Lazy Scheduling Algorithm(LSA) for an energy-driven scenario. The LSA schedules taskswhen either 1) the energy storage buffer is full, and thus,unused energy will be wasted, or 2) a task will miss itsdeadline if not scheduled. While the LSA works well forindependent tasks with deadlines, it does acknowledge depen-dencies between tasks. In many systems, tasks must occur in adesignated order; for example, data cannot be processed until ithas been collected. Moser et al. do consider task dependenciesin [6] by presenting an energy-harvesting system design usedto maximize node utility by adjusting task execution rates.An estimator predicts the amount of energy harvested in thefuture, while a controller adapts the system parameters tomaximize node utility using critical regions defined offlinewith multi-parametric linear programming. While optimal, [6]demonstrates their solution using only two tasks and restricttask variation to altering only the execution rate, not providinga method for application-specific accuracy measurements.

Rusu et al. [11] present the only work to our knowledgethat considers the accuracy level when scheduling tasks. Eachtask has multiple versions, each of which has an associatedreward. The goal of the system is to maximize the system valuewhile meeting the global deadline and respecting the energyconstraint. The authors present a heuristic that schedules tasksbased on reward until a constraint is violated. The heuristic,however, only uses a small number of versions per task and

Fig. 1. System Model

assumes that a minimum amount of energy is available at thebeginning of each discharge period.

Our contribution in this paper is an adaptive task manage-ment scheme that has several key features. First, an externaldevice can obtain immediate estimates of the total utility, time,and energy characteristics of a set of tasks. Second, any ap-plication can use the methods described with the specificationof a task graph and task execution and utility characteristics.Third, task utility can be adapted online at detailed levels moreprecise than duty cycles or execution rates. Finally, our methodensures that, if possible, all tasks in the task graph will bescheduled, and a task’s utility will be determined by its relativeimportance to the system.

The remainder of this paper is structured as follows. SectionII describes the system model, and section III defines theproblem and presents two algorithms. Section IV providesresults for a relevant application. Finally, section V concludesthe paper.

II. SYSTEM DESCRIPTION

The purpose of the system is to execute a set of tasks whilemaintaining energy neutrality. The system model, shown inFigure 1, illustrates the components that comprise the sensornode. The system is powered by an energy-harvesting device,denoted as the energy source, and the energy is stored inthe energy buffer (such as a rechargeable battery or a supercapacitor.) The predictor, further described in section II-C,uses past energy harvesting information to estimate the futurerate of energy harvesting. The controller uses this predictedinformation, along with the current amount of energy in thebuffer, and the external request to determine the utility andexecution time of a sequence of tasks.

The system can operate in one of two modes: steady state orexternal trigger state. Steady state operation is typical of sensornodes; data is gathered, processed, and transmitted accordingto a predefined schedule over a long period of time. The goalof steady state operation is to periodically execute a set oftasks while maintaining a desired level of energy and eithersend this data to a base station or store the results for a latertime. In contrast, when external trigger state operation occurs,an external device is present and issues a request to the systemthat imposes a constraint. The goal of the system in this stateis to meet the constraint and inform the external device of

the expected performance of the request. The external devicecan be any device that communicates with the system, suchas a base station, a mobile agent, or another sensor node. Thework in this paper focuses on external trigger state operation;steady state operation. however, is briefly addressed in sectionIV and described in greater detail in [12].

A. Task Model

The relationship among the tasks in a system is modeledas a Directed Acyclic Graph (DAG). In the DAG G = (T,E),each vertex represents a task τ ∈ T, which is an action orcombination of actions that the system performs. Each edgeeij ∈ E represents a dependency between tasks such that τjcannot begin execution until τi is complete. It is assumedthat the Worst Case Execution Time (WCET) for each taskis known ahead of time. Figure 5 illustrates an example taskDAG. Tasks τact/acq are entry tasks, as they have no incomingedges. Upon execution of all predecessors, the exit task, taskτtransmit, can begin execution.

In the system, each task τ is defined by its relationshipwith the other tasks in the system, its priority, and its appli-cation specific execution characteristics, each of which willbe described in further detail in this section. A task τi canbe represented as a seven-tuple {pτi

, Uτi , tτi , Pτi , sτi , fτi , dτi}where pτi

is the priority, Uτi is the utility, tτi is the WCET,Pτi is the power, sτi is the start time, fτi is the finishing time,and dτi is the amount of data produced.

Upon the completion of any task τi, an amount of data,dτi , is produced. The produced data is a function of theutility, Uτ , although the exact relationship is defined by theapplication. This data is then passed on to successors inthe DAG. For example, as shown in figure 5, task τact/avgsends data dτact/acq

to its successor, task τaveraging, uponcompletion.

In this model, each task τ is executed with a level of utility,Uτ , such that 0 ≤ Uτ ≤ 1. In this work, the terms utility andaccuracy will be used interchangeably, as in most applications,they have similar implications. A utility of 1 represents thehighest level of utility a task can perform, while a utility of 0.1indicates little to no accuracy, and a utility of 0 indicates thatthe task should not be executed at all. The relative importanceor priority of each task τ in the system is denoted by the task’spriority, pτ . The priority is used to determine the utility of eachinstance of a task in relation to other tasks in the system suchthat equation 1 holds. The task with the highest priority willbe executed with the highest utility and so forth.

Uτi =pτi

Ntasks∑j=1

pτj

∗Ntasks∑j=1

Uτj (1)

For example, consider a system designed to provide a videointerface for a teleconference; the two tasks in this systemmight be: task τ1, display local video, and τ2, display remotevideo. In this system, it is desirable to display the remotevideo at a higher resolution than the local video, as it is of

more importance to see the other person than oneself. Thus,the priority for τ1, display local video, should be smaller thanthat of τ2, display remote video. If pτ1 = 1 and pτ2 = 2, theutility of task τ2 should be twice that of task τ1. Because therelative importance of each task may change depending onthe system’s current conditions, the task’s priority is expectedto change in a system over time. The priorities of tasks areassumed to only change before or after an iteration of the taskgraph.

The relationship between the utility of a task and its specificexecution characteristics must be defined by the applicationdesigner. The expected execution times for each level ofutility for each task can either be experimentally measuredor calculated using a functional relationship such that tτequals the expected WCET of τ . For the general solution, thisapplication specific relationship is referred to as f(Uτ ), shownin equation 2. The energy consumption eτ of a task τ can thenbe determined using the execution time tτ and the task powerPτ . To simplify the model, the power Pτ is assumed to beconstant for all utility values of a task; however, this may notbe the case for all applications, in which case the power canbe determined in the same manner as the execution time usingan application specific function.

tτ = f (Uτ ) (2)

eτ = tτ ∗ Pτ (3)

As the utility Uτ of a task increases, the energy and time oftask τ is expected to increase; however, the actual implementa-tion of the above function depends entirely on the application.One possibility for the relationship between the utility andtime of a task is a function. Another possible relationshipcould be the use of a lookup table representing only severaldiscrete utility values. For instance, video resolution may onlyhave two levels of utility: low (U = .5) or high (U = 1). Thissystem design requires that applications can identify differentlevels of utility for a task that can be easily interchanged. Thismodel of utility is general enough to work with very simplechoices of utilities as well as more complex utilities, such asthose described in section IV for SHiMmer, a Structural HealthMonitoring system.

B. Energy Model

The energy model for this work has two parts: the energyharvesting source and the energy storage buffer. Decisionsmade by the controller must adhere to the energy storageconstraints and can exploit the knowledge of the energy sourceto improve performance.

The energy harvested from the energy source at time t,Eharvestt , is defined as the amount of energy harvested betweentime t-1 and time t such that the time between time t-1 andtime t is the period T. The total energy harvested at time t isa result of the energy at the source, Esourcet , the efficiency ofconversion, ηconversion, and the energy lost due to leakage in theperiod T, Eleakage. The instantaneous rate of energy harvesting,

RateEH = dEdT , is then defined as the energy harvested at time

t divided by the time period T.

Eharvestt = ηconversion ∗ Esourcet − Eleakaget(4)

Energy thresholds are set based on the needs of the ap-plication and the characteristics of the buffer and source. Theenergy storage buffer has capacity, Ecapacity, and a maximum al-lowed amount, Emax, that may or may not be equal to Ecapacity.For example, Recas et al. [10] show that the recharge rate of asupercapacitor is significantly lower when the buffer is nearlyfull and thus, it is more beneficial to use the extra energy toexecute tasks than to completely fill the supercapacitor. Duringsteady state operation, Ebuffer ≥ Esteady, and during an externalrequest, Ebuffer ≥ Emin. The available energy at any time t isdenoted as Eavailable. The energy in the buffer at time t, Ebuffert ,is the sum of the buffer energy at time t-1, Ebuffert-1 and theenergy harvested at time t, Eharvestt less the energy consumed,Econsumedt-1 .

Ebuffert = Ebuffert-1 + Eharvestt − Econsumedt-1 (5)

C. Prediction Model

At any point in time, there may not be enough energyavailable to execute all the desired tasks immediately. Thecontroller can thus estimate the additional time needed to har-vest energy, twait, shown in equation 6, using the expected rateof energy harvesting, as provided by the predictor, describedin detail below. Erequired is the sum of the energy required foreach task in the system at the desired utility level.

twait =Erequiredt

− Eavailablet

E[RateEHt+1 ](6)

Erequiredt=

Ntasks∑j=1

eτj (7)

To estimate the amount of time needed to harvest theadditional energy, the system must predict how much energycan be harvested in the future. For this, a method based onwork by Recas et al. is used [10]. The predictor uses pastenergy harvesting information from previous days to estimatethe rate of energy harvesting in the next period, E[RateEHt+1 ].The predictor stores data gathered from past days in a matrixof size DxN, where D is the number of past stored days, andN is the number of energy values stored per day. At any timet, the predictor provides a predicted rate of energy harvestingfor time t+1 that indicates the number of expected joules persecond that will be harvested in the next time period. Themethod of prediction uses an Exponentially Weighted Moving-Average combined with a GAP factor to account for variationsspecific to solar energy harvesting. The results from [10] showthat this predictor can predict future energy within a 30 minutetime frame with 10% accuracy.

TABLE IVARIABLES USED IN THE ILPS

pτi: priority for task τi twait: Time delay for energy harvesting

Uτi : Utility for task τi Tlimit: Execution time limit for all taskssτi : Start time of task τi ttotal: Total time needed to complete all taskstτi : WCET of task τi E[RateEH]: Expected rate of energy harvesting (J/sec)

Pτi : Power of task τi Ntasks: Total number of tasksfτi : Finish time of task τi X: Set of utilities specified by the external requestdτi : Data produced by task τi Eavailable: Energy available for task execution

TABLE IIILP FORMULATIONS FOR THE UTILITY CONSTRAINT PROBLEM (LEFT) AND THE TIME CONSTRAINT PROBLEM (RIGHT)

minimize ttotal

subject to constraints:

(a)NtasksXj=1

eτj ≤ Eavailable + E[RateEH] ∗ twait The energy budget is not ex-ceeded.

(b) Uτi =pτi

NtasksXj=1

pτj

∗NtasksXj=1

Uτj Utilities are proportional to pri-orities.

(c) ∀τj : sτj ≥ max fτk∀ekj ∈ E The task dependencies are fol-lowed.

(d) ttotal ≥NtasksXj=1

tτj + twait The total time must be no lessthan the task execution time andwait time.

(e) Uτi ≥ Uτspecified foreach Uτspecified ∈ X Utilities are no less than exter-nal specifications.

maximizeNtasksXj=1

Uτj

subject to constraints:

(a)NtasksXj=1

eτj ≤ Eavailable + E[RateEH] ∗ twait The energy budget is not ex-ceeded.

(b) Uτi =pτi

NtasksXj=1

pτj

∗NtasksXj=1

Uτj Utilities are proportional to pri-orities.

(c) ∀τj : sτj ≥ max fτk∀ekj ∈ E The task dependencies are fol-lowed.

(d)NtasksXj=1

tτj + twait ≤ Tlimit The time limit is met.

III. EXTERNAL TRIGGER REQUESTS

When a request to a system is made, the device making therequest specifies either the desired utility or the maximumtime limit; therefore, our goal is two-fold. First, we wantto determine the expected execution time of a set of tasksgiven a desired utility. Second, we want to find the maximumachievable utility within a given time limit. Both of these goalsmust meet the energy restrictions outlined in section II-B andalso account for additional time needed to harvest energy ifit exists. Estimating these values ahead of time provides theexternal device with valuable information, enabling it to, forexample, collect data from other nodes while it waits for aresult.

To define these problems, we formulate two integer linearprograms (ILPs) shown in Table II (Table I defines thevariables used). Among other requirements, both ILP solutionsmust respect the energy constraints (a), the priority constraints(b), and the task dependencies (c). For the utility constraintproblem, the goal is to minimize the total execution time (d)while satisfying the utility constraint(s) as specified by the ex-ternal request (e). This problem can be solved by determiningthe expected execution time and energy consumption of theset of tasks with the provided utilities. For the time-constraintproblem, the goal is to maximize the system utility within agiven time limit (d). An optimal solution to this problem isshown to be NP-hard in [11]. Therefore, we show a heuristicin section III-B.

A. Utility Constraint (UC)

The goal of our first algorithm is to determine the total timeand energy needed to execute all tasks at a specified level ofutility. The external request contains a desired utility for a

specific task, and the controller uses the set of priorities tocalculate the remaining task utilities. If the energy needed toexecute all tasks exceeds the energy available, the total delaytime needed to harvest additional energy, twait, is estimated.If the energy harvesting rate is not positive, which is likelythe case during the night, then no additional energy can beharvested, and no solution exists. If the energy harvesting rateis positive, the total time, ttotal, needed to execute the task setis the sum of the total execution time and the wait time. Thesteps for solving this problem are shown in figure 2 (assuminga single CPU). Using the application-specific functions fromequations 2 and 3, the controller determines twait and ttotal basedon the predicted energy-harvesting rate, E[RateEH].

ttotal =Ntasks∑j=1

tτj + twait (8)

B. Time Constraint (TC)

Data mules, such as that described by Sugihara and Gupta[13], must typically collect data from many nodes, and thus,it is desirable to designate a time limit in which results mustbe reported. When the external device specifies a time limit,the controller uses the heuristic shown in figure 3 to determinea set of task utilities that satisfies the request. The heuristicconsists of two basic steps: first, satisfy the external time limitand second, satisfy the energy constraint.

1) Step 1: Satisfy the time constraint: The first step insolving this problem uses a binary search method to find aset of task utilities whose execution times satisfy the timeconstraint. Since the utility values we search for could benumerous, a threshold ε is set such that the resulting execution

Fig. 2. Utility Constraint Algorithm

Fig. 3. Time Constraint Algorithm

time must be within ε of the time limit. This threshold placesa limitation on the amount of overhead added to the systemand can be adjusted according to the application’s needs.

2) Step 2: Satisfy the energy constraint: After finding a setof task utilities that satisfy the time constraint, our algorithmcompares the amount of required energy with the amount ofavailable energy. If sufficient energy exists, a solution has beenfound; if not, then the amount of time to wait to harvestadditional energy is determined. One option to solve thisproblem would be to try every possible combination of waittime and execution time and choose the best solution; however,on an energy-constrained embedded platform, such a highlevel of computational complexity is unreasonable. Instead,our algorithm estimates the time to wait under the assumptionthat the ratio between the current energy and time limit willbe proportional to the ratio for a new energy consumption andtime limit. Based on this premise, the wait time is computedusing equation 9, and the time limit is altered to account forthis time by reducing the original time limit by the wait time.Then, step 1 of the algorithm is executed again to determinea new set of utilities that will satisfy the reduced time limit.

twait =Eneeded

E[RateEH] + Erequired

Tlimit

(9)

Upon finding a set of task utilities that satisfies both thetime limit and the energy constraint, the system can informthe external device of the maximum achievable utility foreach task that can be executed in the given time limit, Tlimit,which includes the actual time spent executing tasks andthe time, twait, spent harvesting additional energy. While thisheuristic may not always find the optimal set of task utilities,it ensures that energy neutrality is maintained and that eachtask is executed if possible. Unlike a system without energymanagement, a system using this method is guaranteed to finda set of tasks that satisfy both the time and energy constraints.

IV. RESULTS

The system described in this paper is targeted for wirelesssensor networks that do not have constant communicationwith a base station and contain tasks that fit the modeldescribed in section II. Applications that fit this descriptioninclude wireless healthcare systems [1] and structural healthmonitoring (SHM). The methods presented in this paper havebeen adapted and simulated for the latter application.

A. Structural Health MonitoringSHM is the process of monitoring a structure over time and

assessing the health of that structure. SHiMmer [8], shown infigure 4, is a platform designed for SHM that communicateswith an external device using a combination of Zigbee anda radio triggering circuit. Unlike previous SHM platforms,SHiMmer needs to actuate a lamb wave through the structure,sense the results, and process the readings using sophisticatedSHM damage-detection algorithms. An example SHiMmertask graph is shown in Figure 5. The methods describedin section III were implemented for the SHM application.For each task, f (Uτ ) is defined in terms of the data flow,

Fig. 4. SHiMmer

Fig. 5. SHM Task Graph

the WCET, and the power consumption. Table III shows theexecution time and data formulas defined for each task, andtable IV shows the data used.

Actuation and acquisition involves the use of piezoelec-tric transducers that serve as both actuators and sensors. Apath is defined as the pairing of two transducers, whereone transducer actuates and another transducer senses. TheSHiMmer platform connects to 16 transducers and thus, canevaluate up to 120 paths. In the task graph, each of the tasksact/acq1−act/acq120 represents one of the 120 possible pathsthat can be evaluated. The utility for an act/acq task increasesexponentially as each path is evaluated an additional iteration,up to MAXiterations.

After the data is acquired from the previous tasks, it isprocessed on a TMS320C2811 Digital Signal Processor [14]by tasks avg, filt, fExt, and dCor. Averaging, represented bytasks avg1 − avg120, reduces the amount of data acquiredby the transducers by averaging multiple iterations of eachpath into a single data set. If data is averaged, then theutility is 0.25 (U = 0.25); if data is not averaged, then theutility is 0.0 (U = 0.0). Filtering (filt1 − filt120) removesnoise from the signal using a bandpass or matching filter.

If data is filtered, then the utility is 0.75 (U = 0.75); ifdata is not filtered, then the utility is 0.0 (U = 0.0). Featureextraction, fExt1− fExt120, divides the signal into N blocks, upto MAXblocks, and compares each block to a baseline signal.Finally, task dCor performs damage correlation, combining thefeatures extracted from all paths to determine if damage existsat a specific point of interest on the structure for up to MAXpoi.The utility for both feature extraction and damage correlationincreases as the number of features and blocks increase.

Task trans, the exit task in the graph, represents the trans-mitting of data using an Atmel 128L microcontroller [2] inter-faced with a Maxstream Zigbee module [5]. The utility of thedata transmission affects whether or not the data is transmitted.If the utility is greater than zero, the data is transmitted; ifthe utility equals zero, the data is not transmitted. While thismethod of utility measure is simple due to the needs of theapplication, more complicated utility measurements could beused such as varying the signal strength or amount of datatransmitted.

B. Evaluation

We simulated both algorithms using the SHM descriptionin the previous section. Because SHiMmer is powered by asolar panel and stores this energy in a supercapacitor, we usedata collected from SHiMmer’s solar panel to show how thenature of sunlight drives our algorithms. The energy harvestingcircuit used for SHiMmer enables the node to harvest energyfrom a 100 cm2 solar cell and store up to 780 J in a 250 F, 2.5V supercapacitor. The relationship between the voltage of thesolar panel and charging rate for the supercapacitor is definedusing the results obtained from twenty days of measurement,further described by Recas et al. [10].

1) Utility Constraint (UC) Algorithm: In an energy har-vesting system, the rate of energy harvesting can be exploitedto increase task utility. To demonstrate the impact of theenergy harvesting rate on task execution, the utility constraintalgorithm is executed while varying the desired task utilityfrom 0.01 to 1.00 for three distinct times of day: the peak ofa sunny day (RateEH = 0.1022 mV/s), the peak of a cloudyday (RateEH = 0.0340 mV/s), and the middle of the night(RateEH = 0 mV/s). The available energy in the buffer is setto to 100 joules and the priorities for all tasks to 1.0. Figure 6shows the energy and time required for tasks on a sunny day,when the energy harvesting rate is high. When the energyrequired to execute the tasks at the desired utility exceeds 100J, there is no longer sufficient energy in the buffer to satisfy therequest, so the system must wait to harvest additional energy.On a sunny day, this wait time never exceeds six minutes. Infigure 7, however, the wait time is significantly increased (tonearly 35 minutes) due to the reduced energy harvesting rateon this particular cloudy day. The energy and time neededto execute the tasks is equivalent to the energy and time ona sunny day, but because the harvesting rate is lower, thecompletion of the tasks will require more time. During thenight, the system cannot harvest any additional energy. Oncethe desired task utilities pass 0.74, no solution is possible, asthere does not exist sufficient energy for task execution.

TABLE IIISHM EXECUTION DEFINITIONS

Task Execution Time: f (Uτ ) Data Produced: dτ Power: Pτ

act/acq1 − act/acq120 t = (tact + tsense) ∗ Niterations d = Niterations ∗ dpair 3.5 W

(Actuate & Acquire) where Niterations =le4.6∗U−1

MAXiterations

m780 mW

avg1 − avg120 t = 0‖t = tavg ∗ (Niterations − 1) d = dact/acq‖d = dpair 680 mW

(Average)

filt1 − filt120 (Filter) t = 0‖t = tfilt ∗davg

dpaird = davg 680 mW

fExt1 − fExt120 t = dMAXblocks ∗ Ue d = dMAXblocks ∗ Ue ∗ 680 mW

(Extract Feature) davgdpair∗ dblock

dCor t =˚

MAXpoi ∗ Uˇ∗ d =

˚MAXpoi ∗ U

ˇ∗ dpoi 680 mW

(Correlate Damage)`tpoi ∗ Npairs + tadd ∗ (Npairs − 1)

´trans (Transmit) t = ddCor ∗ ttransmit/byte + twakeup d = 0 168 mW

TABLE IVSHM EXECUTION DATA

MAXiterations: 10 tact: 0.1 ms tblock: 0.5596 ms dpair: 20 KBMAXpairs: 120 tacq: 1 ms tpoi: 0.0107 ms dblock: 2 BMAXpoi: 90 tavg: 4.004 ms ttransmit/byte: 0.071 ms dpoi: 2 B

MAXblocks: 50 tfilt: 1294.6 ms twakeup: 13.2 ms tadd: 0.0004 ms

Fig. 6. UC: Energy and Time Characteristics on a Sunny Day

Fig. 7. UC: Energy and Time Characteristics on a Cloudy Day

2) Time Constraint (TC) Algorithm: An important valuein the time constraint algorithm is the threshold ε, whichdetermines the percentage of deviation from the specified timelimit. To determine an appropriate value for ε, we comparedthe optimal values with the results using several thresholdvalues. The optimal values were obtained for various time

TABLE VMODES WITH VARIOUS PRIORITY COMBINATIONS

Paths 1-40 Paths 41-60 Paths 61-80 Paths 81-120Mode 1: p = 1.0 p = 1.0 p = 1.0 p = 1.0Mode 2: p = 1.0 p = 1.0 p = 0.6 p = 0.6Mode 3: p = 1.0 p = 0.6 p = 0.6 p = 0.1

limits using an exhaustive search with the utility constraintalgorithm. To reduce the amount of search overhead yet alsomaintain acceptable accuracy at low time limits, we chose athreshold of ε = 2%.

To test the impact of priority on achievable utility, threemodes of priority combinations are defined, shown in table V.For the first mode (mode 1), all priorities for all paths are 1.0.In the second mode (mode 2), one half of the tasks for allpaths (act/acq, avg, filt, and fExt) have a priority of 1.0, whilethe other half have a priority of 0.6. Finally, in the third mode(mode 3), one third of the tasks for all paths have a priorityof 1.0, one third have 0.6 and the last third have 0.1. In allmodes, the dCor task has a priority of 1.0. The results for thethree modes are shown in Figure 8 where the achievable taskutility of the fExt task changes with time limit and mode. Asthe time limit in the request is increased, mode 1 requires over150 seconds to obtain full utilty, while mode 3, for example,takes less than 60 seconds. The results show that for mode 3,the more important tasks can achieve full utility, while the lessimportant tasks settle for lower utility. Distinguishing betweenthe importance of types of tasks allows the more importanttasks to achieve full utility at the expense of the other tasks.

3) Steady State with External Requests: While the focusof this paper is on external requests, steady state operation isimportant as it describes the periodic execution of tasks on

Fig. 8. TC: Impact of a Task’s Priority on Achievable Task Utility

a system. In some systems, steady state operation is definedby the method of duty cycling. For the system targeted in thiswork, however, steady state operation defines the periodic exe-cution of a task graph, the utility of which is determined usingthe time constraint algorithm or a similar energy constraintalgorithm. As the energy harvesting rate assumed for thissystem is variable, the amount and rate of energy harvestingdetermines the rate of task execution and the types of tasks tobe executed. During the day, the execution rate, r, indicatesthe number of times that a set of tasks is executed. Becauseday lengths and energy harvesting rates change over time, theexecution rate is altered to maximize the number of maximumutility executions.

An energy constraint algorithm is executed r times per dayto determine the utility at which to execute tasks. The energyconstraint algorithm determines the maximum achievable util-ity given an amount of energy and is solved using an algorithmsimilar to the time constraint algorithm from section III-B butusing an energy constraint instead of a time constraint. The en-ergy constraint equals the current energy in the buffer, Ebuffer,minus the steady state energy threshold, Esteady. After eachiteration, the achievable utility is compared to the maximumutility of the set of tasks and adjusted accordingly. Additionaldetails concerning steady state operation can be found in [12].

As steady state operation and external requests are typicallyintertwined, steady state operation is simulated with randomexternal requests (Esteady = 400 J and Emin = 200 J). Figure 9shows that energy neutrality is maintained as the execution rateadapts to the energy consumed during external requests. Theexternal requests in the figure are normalized to the primaryaxis such that a value of 200 indicates a time constraint requestand a value of 400 indicates a utility constraint request. Thereexists a 0.05% chance of an external request every minute inthe last six days of the evolution.

V. CONCLUSION

In this paper, we propose a solution for balancing the trade-off between task utility and system constraints. We providea general, adaptable task model that can be used in energyharvesting systems where task execution characteristics andquality are known. We describe two algorithms that can beused to provide immediate feedback to an external request.Our first algorithm determines the execution time and energyconsumption of a set of tasks at a certain utility. Our secondalgorithm solves the converse problem by choosing the utility

Fig. 9. Steady State with External Requests

for a set of tasks given a time constraint. Our evaluationshows that our methods can be applied to an application byproviding a task graph, task execution definitions, and utilityrelationships. We show how the energy harvesting rate andpriority impact the execution time, energy consumption, andachievable utility of a set of tasks. Most importantly, ourevaluation confirms our controller’s ability to adapt at runtimeand maintain energy neutrality.

ACKNOWLEDGMENT

The authors would like to thank their colleagues in theStructural Engineering Department and Los Alamos NationalLaboratory.

REFERENCES

[1] Priti Aghera, Diana Fang, and Tajana Simunic Rosing. Energy manage-ment in wireless healthcare systems. IPSN, 2009.

[2] Atmel. Atmega 128L Microcontroller, 2007.[3] Aman Kansal, Jason Hsu, Mani Srivastava, and Vijay Raghunathan.

Harvesting aware power management for sensor networks. In DAC ’06:Proceedings of the 43rd annual conference on Design automation, 2006.

[4] Aman Kansal, Dunny Potter, and Mani B. Srivastava. Performance awaretasking for environmentally powered sensor networks. SIGMETRICSPerform. Eval. Rev., 32(1), 2004.

[5] Maxstream. Maxstream XBee OEM RF Module, 2007.[6] Clemens Moser, Lothar Thiele, Davide Brunelli, and Luca Benini.

Adaptive power management in energy harvesting systems. In DATE’07: Proceedings of the conference on Design, automation and test inEurope, 2007.

[7] Clemens Moser, Lothar Thiele, Davide Brunelli, and Luca Benini.Lazy scheduling for energy-harvesting sensor nodes. In DIPES ’06:Proceedings of the 5th working conference on distributed and parallelembedded systems, 2007.

[8] D. Musiani, K. Lin, and T. Simunic Rosing. Active sensing platformfor wireless structural health monitoring. In IPSN ’07: Proceedings ofthe 6th international conference on Information processing in sensornetworks, 2007.

[9] Joseph A. Paradiso and Thad Starner. Energy scavenging for mobileand wireless electronics. IEEE Pervasive Computing, 4(1), 2005.

[10] Joaquin Recas Piorno, Carlo Bergonzini, Benjamin Lee, and TajanaRosing. Solar energy harvesting prediction algorithm. 4th Annual EnergyHarvesting Workshop, 2009.

[11] Cosmin Rusu, Rami Melhem, and Daniel Mosse. Multi-version schedul-ing in rechargeable energy-aware real-time systems. J. EmbeddedComput., 1(2), 2005.

[12] Jamie Steck. Energy and task management in energy harvesting wsnsfor structural health monitoring. Master’s thesis, UCSD, 2009.

[13] Ryo Sugihara and Rajesh K. Gupta. Improving the data delivery latencyin sensor networks with controlled mobility. In DCOSS ’08: Proceedingsof the 4th IEEE international conference on Distributed Computing inSensor Systems, 2008.

[14] Texas Instruments. TMS320C2811 Data Manual, 2007.