2013 19th Asia-Pacific Conference on Communications (APCC), Bali - Indonesia

Programmable Objectification and Instance Hosting for IoT Nodes

Jinhong Yang, Hyojin Park

Yongrok Kim, Jun Kyun Choi

Department of Information and Communications

KAIST
Daejeon, Korea
sunupnet@kaist.ac.kr, gaiaphj@kaist.ac.kr

KAIST Institute for IT Convergence

Daejeon, Korea
kimyolo@kaist.ac.kr, jkchoi@ee.kaist.ac.kr

AbstractWith the spread of Internet of Thing end device, the

usage of multiple devices with internet connectivity is
increasing. However the methodology that can effectively
interconnect the data or integrate the services being executed
on individual things is scarce. One way to solve this problem is
converting the things into the flexible virtual objects. In this
paper, a method to generate an IoT node into a programmable
object form is introduced. In addition, Instance Hosting
System and its structure that can service the objects as micro
instances are provided. Functionality of the proposed system
has been confirmed via realization of Instance Hosting
Gateway in an Access Point environment. Through this
research, the method on how to effectively and efficiently
manage number of IoT nodes is suggested.
Keywords-IoT; programmable objectification; micro instance
hosting

I.

Figure 1. Object and instance generation of IoT nodes

INTRODUCTION

In this paper, followed by the background in section II, a

technique of generating programmable object of IoT node is
proposed in section III. Then, the system architecture of the
proposed Instance Hosting System that hosts those instances
of the virtualized objects is described in section IV. In
section V, the implementation of the system that confirms
the functionality by directly materializing it in a wireless
access point is depicted. After discussing the relevant
existing research in section VI, we conclude this paper in
section VII.

In the study area that studies how to connect various realworld things into the internet and use them as in forms of
virtualized objects (Virtual Object); known as the IoT
(Internet of Things)/WoT (Web of Things) researches are
being conducted [1]. Especially from fields like lifestyle
machines, healthcare, home-security, there is an increase in
the usage of devices (IoT nodes), which the users can be
connected onto internet easily with gadget, sensor, and
actuator functions.
The majority of the IoT nodes that are being released
currently in the market offers monitoring function on the
sensed information and control function through the Web or
Apps. To supply the corresponding functionalities, an IoT
node should contain the Web server function within the end
device itself or provide a structure that has the ability to be
managed and controlled via online Web service. Under this
silo-style service environment, when the number of IoT
nodes that consumers use increase, following two problems
emerge: (1) difficulty of managing individual services, (2)
limitation of forming mutual linkage between IoT node data.
One way of solving these issues is virtualizing the real
world things into programmable objects. As depicted in the
Fig 1, the virtualized object is required to represent both the
attributes and methods of the real world thing. When the
object is executed and running on the target environment, it
is called as an instance of the object. The instances of IoT
nodes are event driven and micro size, compared with
conventional web service hosting.

978-1-4673-6050-0/13/$31.00 2013 IEEE

II.

BACKGROUND

Assuming our house where various IoT nodes, necessary

for a family, can be formed by products from different
manufactures or providers. In this case, the control will be
done via individual IoT nodes respective web sites or
applications. Thus, on the user side, in order to make a call
or control on a node, it is inconvenient to access to their
individual assess route. As the number of IoT nodes
increases, the inconvenience of access and management gets
magnified.
Likewise, in mutual usage of the information IoT node
collects, as individual IoT node has and runs in their distinct
service formats, a hardship raises when interlinking the data
collected by multiple IoT nodes in a user centric
environment. For example, a control sensor that manages a
houses boiler can only have so much information it can
collect all by itself. However, if the range of information the

603

2013 19th Asia-Pacific Conference on Communications (APCC), Bali - Indonesia

sensor can have access to, broadens with other IoT nodes
information, based on information such as existence in
residence, external temperature and time, it can offer more
flexible and customized functionalities to the user[2].
When these problems are pictorialized, according to the
functional structure supply method, as the problems due to
existing IoT node service offer methodology, it is as shown
in Fig 2.
Firstly, Case1s circumstance shows an IoT node
containing Embedded Web Server with the process logic for
data generation and handling, all internally in the end device.
This structure is impossible to supply with services, which
are outside of the provided service domain capability, which
have to interlink or fuse together.
Case2 shows a circumstance where the IoT node
manufacturer or the application service provider supplies
separated Web service online. It is a structure that can offer
all the data generated from IoT node and process logic
required for handling, online. In this case, problems such as;
Web service providers domestic service performance in low
quality; unstable permanency and data privacy leakage may
occur. Especially, in the case of IoT node, there are times
when it directly senses personal information (for example,
health-related, existence in residence). Thus having personal
information being delivered online may incur various user
privacy leakage and security problems.
Figure 3. Overview of the proposed instance hosting system

III.

PROGRAMMABLE OBJECTIFICATION OF IOT NODE

The objectification of IoT node is a necessary procedure

that needs to be undertaken in order to use pre-existing
process logic and data in IoT node as in their open forms. It
is done by creating the profile file, which contains IoT
nodes properties, in XML format that defines the process
information in a script file. Thus from the external
application service environment, using the IoT nodes profile
and process information, it becomes possible to supply with
the corresponding IoT nodes device properties and functions
(process logic). Identically, moreover, it becomes possible to
connect with other objects, such as the process and nodes.
Firstly, it is essential to define an IoT nodes hardware
functions and interface in order to objectify an IoT node and
the IoT Profile is the one that supplies this. IoT Profile is a
XML file that contains the information on the IoT node
manufactured or developed by its manufacturer or developer;
that provides according to the schema standard shown below.
The elements, from data_stream to max_value in the Table I,
are repeated in accordance to the number of IoT nodes
interfaces.
Figure 2. Object and instance generation of IoT nodes

TABLE I.

To address aforementioned issues, we propose a way of

programmable objectification of IoT nodes and an instance
hosting system. Fig 3 shows the overall concept of the
proposed instance hosting system. By doing so, users can
monitor and control them with one integrated access point
and the instances can be easily communicated via Instance
BUS and Instance Manager.

978-1-4673-6050-0/13/$31.00 2013 IEEE

Element
iot_profile
profile

604

IOT NODE PROFILE INFORMATION

Description
Root Tag
It is possible to set multiple profiles onto
an IoT Node Profile
Gets granted an id value by attribute and
it means individual profiles ID

2013 19th Asia-Pacific Conference on Communications (APCC), Bali - Indonesia

url
display_na
me
product_Na
me
product_im
age

description
schema
created
version
creator
process_url
data_stream
or
control_me
ssage
id
name
units
min_value
max_value

When using JavaScript to create IoT nodes

programmable objectification, as suggested in this paper, it
has pros such as easiness of linking with Web Service, which
is the general target, as well as the simplicity of development
due to Scripts characteristic.

URL information that locates the relevant

IoT Node Profile
The representative name for a Profile
from service deploy procedure
Product Label that IoT Node Profile
modifies (IoT Node Name)
Product image that IoT Node Profile
modifies (Provided so that during the
Profile Loading the image information can
also be read)
Description on IoT node
IoT Node Profiles Schema
Created date of IoT Node Profile
IoT Node Profile version
IoT Node Profile Generator
IoT Node Profile and its interlinked
Process URL
DataStream generated by IoT node or the
Controls properties
It is possible to have multiple number of
DataStreams and ControlMessages on one
sensor
Identity value to differentiate Sensor
DataStream / ControlMessage
Name used to differentiate Sensor
DataStream / ControlMessage
Unit the DataStream will make use of
Minimum Value (Signed Numeric value)
Maximum Value (Signed Numeric value)

IV.

SYSTEM ARCHITECTURE FOR INSTANCE HOSTING

In this section, the the instance hosting system

environment, that is used to activate IoT node object as an
instance, is given. Furthermore discussions on the
corresponding softwares functional block structure,
important message process and additional consideration are
specified.
A. Software Functional Block
To provide with these functionality, instance hosting
systems software functional block is structured as the
diagram shown below as Fig 4, and generally the software
blocks position themselves on 3 layers. Each module
provides following functions:
Network Adaptor functional block provides adaptor
functionality that is required for network linkages in forms of
Zigbee, Ethernet, Wireless LAN. Also by using
differentiated message format in accordance to IoT nodes
characteristics, it is granted with Message Parser competence.
Since it is required to be able to change the received IoT
nodes message into a form an instance can use.
Network Handler provides the function that conveys the
message that is received by Network Adaptor to Message
Router that is on Instance Manager.
Instance Manager is the module that has the
responsibility for the central functionality for instance
hosting. It provides environment that directly activates IoT
Node Object as an instance form by deploying IoT Profile
and Process. JavaScript Engine provides an engine that runs
IoT Node Process as instance format that is written as
node.js and JavaScript.
Simple DB provides with the function of saving the
necessary information that is needed by the system. In case
of the Node.js library, when various functions supplied by

The IoT node business logic is in a programmable form

that is written as a JavaScript. IoT nodes business logic
converts into a JavaScripts function to provide with its
functions. The corresponding script file acts as an instance
called from JavaScript Engine. Due to the characteristics of
the script language, it executes as a stateless form and the
function, which is linked with the system, can use the
logging and Open API Triggering functionalities to record
the information of the instance and conduct the external
service calls function.
var api=require("ProcessApi.js")
exports.init = function( key, msg ){
res = msg.split(/[=;:,]/);
api.DataStream.Create(key , 10000 , res[5]);
api.DataStream.Create(key , 10001 , res[7]);
}

Above script shows a simple JavaScript function. In

order to make the logging of external function and data
possible, the function provides with the API the process can
use. Also when a JavaScript, which has init function, runs
API, it receives the necessary key and message it will use as
factors. Inside a function, scripts are structured in a way that
enables; it to extract information according to its own
message format, record or read DataStream via API, or send
out the ControlMessage.

978-1-4673-6050-0/13/$31.00 2013 IEEE

Figure 4. Instance Hosting Software Function Block

605

2013 19th Asia-Pacific Conference on Communications (APCC), Bali - Indonesia

Instance Hosting System are exposed, it provides with HTTP

Server and Service Side Scripting functions.
In case of API Exposure, it provides the function that
exposes IoT nodes information and Log data, which are
collected or generated via Instance Hosting, to a 3rd party
service.
Management Portal provides the user with a web service
form of function that enables the user to directly manage the
Instance Hosting System.
B. Instance Profile Loading and Process Deploy
Procedure
The In these system environments, to maneuver objects
as instances, it is required to load object profile file and
deploy object process file, in JavaScript form, onto Instance
Hosting System and then when IoT nodes message is
received, call the corresponding instance. The following
explains in detail, how the procedure for generating an
Instance proceeds.
Firstly, the reading process of an IoT Profile starts with
obtaining the URL, where the IoT Node Profile is located.
After the system downloads the profile from the URL; and
verifies that the corresponding profile has no peculiar factors
by using XML validation; it registers the nodes general
information, including DataStream and control information,
into the system.
Process Deploy procedure begins with reading the
process URL, that is included in the profile information, and
downloading the process file from online in the same step as
the Profile itself. Afterwards procedures are validation
procedure of the downloaded script file and Deploy
procedure of the process file onto the system. The Deploy
procedure consists of interlinking process of the
corresponding processs input/output information with the
system. In case of the input parameter of the process, the
DataStream information; that is the data message from the
node that will be used as the parameter; is mapped with the
process information and is registered at the Message Router.
In case of the resultant value of the process, which is the
output parameter, it inserts the output value into the
ControlMessage, of the connected node, as the input
parameter. Through these two procedures the basic operation,
that can combine the received message from the IoT node
with the process that can treat the corresponding message,
gets completed.
C. Node Message Parsing and Instance Calling Process
The system should be able to parse the message received
from an IoT node and deliver it to the interconnected
Instance as parameters.
The explanation about the procedure of processing the
received messages from various IoT nodes is shown in Fig 5.
This procedure is undertaken via a Network Adaptor, but
before that, whether the corresponding device is registered or
not, by using the MAC address gets verified. During this
procedure, if the device is unregistered, it is registered
temporarily as Unknown IoT node and is asked whether it
is a newly registered device through the user management
portal. If it was previously registered, the message parsing

978-1-4673-6050-0/13/$31.00 2013 IEEE

Figure 5. Message parsing procss

information of the corresponding device is read and the

message is parsed. Afterwards, the Network Adaptor judges
whether a complete set of messages have been received and
if not, it registers onto the Message Queue and then when the
message receiving is complete, parses the message to the
Network Handler.
After the message parsing, the Network Handler
forwards them to the Message Router and the Message
Router calls process as portrayed in Fig 6. When the parsed
message arrives, Message Router saves logs and performs

Figure 6. Message router process and instance processing process

606

2013 19th Asia-Pacific Conference on Communications (APCC), Bali - Indonesia

the lookup stage of the destination Instance, where the

received message needs to be delivered, before conveying
the corresponding message as the input parameter of the
Instance. According to the operation processs needs, the
Instance calls external APIs or generates ControlMessages
and terminates after logging the process resultant values.
Figure 8. Network Adaptor Message Parsing

V.

IMPLEMENTATION
Dependent on this result, it is possible to request Instant
Manager to run the corresponding process. Then the Instant
Manager issues the corresponding process a key that will
enable it to use the API, then runs the init function with the
received message as the factor.
In the screenshot below, it shows the Network Handler
and Instant Managers communication procedure with the
Network Adapter and how the Process API module handles
the request when an API call within a running process comes
in.

Proposed instance hosting function realization has been

performed on ASUS RT-N16 device with the following
hardware properties: 450MHz clock, RAM 128MB, Flash
32MB + additional USB 1Gb Mount, and the IEEE 802.11
interface.
Firstly, the reason for progressing Instance Hosting
function in the AP environment is, because of the simplicity
of the support from the Wireless Network WLAN
(802.11a/b/g/n) interface. Additionally via USB based
Zigbee (802.15.4) receiver module, its support on the
extended network interface is simple. Also assuming a
general home environment, it was adequate device that has
the computing process that runs at minimum computing
power received and supports the wireless interface that
accommodates the sensor node.
Especially, in case of the Wireless AP, as end devices
such as smart phones, it has taken the role of acting as a
home network interfaces hub in a home environment.
Moreover, it has pros such as its self-supply being high, low
power consumption; despite it is a device of a PC class, and
provides minimum computing power for instance
management.
In case of generating IoT Node Profile, it was undertaken
as shown in the Fig 7 below by using a separate external
Web Service; IoT Node Profile Generator.

Figure 9. Message Handling Procedure

VI.

EXISTING RESEARCH

When comparing the service supply scheme with the

general WoT; instance hosting is most similar to the
computer-mediated structure and it can be seen as a
realization of the corresponding structures computing role
onto the AP. As shown in the Fig 10, it has the form of
providing Local Computer function through the Internet
Gateway Processing Power.

Figure 7. Object and instance generation of IoT nodes

After that, the IoT node process gets executed by

Instance Manager. When a message is being transmitted,
Network Adapter passes on the recipients address to the
Network Handler. The Network Handler checks, based on
the corresponding information, whether the IoT node is
registered or the existence of the process that will be ran. The
Fig 8, screenshot below captured the serial procedure of the
handling of the received message at the Network Adaptor.

978-1-4673-6050-0/13/$31.00 2013 IEEE

Figure 10. WoT service supply structure in form of Computer-mediated

Related discussions and researches on the programmable

objectification of things are being conducted recently from
WoT[3][4][5].
The project named Actinium has studied the
programmable objectification of IoT node[6]. The Actinium
developed RESTful runtime container for scriptable IoT
applications which were executed in individual scripting
sandbox.
In this research, through the distribution of IoT Node
Profile, that hasnt been well provided from existing
researches, it provides a functionality that can effectively do
the description. Moreover, by supplying with a function with

607

2013 19th Asia-Pacific Conference on Communications (APCC), Bali - Indonesia

deploying profile and process, it provides more extensive

object features.
The Ambient Dynamix project developed a Web App[7].
onto an unmodified mobile Web browser; an Android based
Plug-and-Play context framework, the Ambinent Web, in
order to connect various IoT Nodes in Mobile/Web
environments. Through this, the interlocking of content
sources and actuators that is difficult to do in the existing
Web environment is provided. However, for this to work, an
inconvenience follows as the individual sensors and
actuators need to support the OSGi based context plug-in set.
The WoTKit project also aims to interconnect IoT nodes
based on the new Java based framework, called Spring
framework. They provide a development tool to transform
each IoT services into widgets. They focus on the
visualization of the functionalities. [8]
Finally, the objectification of real world materials is
actively studied in the augmented reality area that develops
reference models for objectification. Such works are also
being proceed in global standard bodies including OGC,
OMA, ISO, W3C [9]. However, the IoT node objectification
needs to be focused not only on their properties but also their
functionalities and internal processes and the data streams
they generate. Hence, this area still requires further study.
VII.

[4]

[5]

[6]

[7]

[8]

[9]
[10]

[11]

[12]

CONCLUSION

In this paper, in order to provide the extensiveness of IoT

node data usage and service interlinking from using IoT node,
an Instance Hosting structure has been suggested. Then, it
was implemented in a form as an Instance Hosting Gateway.
For this, a XML based profile and JavaScript based
process composition format, to convert the IoT node into a
programmable object form, were proposed. Furthermore the
Instance Hosting System, as a platform environment, that
can deploy this onto a system then use it as individual
instance, was also suggested.
Through this, by running multiple individual IoT nodes
on an Instance Hosting Gate, the efficiency of management
and the possibility of extension through mutual linkage
between individual IoT node services have been confirmed.
ACKNOWLEDGMENT
This work is partly supported by the "Social M2M
Service Development" funded by Ministry of Science, ICT
& Future Planning (MSIP) and the EU ITEA-2 project 10028
Web-of-Objects (WoO) funded by Ministry of Knowledge
Economy (MKE) and supervised by Korea Institute for
Advancement of Technology (KIAT).
REFERENCES
[1]

[2]
[3]

Atzori, L.; Iera, A.; Morabito, G., SIoT: Giving a Social Structure to
the Internet of Things, IEEE . Communications Letters, vol. 15,
pp.1193-1195, 2011
NEST, www.nest.com
J. Ousterhout. Scripting: Higher Level Programming for the 21st
Century. Computer, 31(3):2330, 1998

978-1-4673-6050-0/13/$31.00 2013 IEEE

608

[13]

[14]
[15]

A. Boulis, C. Han, and M. Srivastava. Design and Implementation of

a Framework for Efficient and Programmable Sensor Networks. In
Proc. MobiSys, San Francisco, CA, USA, 2003.
D. Gordon, M. A. Neumann, and M. Beigl. Demo Abstract: Program
Your Reality with dinam-mite. In Proc. Pervasive, San Francisco, CA,
2011.
Kovatsch, Matthias and Lanter, Martin and Duquennoy, Simon,
Actinium: A RESTful Runtime Container for Scriptable Internet of
Things Applications, 2012 3rd International Conference on the
Internet of Things(IOT), pp.135-142, 2012.
D. Carlson, B. Altakrouri, A. Schrader, AmbientWeb: Bridging the
Web's cyber-physical gap, 2012 3rd International Conference on the
Internet of Things(IOT), pp.1-8, 2012.
M. Blackstock, R. Lea, IoT mashups with the WoTKit, 2012 3rd
International Conference on the Internet of Things(IOT), pp.159-166,
2012.
OGC, Developing a Reference Model for Augmented Reality, 5th
International AR Standards Community Meeting 19 March, 2012
D. Guinard, V. Trifa, and E. Wilde, "A resource oriented architecture
for the Web of Things, " in Internet of Things (lOT), 2010, 2010, pp.
1-8.
D. Guinard, V. Trifa, F. Mattern, and E. Wilde, "From the Internet of
Things to the Web of Things: Resource Oriented Architecture and
Best Practices, " in Architecting the Internet of Things, D. Uckelmann,
M. Harrison, and F. Michahelles, Eds. New York Dordrecht
Heidelberg London: Springer, 2011, pp. 97-129.
D. Guinard, V. Trifa, T. Pham, and O. Liechti, "Towards physical
mash ups in the web of things, " in Proceedings of the 6th
international conference on Networked sensing systems, Pittsburgh,
Pennsylvani, USA, 2009, pp. 196-199.
I. Chatzigiannakis, H. Hasemann, M. Karnstedt, O.Kleine, A. Kroller,
M. Leggieri, D. Pfisterer, K. Romer, C. Truong, True selfconfiguration for the IoT, 2012 3rd International Conference on the
Internet of Things(IOT), pp.135-142, 2012.
ECMA Int. ECMAScript Language Specification 5.1. ECMA-262,
2011.
E. Wilde. Putting Things to REST. Technical Report 2007-015,
School of Information, UC Berkeley, Berkeley, CA, USA, 2007