A Self-Governing, Decentralized, Extensible Internet of Things

To Share Electrical Power Efficiently

Horia A. Maior and Shrisha Rao
Mixed

Reality Lab, School of Computer Science

University of Nottingham, UK
E-mail: maiorh@acm.org
International Institute of Information Technology - Bangalore
Bangalore 560 100, India
E-mail: shrao@ieee.org

Abstract An extensible, decentralized Internet of Things

(IoT), with self-governing objects connected to a shared, variable power supply, is a realistic problem domain for certain
demand-management problems arising in the context of future
smart homes connected to smart power grids. A theoretical
framework of such an IoT is presented and discussed in this
paper. Each object of the IoT has a power demand and
a priority, and it is interconnected and able to exchange
information with all other objects in the system. As each object
shares information (its power demand and priority) with the
other objects, the system as a whole gains self-governance, or is
able to be managed without a centralized controller. Our model
of such an IoT also gives four applicable algorithms describing
the behavior of the objects, along with analyses of correctness
and performance.
Keywords: Internet of things, distributed algorithms, electrical power, resource allocation, demand side management, power
system automation.

I. I NTRODUCTION
A lot of effort has been invested when it comes to
managing and distributing resources among large distributed
systems. Together with the distribution of such resources,
improving the energy efficiency of a system can be done at
the demand-management level [1]. A common resource to
be shared is electrical power, powering all kind of devices
around us, such as households appliances (fridge, computer,
toaster etc.). An Internet of Things (IoT) [2] is a term to describe a network of thingsobjects not traditionally thought
of as computers (e.g. cars, household appliances), which
may nonetheless be connected using Internet protocols and
technologies (TCP/IP, etc.). Assuming that such a network of
objects is connected to a shared, variable power supply, it is
fruitful to consider protocols by which they may function
effectively in a decentralized manner, efficiently sharing
electrical power. Here is presented a novel approach where
a network of connected, autonomous IoT objects efficiently
share electrical power from a common, limited power supply.
Every object within the IoT has an individual power requirement. The power rating of each object is assumed to be
constant (i.e., not changing over time), such that objects can
either be powered (i.e., consuming their full power demand)

or not powered at all (consuming zero power). Following

Rao [3], objects drawing power resource are distinguished
from one another by some sort of priority. This is because
in practice, some objects are more important than others in
terms of their functions and utilities. In our approach, the
IoT objects are assigned a priority, therefore being able to
distinguish which objects should have access to power first.
The approach we take in this paper overcomes the limitations of having a central controller or a master node of some
sort to oversee the activities of all objects (making decisions
on behalf of the objects [4]). Instead, all objects decide their
own actions based on what we call an individual overview of
the whole system. The overview would be the information
collected by each object in the system from all other objects. This is possible through direct object communication
(objects exchanging information among them without human
intervention [5]): each object shares with other objects its
priority and power demand by broadcasting messages over
the network.
The resulting system is an extensible and decentralized
one, also overcoming limitations such as scalability and
reliability; objects can join or leave the system at any
time. Such a system is also not subject to a single point
of failure (SPOF). In other words, if an object fails to
complete an action/task, the rest of the system would not
stop working or would not be affected, unlike a centralized
system which would be rendered entirely dysfunctional if the
central controller were to fail. The decentralized approach
requires every object in the system to have processing and
communication functions, which would give them computing
capabilities, and make them capable decision making. Such
self-governing objects are technologically feasible [6] (hence
the current focus on IoT). Liu and Zhou [7] describe an
autonomy feature, where objects have the ability to reason,
negotiate, understand, adapt and learn from other objects.
The power source for the system might not provide enough
power to satisfy all objects in the IoT. Therefore, higher
priority objects should have the chance to get powered
first. To satisfy as many objects as possible given a limited

power budget, within high priority objects, low consumers

(objects with smaller power demands) would be powered
first. However, objects in the IoT might not necessarily
require power at all times. For example, a toaster may be
considered to need power in the mornings when toast is
desired for breakfast, but it may not require power during
the rest of the day though it continues to be part of the
system.
Our model of an IoT considers it to have a non-preemptive
power policy with no partial fulfillment. When an object is
allocated power, the allocation is not interrupted until it has
finished its work, and allocation is either zero or sufficient
to meet the demand. Moreover, in the IoT there are no
dependencies among objects; objects do not have to wait for
other objects to finish tasks/jobs so they can do their own
work.
To model the behavior of the object in the IoT, four
algorithms have been developed in further sections. The
Flood Algorithm describes how objects communicate with
other objects, particularly how they broadcast messages to
all other objects. The Exploration Algorithm captures the
behavior of objects exploring the system and finding other
objects; this is the way an object can create a local overview
of the whole system. When an object is to exit the system,
the Exit Algorithm describes how it interacts with other
objects about its impending departure. The Power Algorithm
describes how and when objects of the IoT get powered. The
first part of the algorithm addresses the highest priority object
with the smallest power demand, while the rest describes the
process of powering the next-in-line objects.
We consider the use of the power available from a source
to the maximum extent possible. When comes to sustainable
energy, the available power resource is variable and it should
be used to the maximum extent possible at a given time
(considering the example of solar power, as much of the
available power as possible should be used when the sun is
shining, as storage and later use tend to be expensive and
problematic [8]).
To complete the development of this model of IoT, we
prove the correctness of our algorithms in the last part
of Section III. We formulate two lemmas stating relevant
correctness properties, and give corresponding proofs. In
Section IV, a simulation example has been presented showing, for a sample IoT consisting of a set of household
appliances objects and a given power budget, how and in
which order, objects get powered.
II. R ELATED W ORK
The IoT has the potential to be a great method for solving
demand-management problems [9]. Higgins et al. [10] discuss a pathway to flexible power system automation. They
propose a new approach based on distributed intelligence
rather than traditional centralized control, with the system
improving on many levels. We further develop along the
lines of their approach, by creating a decentralized distributed
model of an IoT, where power resource consumers can freely
join and leave the system automatically at any time [11].

Zorzi et al. [12] point out that there is presently a firsttime opportunity to use the IoT approach to interact with
surrounding environments and to exchange information that
previously was not available. They address a series of issues
when comes to the IoT paradigm, including connectivity,
scalability, self-management, capabilityall within the context of energy management. Monnier [13] discusses how
objects around us need to be more and more connected and
suggest that connectivity is the key to automation. Perera
et al. [6] survey context-aware computing by an IoT.
Niyato et al. [14] present a system that uses machineto-machine (M2M) communication to reduce the costs of
a home energy management system. They describe a smart
grid system as having three major parts: power generation,
power distribution and power consumption. Their M2M
communication takes place between home appliances and
smart meters, and the system is dependent on a central
node or control center [14]. Our approach overcomes the
limitation inherent in using a central controller of any sort.
Objects in our model use a sort of M2M communication, but
in a different context; objects communicate among themselves and decide their own actions (e.g. to get powered
if suitable conditions exist). Karnouskos [15] supports such
an approach, and points out that communication between
objects and other entities, with alternative energy resources
which are smaller and decentralized, is one way to achieve
common goals such as energy efciency. Walczak et al. [16]
also describe M2M communication as part of the IoT and
the Future Internet Engineering.
The combination of intelligent consumers and providers of
sustainable energy has been recently combined conceptually
as the Internet of Energy [17], [18]. Bui et al. [17] present
a set of advantages of combining the smart grid and IoT,
such as decentralization of the control procedures. They
mention that from a communication perspective, the smart
grid distribution network must also be scalable, given the
high number of devices that are presumed to take part in the
future Internet of Energy [19].
Siano [20] presents ways in which systems can lower
peak demand, and Gelazanskas and Gamage [21] propose a
novel electricity demand control technique using real-time
pricing. Such methods often require coercive stopping of
consumption at a system-wide level. Our work overcomes
the limitations of stopping objects of the IoT/smart grid
consumers from consuming power at peak times, instead
making the objects responsible for their own usage times
(objects decide themselves when it is a suitable time to get
powered) but subject to global availability limits.
The works discussed above consider how to reduce energy
consumption in networked systems, but there is also a
substantial literature (though not directly pertinent to our
problem domain) on energy efficiency in networking itself
as may be seen in the survey by Bolla et al. [22].
III. P ROBLEM S TATEMENT
In this section, an abstract model of the IoT within a
demand-management problem is discussed. The definitions

and notations of the problem are defined, and four applicable

algorithms are developed and discussed along with analyses
of correctness and performance.
A. System Model and Notation
Let there be numerous objects i that demand and may
consume electrical power. The set of all objects, denoted
by O, together with the power supply and the underlying
communication network, comprise the whole system.
O = {0 , 1 , ..., n1 }, the set of all n objects.
Each object consumes a non-negative amount of power
(i.e., objects are not themselves power sources). We assume
this amount to be constant for each object when powered
(objects cannot change their power ratings). Let R+ be the
set of positive real numbers, and R+ {0} the set of nonnegative reals; then the demand function f : O R+ {0},
where f (i ) = r means that the power demand of object i
is r.
The Total Demand of the system at any one time, according to Rao [3], is the sum of all power demands of all objects
in the system:
Td =

n1
P

f (i )

i=0

The power supply can be described as the total amount

of power from some source available to share among all
objects of the system at a given time. One property of the
power supply is that it is variable in time. Let the set T
denote the set of all time instances. Then, the function :
T R+ {0} is a power supply function, where (t) = w
indicates the power provided by the power source at a given
time t.
In Section I we describe each object in the system as
having an assigned priority level, and therefore being able to
distinguish which objects should be powered and in which
order. We assume the priority of an object to be constant, so
that objects cannot change their priority levels. Let : O
R+ {0} be a priority function, with (i ) = p, where p is
the priority of object i .
Objects need to keep track as they get powered. Considering the boolean values TRUE and FALSE, a status function
p : O T {TRUE, FALSE} is given by:

TRUE
if i is powered at t
p(i , t) =
FALSE
if i is not powered at t.
When an object i gets powered at time t, the boolean
status function p(i , t), becomes TRUE. This way, each
object knows its status (powered or not powered) at any
time. However, objects of the IoT can both accept and refuse
power. Let function d : O T {TRUE, FALSE} denote
wether or not an object requires power at a specific time t:

TRUE
if i needs power at time t
d(i , t) =
FALSE
otherwise.
When joining the IoT, objects explore the system in order
to create their local overview of the IoT. In particular, each

object is interested in storing information about other objects;

it wants to know the other priorities in the system vis-`a-vis
its own priority, and objects with the same priority. Every
object i {O} maintains two arrays:
Pi [] is an array where object i stores priorities of other
objects in the system (but without the information of
which objects are at what priority levels); this is sorted
in decreasing order such that Pi [0] holds the highest
priority known to i .
Qi [] is an array denoting objects with the same priority
as i ; it is sorted in increasing order of power demand,
such that Qi [0] holds the id of the object with smallest
power demand known to i .
When joining the system (just before exploring), every
object i has zero elements in Pi [], and just one element in
Qi [], viz., i itself. The arrays are then modified as will be
explained shortly.
B. Algorithms: Flood, Exploration, Exit, and Power
Every object networked in the IoT is able to exchange
information with other objects (for simplicity, we abstract
away the details of how they are physically networked, and
assume a reliable underlying communication service). It is
also assumed that every object has some sort of no-cost
and reliable computing capability. When joining the IoT,
objects explore the whole system; they find other objects
and store information about them. This way, every object
creates its own local overview of the system, and knows
things such as its own priority relative to other objects. The
exploration is possible through communication and exchange
of information among objects. As an abstraction of how the
communication is done, let i , j {O} be two objects.
Let msg[i , j , ] be a message (when there is no confusion
we simply write it as msg[]), where i is the sender of
the message, j is the receiver of the message, and is
the message (which may contain any kind of information).
After receiving a message, the receiver j stores the message,
by function store(j , ), and sends an acknowledgement
for receiving the message to the sender, as indicated in
ack [j , i , ]. Following a standard approach [23], a message
can also be broadcasted or flooded over a system of IoT
objects. The Flood Algorithm is an adapted version [23] for
broadcasting a message across n connected objects of the
IoT, from a sender object j . Algorithm Flood implements
a subroutine function broadcast[j , ], such that j is the
object flooding message .
The number of messages sent by objects can be used to
evaluate the message complexity of the algorithms described
in this paper. The object running the Flood Algorithm sends
a message to all other n1 objects; therefore the complexity
of the Flood Algorithm is O(n).
In the Exploration Algorithm (run by all objects of the
IoT), objects communicate among themselves and exchange
information about their priorities and their power demands.
At the same time, objects receive, compute, and store information about other objects, creating their own local overview
of the IoT system.

Algorithm 1: Flood Algorithm with object j flooding message over all other objects.
1

broadcast[j , ]

for i 0 to n 1 do
if i 6= j then
Send msg[j , i , ]
end
end
Upon Receiving msg[]

store(i , )

ack [i , j , ]

3
4
5
6

Algorithm 3: Exit Algorithm run by i when leaving the system at time t.

1

broadcast[i , msg[i , (i ), f (i ), powered

p(i , t)]]

for j 0 to n 1 do

3
4
5
6
7
8
9

Algorithm 2: Exploration Algorithm run by i

when joining the system at time t.
1

broadcast[i , msg[i , (i ), f (i )]]

for j 0 to n 1 do
Upon Receiving msg[]

3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

11
12
13
14
15

if (i ) = (j ) then
Remove i from Qj []
end
else
if sizeof (Pj []) = 1 then
Remove (i ) from Pj []
end
end
if powered = TRUE then
w w + f (i )
end
end

if (i ) = (j ) then
Insert i in Qj []
ack [j , i , ((i ) = (j ))]
end
else
if (i )
/ Pj [] then
Insert (i ) in Pj []
ack [j , i , (i ) 6= (j ))]
end
end
end
for j 0 to n 1 do
Sort Qj [] in increasing order of f ()
Sort Pj [] in decreasing order
end

The Exploration Algorithm has complexity O(n2 ), and

this is mostly because there are n objects running the Flood
Algorithm, with every object sending n 1 messages.
Objects joining the system may no longer want to be part
of the system, and may exit. The leaving object informs all
the other objects about its intention. The Exit Algorithm
describes exactly what happens when an object leaves the
system.
The Exit Algorithm has complexity O(n). Each leaving
object informs all other objects about its intention, therefore
sending n 1 messages. The message sent by the leaving
object contains three important information parts:

10

Upon Receiving msg[]

Its own priority level (i );

Its own power demand f (i ); and;
Whether or not the leaving object is powered (function
p(i , t)).

In the case that the leaving object i has the same priority

as a j receiving the message, the latter has to remove the

leaving object from the array Qj [] (lines 46 Algorithm
3). In the case that the leaving object i is the last one of
its priority, the whole priority level is also removed from
the other array Pj [] (lines 89 Algorithm 3). Finally, if
the leaving object was powered, its power demand becomes
available for other objects (lines 1214 Algorithm 3).
We mentioned that some objects might be more important
than others, therefore we distinguish among them in terms of
priority levels. In the case of the power supply from a source
not being able to satisfy all objects, higher priority objects
are satisfied first. We also discussed that objects can have
different power demandsone object may need more power
than others. In the case of objects with the same priority
level, the system first serves the lower-consuming object. The
Power Algorithm describes how the power first reaches the
highest priority object with the smallest power demand, and
how each object informs other objects about its actions and
the remaining available power.
The Power Algorithm is run by all objects in the system
independently. The first part of the algorithm (lines 115)
concerns the highest priority object with the lowest power
demand. It is the first object with the chance to get powered;
in the case that the available power can satisfy its power
demand and the object needs to get power at current time
(lines 36). When an object has the chance to get powered,
it sends a message to the next-in-line object, which can be
either of the same priority but with a higher power demand
(lines 1114), or one of the next lower priority (lines 7
10). The second part of the Power Algorithm (lines 16
30) describes the behavior of objects upon receiving such
a message. In the first place, objects check if the message
was directed to them (lines 1718). If so, it is their chance
to get powered.

Algorithm 4: Power Algorithm run by all objects

i {O} at time t.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

18
19
20
21
22
23
24
25
26
27
28
29
30

if (i ) > Pi [0] and Qi [0] = f (i ) then

w (t)
if f (i ) w and d(i , t) = TRUE then
p(i , t) TRUE
w w f (i )
end
if sizeof (Qi [] = 1) then
nextP riority Pi [0]
broadcast[i , msg[nextP riority, w]]
end
else
nextObj Qi [1]
Send msg[j , nextObj, w]
end
end
Upon Receiving msg[]
if [j = nextObj] or [(j ) = nextP riority and
Qj [0] = f (j )] then
if (f (j ) w) and(d(j,t ) = TRUE) then
p(j , t) TRUE
w w f (j )
end
if sizeof (Qj []) = 1 then
nextP riority Pj [current + 1]
broadcast[j , msg[nextP riority, w]]
end
else
nextObj Qj [current + 1]
Send msg[j , nextObj, w]
end
end

The message complexity of the Power Algorithm is

O(n2 ), which arises in the worst case when all objects have
different priorities, and every object broadcasts n messages.
C. Proofs of Correctness
We identify a set of desirable properties of the IoT model,
and prove the correctness of our proposed design by showing
that they hold.
We claim that the system we propose is wastage free. By
this, we mean that all available power is used by the objects
to the greatest extent possible, and there is no object i O
facing a situation where the object requires power at the
current time (d(i , t) = TRUE), but is not powered, i.e.,
(p(i , t) = FALSE), though there is enough power resource
to meet i s demand (f (i ) w).
This is indicated formally as follows.

Lemma III.1. i O, (d(i , t) = TRUE) and

(p(i , t) = FALSE) and (f (i ) w);
Proof. By contradiction, assume i O such that
d(i , t) = TRUE and p(i , t) = FALSE while there is
sufficient power to satisfy its demands, (f (i ) w). There
are two cases to consider:
Object i is the highest priority object with the smallest
power demand (among objects of the same priority); if
p(i , t) = FALSE, following lines 34 in Power Algorithm (Algorithm 4) f (i )  w. Power demand f (i )
cannot be both w and  w. Hence a contradiction.
Otherwise, object must have received a message from a
higher priority object; if p(i , t) = FALSE, following
lines 1821 in the Power Algorithm (Algorithm 4),
f (i )  w. Power demand f (i ) cannot be both w
and  w. Hence also a contradiction.
We also claim that there is no priority inversion in our
model, meaning that higher priority objects get powered first,
if possible (that is if there is enough power available to satisfy
their demands), before the lower priority ones. This means
that there are no objects i , j O, with i 6= j, such that
object j has a higher priority than object i , the available
power is more than the power demanded by any of the i
and j (w f (i ) and w f (j )), but the lower priority
object i is powered (p(i , t) = TRUE) while the higher
priority one j is not (p(j , t) = FALSE).
This is indicated formally as follows.
Lemma III.2. i , j O such that ((i ) < (j )) and
(w f (i ) and w f (j )), (p(i , t) = TRUE and
p(j , t) = FALSE).
Proof. By contradiction, assume i , j O, such that
priority of object (i ) < (j ) and the power available can
satisfy any of the two objects with power resource w f (i )
and w f (j ). We also assume that p(i , t) = TRUE and
p(j , t) = FALSE after running the Power Algorithm. There
are two cases to consider:
Object j is object with the smallest power demand
object and the highest priority; following lines 14 in
Power Algorithm (Algorithm 4), object j gets powered
first (therefore, before i ) and p(j , t) = TRUE.
Object j cannot be in the same time both powered
p(j , t) = TRUE and not powered p(j , t) = FALSE
(the assumption made). Hence a contradiction.
Object j is not the highest priority with the smallest
power demand object; objects get powered when receiving a message dedicated to them (lines 1718 Algorithm 4). Messages flow from the highest priority object
(line 1, Algorithm 4) towards the lowest priority ones
(lines 714 and 2129 in Algorithm 4). If p(i , t) =
TRUE and p(j , t) = FALSE, the message must have
first arrived to object i . Therefore (i ) (j ). But
the priority comparison cannot be both (i ) < (j )
and (i ) (j ) at the same time. Hence too a
contradiction.

Object Name
Electric Shower
Dishwasher
Washing Machine
Tumble Dryer
Iron
Toaster
Oven
Grill
Fridge-Freezer
Vacuum Cleaner
Hairdryer
Plasma TV
Desktop Computer
Broadband Router
Smart Phone

Abbreviation
ES
Dw
WM
TD
Ir
Ts
Ov
Gr
FF
VC
Hd
TV
PC
BR
SP

PowerDemand
7kW
1.5kW
1.5kW
3kW
1.6kW
1kW
2kW
1.8kW
0.4kW
1kw
1kW
0.4kW
0.15kW
0.01kW
0.005kW

Priority
6
1
2
2
2
8
8
8
10
3
9
5
9
10
10

TABLE I
( SOURCE : [24])

Object
SP
BR
FF
PC
Hd
Ts
Gr
Ov
ES
TV
VC
WM
Ir
TD
Dw

Case 1 (10kW)
on
on
on
on
on
on
on
on
off
on
on
on
off
off
off

Case 2 (10kW)
on
on
on
on
on
N/A
on
N/A
off
on
on
on
on
off
on

Case 3 (11kW)
on
on
on
on
on
N/A
on
N/A
on
on
off
off
off
off
off

TABLE II
L EGEND : ON = OBJECT IS POWERED ; OFF = OBJECT IS NOT POWERED ;
N/A = OBJECT DOES NOT REQUIRE POWER CURRENTLY.

Fig. 1.

The order of power usage in the IoT sample.

IV. R ESULTS
In this section, the results of our work are presented with
a simple simulation example. A sample IoT consisting of
objects from a hypothetical smart house as consumers of
power is considered with realistic data from a published
source (see Table I). Given limited proposed power budgets,
we simulated which objects are powered and in which order
in various scenarios (3 cases). Each object has a power
demand (usage setting), and a priority level (from 1 to 10)
denoting its importance relative to the other objects. The
power resource budget is an amount of power in kilowatts
(kW) available to share among the objects.
After running the Exploration Algorithm, each object
knows where it stands in the system relative to other objects.
Further, according to the Power Algorithm, the highest priority object with the smallest power consumption is powered
first. Figure 1 shows that object SP should be powered first,
and also describes the order in which power flows among
the IoT objects.
For a power availability of 23 kW, assuming that all

objects want to be powered, all objects are powered, as the

total demand of all objects from the IoT is 22.365kW <
23kW . However, sometimes the budget may not satisfy the
system needs, and at other times there may be objects that do
not require power. We present three cases below, simulating
the proposed IoT while varying power budget and object
demands:
C ASE 1: Simulating which objects get powered if the
power budget is 10 kW and all objects require (need)
power. As shown in the first column of Table II, objects
SP to Ov would get powered right away; their demand
is 6.356 kW, therefore the remaining power is 3.635
kW. Object ES is skipped as its demand is larger
than the remaining power, and objects TV, VC, WM
are being powered (requiring 2.9 kW). The remaining
power 0.735 kW cannot satisfy any of the remaining
objects, therefore this amount is not used and objects
ES, Ir, TD and Dw are not powered.
C ASE 2: The power budget remains the same (10 kW),
but objects Ov and Ts do not require power at the
current time. The second column of Table II shows how
objects with low priority that were not powered in Case
1 are powered in Case 2 for the same amount of power
available.
C ASE 3: Objects Ov and Ts still do not require power
at the current time, and the power budget is increased
to 11 kW. Table II shows how for a slightly higher
power budget, fewer objects are getting powered. This
is because there is now enough power to satisfy object
ES, and this object in particular has the highest power
demand in the system (7 kW).
V. C ONCLUSIONS AND F URTHER W ORK
We propose a model for the development of a selfgoverning IoT of objects that share power without a central
controller. Four applicable algorithms have been included
in order to describe the behavior of such objects, further
giving some analyses of correctness and performance. This

model can be adopted and extended when implementing a

smart home or other real IoT. The model developed is
extensible and decentralized, such that it meets the needs and
requirements of an IoT with a variable number of connected
objects. It is also SPOF free, and overcomes the limitations of
having a central controller by having self-governing objects.
Certain assumptions that have been made for our IoT
model, e.g., that objects have a fixed, constant power demand
and priority level, are relaxed in later work that enters
in some greater complexity; this is meaningful as in real
life, appliances can have multiple levels of power settings
(e.g., a hair dryer or washing machine typically has multiple
settings). Another important development is that the run-time
and unexpected changes in power availability may require the
IoT to dynamically adjust (as in [3]), however an algorithm
to handle such changes in power has not been presented
here. We also assumed that there is only one power supplier;
a further approach can consider multiple power suppliers,
possibly also including objects that are both power producers
and consumers (which would make the problem similar
to the Potluck Problem [25]). We can include and discuss
algorithms for such a scenario also that are not presently
included, resulting in an IoT model of greater sophistication
and applicability than that captured in this paper.
Starting from the simulation example presented in this
paper, we can further add without much difficulty a complete
simulation of the IoT with real and realistic data describing
a complete set of smart home objects (with real power
demands [24]). A real power budget from sustainable energy
sources can be obtained and used in the proposed simulation
(e.g. solar profile data obtained from NREL [26], cost price
profile from Nova Scotia Power [27], and load profile data
from Southern California Edison [28]).
R EFERENCES
[1] P. Palensky and D. Dietrich, Demand side management: Demand
response, intelligent energy systems, and smart loads, IEEE Trans.
Ind. Informat., vol. 7, no. 3, pp. 381388, 2011.
[2] J. Holler, V. Tsiatsis, C. Mulligan, S. Avesand, S. Karnouskos,
and D. Boyle, From Machine-to-Machine to the Internet of Things:
Introduction to a New Age of Intelligence. Academic Press, 2014.
[3] S. Rao, A foundation of demand side resource management in
distributed systems, Trans. on Comput. Sci., vol. VIII, pp. 114126,
Oct. 2010, doi:10.1007/978-3-642-16236-7 8.
[4] M. R. Palattella, N. Accettura, X. Vilajosana, T. Watteyne, L. A.
Grieco, G. Boggia, and M. Dohler, Standardized protocol stack for the
Internet of (important) Things, IEEE Commun. Surveys Tuts., vol. 15,
no. 3, pp. 13891406, 2012.
[5] S. S. Prasad and C. Kumar, An energy efficient and reliable internet
of things, in Communication, Information & Computing Technology
(ICCICT), 2012 International Conference on. IEEE, 2012, pp. 14.
[6] C. Perera, A. Zaslavsky, P. Christen, and D. Georgakopoulos,
Context aware computing for the Internet of Things: A survey,
IEEE Commun. Surveys Tuts., vol. 16, no. 1, pp. 414454, 2014,
doi:10.1109/SURV.2013.042313.00197.
[7] Y. Liu and G. Zhou, Key technologies and applications of internet
of things, in Intelligent Computation Technology and Automation
(ICICTA), 2012 Fifth International Conference on, 2012, pp. 197200.
[8] I. Maity and S. Rao, Simulation and pricing mechanism analysis of
a solar-powered electrical microgrid, IEEE Syst. J., vol. 4, no. 3, pp.
275284, Sep. 2010, doi:10.1109/JSYST.2010.2059110.

[9] C. Wei and Y. Li, Design of energy consumption monitoring and

energy-saving management system of intelligent building based on
the Internet of Things, in International Conference on Electronics,
Communications and Control (ICECC 2011), 2011, pp. 36503652,
doi:10.1109/ICECC.2011.6066758.
[10] N. Higgins, V. Vyatkin, N. Nair, and K. Schwarz, Distributed
power system automation with IEC 61850, IEC 61499, and intelligent
control, IEEE Trans. Syst., Man, Cybern. C, vol. 41, no. 1, pp. 8192,
2011.
[11] A. Suzdalenko and I. Galkin, Instantaneous, short-term and predictive
long-term power balancing techniques in intelligent distribution grids,
in Technological Innovation for the Internet of Things, ser. IFIP
Advances in Information and Communication Technology, L. M.
Camarinha-Matos, S. Tomic, and P. Graa, Eds.
Springer Berlin
Heidelberg, 2013, vol. 394, pp. 343350.
[12] M. Zorzi, A. Gluhak, S. Lange, and A. Bassi, From todays intranet of
things to a future Internet of Things: A wireless-and mobility-related
view, IEEE Trans. Wireless Commun., vol. 17, no. 6, pp. 4451, 2010.
[13] O. Monnier, A smarter grid with the Internet of Things,
Texas Instruments White Paper, 2013. [Online]. Available: http:
//www.ti.com/lit/ml/slyb214/slyb214.pdf
[14] D. Niyato, L. Xiao, and P. Wang, Machine-to-machine communications for home energy management system in smart grid, IEEE
Commun. Mag., vol. 49, no. 4, pp. 5359, 2011.
[15] S. Karnouskos, The cooperative Internet of Things enabled smart
grid, in Proceedings of the 14th IEEE International Symposium on
Consumer Electronics, Braunschweig, Germany, 2010, pp. 0710.
[16] D. Walczak, M. Wrzos, A. Radziuk, B. Lewandowski, and C. Mazurek,
Machine-to-machine communication and data processing approach in
future Internet applications, in 8th International Symposium on Communication Systems, Networks & Digital Signal Processing (CSNDSP
2012), 2012, pp. 15.
[17] N. Bui, A. P. Castellani, P. Casari, and M. Zorzi, The Internet of
energy: A web-enabled smart grid system, IEEE Netw., vol. 26, no. 4,
pp. 3945, 2012, doi:10.1109/MNET.2012.6246751.
[18] H.-J. Appelrath, O. Terzidis, and C. Weinhardt, Internet of Energy
ICT as a Key Technology for the Energy System of the Future,
Business & Information Systems Engineering, vol. 4, no. 1, pp. 12,
2012.
[19] O. Vermesan, P. Friess, P. Guillemin, S. Gusmeroli, H. Sundmaeker,
A. Bassi, I. S. Jubert, M. Mazura, M. Harrison, M. Eisenhauer, and
P. Doody, Internet of Things strategic research roadmap, Internet
of Things-Global Technological and Societal Trends, pp. 952,
2011. [Online]. Available: http://www.internet-of-things-research.eu/
pdf/IoT Cluster Strategic Research Agenda 2011.pdf
[20] P. Siano, Demand response and smart gridsa survey, Renewable
and Sustainable Energy Reviews, vol. 30, pp. 461478, 2014.
[21] L. Gelazanskas and K. A. A. Gamage, Demand side management in smart grid: A review and proposals for future direction,
Sustainable Cities and Society, vol. 11, pp. 2230, Feb. 2014,
doi:10.1016/j.scs.2013.11.001.
[22] R. Bolla, R. Bruschi, F. Davoli, and F. Cucchietti, Energy Efficiency
in the Future Internet: A Survey of Existing Approaches and Trends
in Energy-Aware Fixed Network Infrastructures, IEEE Commun.
Surveys Tuts., vol. 13, no. 2, pp. 223244, Second Quarter 2011,
doi:10.1109/SURV.2011.071410.00073.
[23] D. Peleg, Distributed computing: a locality-sensitive approach.
SIAM, 2000, vol. 5.
[24] How much electricity am I using? 2014, [Online].
Available:
http://www.cse.org.uk/advice/advice-and-support/
how-much-electricity-am-i-using.
[25] P. K. Enumula and S. Rao, The Potluck Problem,
Economics Letters, vol. 107, no. 1, pp. 1012, Apr. 2010,
doi:10.1016/j.econlet.2009.12.011, arXiv:0809.2136v2 [cs.GT].
[26] National Renewable Energy Laboratory, 2014, [Online]. Available:
http://www.nrel.gov.
[27] Nova Scotia Power, 2014, [Online]. Available: http://www.nspower.
ca/.
[28] Southern California Edison, 2014, [Online]. Available: http://www.
sce.com.