Managing Distributed Networked Appliances
in Home Networks
Madjid Merabti, Paul Fergus, Omar Abuelma’atti
Heather Yu
Charlie Judice
School of Computing and Mathematical Sciences Panasonic Information and Networking School of Science, Technology
Liverpool John Moores University, Liverpool, UK.
Technologies Laboratory,
and Engineering, Monmouth
Email: {M.Merabti, P.Fergus,
Princeton, NJ, USA
University, NJ, USA
O.E.Abuelma’atti}@ljmu.ac.uk
Email: heathery@research.panasonic.com Email: cjudice@monmouth.edu
Abstract – In recent years, with the growth of home appliance
usage and the Internet, networked devices have become more
widely used in more diverse applications than ever before. This
widespread adoption will require new and novel platforms to
abstract the difficulties associated with the exploitation of devices
and help overcome the inherent limitations associated with
bespoke development. New platforms will need to harness the
interactions between devices allowing emergent behaviour to
surface, whereby high-level applications are created from lowlevel compositions. Combining the devices we own to create new
applications or provide services is challenging and there is a need
to reduce the cognitive demands placed on specialists and home
users alike. This will allow for better exploitation of devices and
provide obvious benefits to the end user. In this paper we present
a novel framework for managing devices and their services within
home environments. Our approach provides a new perspective
and we demonstrate the applicability of our approach using a
working prototype to implement an intelligent home
environment.
off, thus optimising and reducing water consumption and
costs.
Researchers suggest that this transition mirrors the
evolutionary process undertaken within personal computing
and wide area communications, where it is now difficult to
imagine using a computer without Internet access. Given the
success of this transition, home networking platforms aim to
achieve the same level of acceptance. Figure 1 illustrates what
such an interconnected home environment might look like.
Home Appliances Network
Keywords:
Networked
Appliances;
Multimedia
Services;
Interoperability; Dynamic Service Composition, Self-adaptive
middleware.
I.
INTRODUCTION
Networked devices have revolutionised the way we access
and disseminate information and changed the way we
communicate with each other. More and more homes are now
Internet-enabled as people from all walks of life embrace this
technology because of the benefits it brings. These include
shared Internet access; file and peripheral sharing; voice over
IP; and online gaming. As this trend continues, we can expect
ordinary everyday appliances to become part of these
networks, and networked devices will become pervasive and
often invisible to users. At the simplest level, this means lights
will switch themselves on when someone enters the room.
Looking further ahead, home appliances will automatically
integrate, configure and manage themselves, to form high-level
applications. For example, garden sprinklers may be
networked to form close relationships with humidity sensors
and real-time weather readings received via the Internet to
make decisions on whether sprinklers should be turned on or
Fig. 1 Connecting Home Appliances
Through the widespread adoption of networked appliances,
new and novel platforms will emerge to abstract the difficulties
associated with device exploitation. New platforms should
overcome the inherent limitations associated with bespoke
development and provide mechanisms that allow users to
easily create new and innovative applications. Typically, the
thought of integrating the devices we own, is somewhat
challenging and there is a need to reduce the cognitive
demands placed on specialists and home users alike. This will
allow for better exploitation of devices and the functions they
provide. It will enable users to operate devices without
burdening them with management and integration tasks.
Increasing the ease with which users are able to operate the
devices they own will produce obvious benefits. But this raises
some important questions. Most notably, how can users
interoperate all the devices they own without incurring
management costs or locking them into inflexible proprietary
solutions? In the short-term we may choose to outsource the
management of our home networks to third party providers.
However the long-term challenge is to develop a suitable
framework that allows devices to automatically integrate and
manage themselves within home networks without third-party
registration.
We propose a framework whereby heterogeneous devices
and services seamlessly interoperate. The framework has a
number of advantages over current approaches. First, it allows
devices and services to be interconnected and uniformly
addressed. Second, it allows the operational capacity of
devices to be dispersed and automatically integrated within
applications using ontologies. And third, it allows devices to
self-adapt to environmental changes. The following will be
discussed to demonstrate the applicability of the proposed
framework. Current research initiatives within networked
appliances and home networking; our proposed framework; an
intelligent home environment case study; the prototype used to
evaluate the proposed framework; and our conclusions and
future work.
II.
NETWORKED APPLIANCES AND HOME
NETWORKING
A number of home networking solutions have been
developed to try and get devices to seamlessly interoperate.
Some approaches adopt an end-to-end solution for
personalised value-added audiovisual services. Others take a
broader view and try to manage the complexity associated with
combining embedded systems with the Internet. As the
proliferation of devices and services becomes more ubiquitous
and as home networks form part of the Internet, finding and
composing devices will become paramount. The trend is to use
syntactic descriptions based on attribute-value pairs. However,
several approaches are investigating how ontologies could be
used to describe and discover devices more accurately.
Bringing this all together different management approaches
have been adopted. Many utilise the benefits of set-top box
technologies whereas ad hoc approaches are used to equip
devices with plug and play capabilities. In the remainder of
this section some of the most common initiatives are
discussed.
The ePerSpace project [1] aims to provide an end-to-end
solution for value-added audiovisual services. In this
framework services are distributed, via open access networks,
based on the details defined in personalisation profiles. This
allows content and devices to be dynamically adapted to
specific users. Using a trusted and interoperable framework
devices are interconnected allowing them to be controlled by
content creators using rich media object management tools.
The approach taken by ePerSpace is somewhat restrictive
because the primary focus is on interoperability between
audiovisual services. Although, this is important, their solution
does not provide mechanisms to address all aspects of device
and service interoperability. We address this limitation within
our framework by allowing any type of service, including
audiovisual services, to be accommodated, using open
standards. This is important because it provides a platform on
which any service functionality can be deployed and
interoperated.
Devices are becoming more pervasive and to accommodate
this the Reconfigurable Ubiquitous Networked Embedded
Systems (RUNES) [2] project is trying to provide a platform
that allows a larger number of devices to form part of the
Internet. To support such environments it aims to manage this
integration, thus providing users, designers and programmers
with the flexibility to interact with services, devices and
sensors. It promises to deliver a platform to enable the
formation of large-scale, distributed, heterogeneous network
systems that can interoperate and dynamically self-adapt to
environmental changes.
This approach is dependent on well-defined languageindependent component metamodels, bound to service
interfaces. This allows interoperation and self-management of
components through the composition of metamodels.
Discovering and composing these metamodels allows
underlying services to be executed to provide high-level
functionality. Whilst this provides a solution, proprietary
metamodel and interface construction is somewhat restrictive
because RUNES dictates how applications must be developed.
A better alternative would be to allow different device
manufacturers to describe metamodels and interfaces using
their preferred vocabulary. Although, this approach is highly
flexible, it nonetheless provides a basis for increased
innovation. This is an approach adopted within our framework
where device and service compositions are guided by
ontologies. Consequently, ad hoc services can be plugged into
our system without constraining how metamodels or interfaces
are defined. This improves component discovery, composition,
execution and management by reasoning over the “what” part
of the composition rather than the “how”.
In support of this, advances within the Semantic Web
community have been adopted [3], where researchers are
trying to use ontologies to describe, infer and better target
required content. In this approach ontologies, linked through
merging or alignment, are used to formally describe services
[4-7]. The Semantic HiFi project [8] has incorporated these
advances to try and address the limitations associated with
attribute-based audio processing, where interoperability is
achieved using libraries, semantic description schemes,
specifications and guidelines. Rather than focusing on
composing networked appliances, this project uses semantic
descriptions to process raw content. This technique could be
utilised within our framework to better process multimedia
data.
Clearly, flexible device management will liberate the user.
However, this is only true if all devices are included. The
Digital Living Network Alliance (DLNA) [9] suggests that
interoperability must be between devices that reside within
three domains: the Internet, broadcast and mobile. DLNA
advocates that the key to successful integration is to address
customer demands where the devices they own work together
within and across these domains. From a technical perspective
DLNA argues that this requires design choices constrained
through industry consensus to enable better interoperability.
They state that current open standards are too flexible and
consequently interoperability between different vendors fails.
As such, standards in conjunction with proprietary
manufacturing may reduce the time taken to deliver products
to high-street stores.
Like ePerSpace, DLNA only
addresses basic
interoperability. Their approach could be incorporated into a
larger framework to provide a base solution, however
mechanisms are still required to effectively manage devices. It
advocates the use of open standards and its underlying
interoperability mechanism is based on Universal Plug and
Play (this standard is discussed later in this section). This
provides a good foundation. However, it is heavily reliant on
IP and as such binds devices to specific addressing schemes.
Although IP is seen as a de-facto standard capable of spanning
different physical media, its sole use could exclude some
devices. To overcome this limitation a unified addressing
scheme is used in our framework capable of mapping devices
to any underlying communication protocol. This allows
devices to interact without having to change their original
configurations and provides an additional level of flexibility
not provided by DLNA.
Some researchers believe that open standards, constrained
by proprietary manufacturing, bring products to market much
quicker. However, it is difficult to ascertain how successful
proprietary solutions will be until products have been released.
A product called iReady [10] tries to counteract this
uncertainty by interconnecting devices using separate data
communication components. iReady provides standards for
different network adapters, which are dependent on the data
exchanged within and across different networks. They claim
their approach is flexible, because device manufacturers do not
have to develop, market and sell existing products separately
from network-enabled ones. Users that require network
connectivity simply buy the associated adapter.
Their approach is however restrictive since interoperability
is addressed by adapting hardware configurations. It is the
user’s responsibility to manage iReady devices because no
mechanisms are provided to automatically achieve this. This is
not conducive to decreasing the cognitive demands on users.
By abstracting this complexity our framework can
accommodate iReady products and manage the operational
functions they provide with little or no human intervention.
Building on the existence of power lines that already exist
within the home, the Consumer Electronics Powerline
Communication Alliance (CEPCA) [11] have defined a highspeed power line communication (PLC) standard. This
provides an interface between different devices using electrical
power lines for audio, video and data networking. The alliance
is trying to convince consumer electronics manufacturers and
the information technology sector to collaborate, with device
interoperability over power lines as the driving force. The
consortium suggests that bi-directional PLC is a
communication channel capable of supporting home
networking using existing electrical power lines installed in
home environments to enable high-definition video
transmissions and IP telephony.
This is said to reduce the costs associated with home
networking. However, the approach is restrictive since
hardware modules need to be implemented on every device
before they can be used in a PLC network. Like iReady, our
framework can support PLC-based products and provide
mechanisms to manage them. This is not the primary concern
of CEPCA.
Unlike CEPCA, the Open Services Gateway Initiative
(OSGI) [12] assumes network-enabled devices and in-home
networks already exist. Using set-top box technologies,
networked appliances are interconnected and controlled. This
approach has considerable industrial and academic backing
from device manufacturers and service providers alike. Its
mission is to create open specifications that enable the delivery
of multiple services over Wide Area Networks (WANs) to
home networks. The framework incorporates three entities: the
service and network provider, the services gateway, and the inhome network. Service providers enable the provision of value
added services to the residential customer via the services
gateway. Service operators manage and maintain the services
gateway and its services, whilst network providers offer the
necessary network infrastructure to enable communications
between the services gateway, the gateway operator, and the
service provider.
OSGi adopts a centralised approach and as such it suffers
from the same problems, i.e. central point of failure and
scalability. Although our framework can operate under
centralised topologies, its core infrastructure uses peer-to-peer
technologies. This provides a decentralised scalable approach
that allows a greater number of devices and services to
redundantly co-exist without forcing them to register with any
third-party. Building on the success of file-sharing
applications, devices and the functionality they provide are
shared between all interconnected devices. This allows devices
to form part of a larger network irrespective of where they
reside and with global scope in mind.
In contrast to centralised approaches, ad hoc networking
standards for home networking are beginning to realise the
benefits peer-to-peer technologies might bring. In these
networks devices are seen as the centre of the information
space, where functionality is received from within a device’s
immediate vicinity. The AMIDEN [13] project builds on this
concept by allowing devices to disperse the functions they
provide as independent services. A standard with considerable
support that adopts this notion is Universal Plug and Play
(UPnP) [14]. Devices are automatically discovered,
interconnected and controlled within local area networks, thus
extending the auto-configuration features of device Plug and
Play (PnP). It achieves interoperability by leveraging existing
mature standards currently used by the Internet, such as IP,
HTTP and XML. It provides mechanisms that can use existing
addressing schemes such as DHCP and AutoIP functions best
suited to ad hoc networking.
Like many other standards discussed, AMIDEN and UPnP
provide mechanism for interconnecting devices. They also
address an important requirement, that of exposing device
functionality as independent services. However, they both fail
to automatically manage devices. This is seen as a key
requirement within our framework where devices are not just
interconnected but also managed.
This section has presented numerous systems trying to
address interoperability. However, they are all somewhat
restrictive. Despite what these approaches claim, they do not
completely solve all interoperability concerns. In the following
section we present our proposed framework and discuss how
using a flexible middleware solution can address many of the
issues introduced. The framework we propose is novel and
shows how new perspectives can be applied to device
interoperability; function utilisation; ontology usage; and
device and service management.
III.
NETWORKED APPLIANCE SERVICE UTILISATION
FRAMEWORK
It helps to begin by defining what a networked appliance is.
Several definitions exist; consequently it is difficult to provide
a clear and decisive description of their key characteristics.
Form a hardware perspective, Moyer et al. [15] define
networked appliances as “a dedicated function consumer
device with an embedded processor and a network
connection.” Whilst we agree with this definition, we define
networked appliances as devices that disperse their operation
capacity as independent services that can be discovered, and
used by other networked appliances in the network (LAN or
Internet) to control, monitor, manage and extend the
functionality they support beyond what they were initially
designed to do.
Our approach, based on service-oriented computing, builds
on this definition. It allows devices to implement a small
footprint of code enabling framework and application specific
functions to be dispersed within the network. Using framework
services, devices can connect to the network using any
underlying communication protocol; discover and/or publish
and use framework and application specific services locally
(on the device itself) or remotely (provided by other devices);
perform semantic interoperability between different
vocabularies used by device manufacturers; automatically
form communication links with other devices in the network;
and self-manage their operations based on composite and
environmental changes. Application specific services, on the
other hand, provide a means of dispersing and utilising device
functionality (such as audio and video).
Devices connected to the network rely on three key
characteristics. First, they provide access to framework and
device functionality using services. Second, devices
automatically form communication links with other devices in
the network based on the functions they provide and the
functions they require. Third, devices manage communication
links and self-adapt to unforeseen changes that occur within
the environment, e.g. increased network traffic. The proposed
framework allows high-level applications to be automatically
created through device interactions. This reduces the cognitive
demands placed on users, who are free to interact with devices
without having to define how applications are created
beforehand.
A. Interconnecting Devices
There have been many proposed solutions to interconnect
devices. Whilst centralised approaches have become
commonplace new research initiatives are trying to utilise ad
hoc technologies such as peer-to-peer networks. Building on
these approaches devices typically intercommunicate with
each other using proprietary communication protocols. These
can be somewhat restrictive and alternative approaches suggest
that using open standards provides greater flexibility. The
proposed framework presented in this paper draws from the
successes of these different approaches to ensure that
flexibility, scalability, and innovation are firmly embedded
within the architecture.
Using ad hoc networking principles the framework avoids
the inherent limitations associated with centralised approaches.
Whilst overcoming the restrictive nature of proprietary
solutions is achieved using open standards and ontologies to
more accurately describe, discover, and compose devices. The
remainder of this paper explains how these techniques have
been incorporated within the framework and highlights the
novelty of our approach.
B. Device Interoperation
The networked appliance service utilisation framework we
propose provides a middleware that operates between devices
and the application layer, as illustrated in Figure 2. All
communication between applications and devices, including
intercommunication between devices, passes through the
framework. When a device is connected to the network it does
four things. First, it either publishes the framework services it
implements and/or discovers and uses framework services
provided by other devices (the reason for this is discussed
later). Second, it publishes any application specific
functionality it provides (e.g. Audio and Video). Third, it
forms relationships with other devices and services within the
network (for example, a media player may form a relationship
with a speaker because it processes audio data). Forth, it selfadapts to connections between devices and services, including
environmental changes that may occur.
Services are dynamically discovered by propagating
messages within the network using peer-to-peer technologies.
As messages pass through the framework they are decomposed
to extract two pieces of information. First, the capability model
used to describe device capabilities. Second, the service
capability model used to describe the functionality the device
requires.
Application Layer
Networked Appliance Service
Utilisation Framework
Network Layer
Network
Layer
appliances or as simple networked appliances as illustrated in
Figure 3.
Here a specialised networked appliance has the ability to
host services, store and evolve semantic information used to
describe and discover services, as well as propagate service
requests within the network. A simple networked appliance by
definition does not have these capabilities. This type of device
joins the network, propagates queries and invokes discovered
services. This enables any device irrespective of its
capabilities, to effectively choose how it will interact within
the network.
Figure 3 illustrates two extremes – devices that are highly
capable and those that have limited capabilities. However, it is
envisaged that there will be a myriad of other possibilities
between these extremes.
Devices
Fig. 2 Proposed Framework
Message serialisations are constrained within the
framework (this is discussed in more detail later), but not the
vocabulary used. Each device uses a local ontology (a means
of semantically representing a domain of interest) to describe
the device and the functions it provides. Device ontologies are
evolved using the framework to understand the vocabularies
used by other devices. In this sense, ontologies are used to
perform semantic interoperability (a means of linking terms
using semantic relationships). When messages are received
they are processed in line with descriptions used by devices to
describe their capabilities and the functions they provide. Any
ambiguities between different vocabularies are resolved using
the device’s domain ontology.
Devices automatically connect to the network without
having to register themselves or the services they provide with
any third party. When a device is switched on it has the ability
to automatically integrate itself within the network and publish
the functions it provides by multicasting service
advertisements. Each advertisement has a time-to-live value
that expires after a given time period – advertisements have to
be periodically re-published to keep the service alive. Devices
may remove themselves and the functions they provide from
the network at anytime or completely fail in some cases. In
these instances service advertisements are no longer republished and are eventually purged from the network. Once
an advertisement has been removed from the network the
device or service no longer exists.
The framework achieves this using the distributed semantic
unstructured services manager [16], which is the primary
component every device must implement. This is a peer-topeer interface that can be mapped onto any middleware
standard, such as JXTA, RUNES, OSGi or UPnP. Devices
connect to the network as either specialised networked
Fig. 3 Distributed Semantic Unstructured Services
The distributed semantic unstructured services manager
marshals all communications between applications and devices
within the network. It also provides the adaptation functions
used to monitor communication links between the device and
any relationships it has with other devices. When devices
initially join the network they try to discover devices they have
relationships with. For example, a multimedia player may try
to discover audio and video devices capable of processing the
audiovisual streams it generates. By propagating messages
describing this required functionality, responses are received
and stored on the device.
By managing references to external services, devices can
adapt to changes that occur. For example, if the user requests
the multimedia player to begin playing a movie, it instructs the
best audio and video devices it has previously discovered to
begin processing the streams it outputs. The collective
operation of all devices forms a high-level application. During
its execution each device monitors its own interaction within
the composition and adapts to any changes that may occur. If
the audio speaker for some reason becomes unavailable, the
player detects this change and automatically selects an
alternative device (a previously discovered device – note
devices that provide the same functionality can redundantly
co-exist).
conditions or composite conflicts. This is achieved using the
semantic interoperability and signature matching service [17].
Each candidate device found has a corresponding device
capability model that describes how well the device can
execute the functions it provides (this is discussed in more
detail in the following section). Each candidate device is
processed and a comparison is made between the different
capability models to ensure that the next best device is
selected. For example a mobile phone and a plasma television
both have visual capabilities. However, the plasma screen will
be selected rather than the mobile phone, ensuring the device
that provides the best quality of service is used. Nonetheless, if
the mobile phone is the only device available then it will be
used.
Devices provide one or more services by publishing
advertisements within the network. Service ontologies [18] are
used to describe each service, which are embedded within
these advertisements. Service ontologies are also used to
describe service requests, which are matched against service
ontologies. Figure 4 illustrates the service ontologies used and
describes the relationships that exist between them.
The primary component, discussed in the previous section,
allows devices to implement and host, or remotely bind to,
framework services. These are called secondary services.
Secondary services extend the primary component
functionality and allow devices to dynamically compose
application specific services, such as audio and video;
automatically resolve terminology differences between
vocabularies; and assess device capabilities. The framework is
not limited to these services, but rather has the ability to
accommodate any new functionality that may be required as
the framework evolves. This is a mechanism that is not
supported by any other solution. In the remainder of this
section each of the secondary services that comprise the
framework is discussed.
A. Dynamically Composing Devices
Networked appliances require management techniques to
automatically integrate and adapt high-level applications. For
example, when a networked-enabled media player is connected
to the home network, it automatically advertises its services
and forms relationships with all visual and audio devices, such
as TVs and Speakers, connected to the network. Underpinning
the dispersed operational functionality, management services
are used to enable devices to react to adverse environmental
1
Process Model
Service
1
Supports
IV. SECONDARY FRAMEWORK SERVICES
1..*
Provides
When compositions are executed, devices also monitor the
arrival of new devices within the network. For example, if a
mobile phone is being used to view a video stream and a
plasma television registers itself on the network, the player
compares the capability model provided by the plasma
television with the capability model for the mobile phone. In
this instance the player determines that the plasma television
provides a better visual experience and instructs the mobile
phone to stop processing the stream. The plasma television is
then instructed to take over this processing. This localised
detection of changes forms the self-adaptation mechanism
within our framework allowing high-level applications to be
continually adapted based on composite and environmental
changes that occur. This describes a simple example. However,
the same principles can be used by any device or application
scenario.
1..* Presents
1
Describes
1
1
Device
Device
Grounding
1..*
Profile
Fig. 4 Service Ontologies
The Service Ontology describes information about the
service, such as the service provider. This ontology contains
references to the Service Profile, Service Process Model and
the Service Grounding, which collectively describe the
service’s capabilities [18]. Service descriptions are described
at an abstract level in terms of Inputs, Outputs, Preconditions,
and Effects (IOPEs) [18]. The IOPEs defined within the
ontologies form explicit relationships between the Service
Profile, Service Process Model, Service Grounding and the
Service Interface. Using ontologies, mapped onto low-level
interfaces, helps independent services offered by devices to be
accurately matched and dynamically composed without any
human intervention.
This allows functions provided by networked appliances to
be discovered and composed to create high-level functionality
as illustrated in Figure 5. For example, by discovering all the
audio services in the network, and using a microphone
provided by either a laptop or a camcorder, services can be
combined to create a virtual intercom system.
Devices and services are composed by matching IOPEs
defined in the service request with those defined in the service
ontologies. A number of techniques can be used to determine
whether two IOPEs match using the device’s domain ontology.
One possible match occurs when any two IOPEs are equivalent
as illustrated in Figure 6. In this example the Precondition
‘Real-time’ in the service request is equal to the Precondition
‘Real-time in the service ontologies. Another possible match
can be achieved via subsumption. For example an Input in the
service request may be called ‘Movie’ and an Input in the
service ontologies may be called ‘Film’ – if ‘Movie’ has a
‘subclass’, ‘superclass’ or ‘equivalent’ relationship with ‘Film’
then a conceptual relationship has been found that links the
two terms together. In this instance, Figure 6 shows that the
device’s domain ontology contains an equivalentTo
relationship that links the two terms together. Consequently,
these terms can be used interchangeably.
Digital Camcorder
DistrES Ontology
Thing
subClassOf
subClassOf
equivalentTo
Picture
subClassOf
SVCD
Abstract matches are used to find concrete matches. These
matches occur if the IOPEs in the service request can be
directly mapped onto concrete bindings in the service
interface. The Service Profile [18] is processed and the values
associated with each IOPE are retrieved. These values specify
which ‘Atomic Process’ each IOPE belongs to in the Service
Process Model [18]. The IOPEs may have been matched at an
abstract level however they could belong to different atomic
processes. Therefore, the framework determines if a single
atomic process exists, that supports all the IOPEs in the service
request. If so, the operation name is extracted from the Service
Grounding [18] along with the parameters, parameter order
and endpoint address from the service interface. Signatures are
created from this information and used to bind to and execute
the required service.
subClassOf
subClassOf
MP2
subClassOf
MP3
1. SERVICE REQUEST
Input: [Movie svcd]
Output: [Movie vcd]
Precondition: Real-time
Effect: converted
DV
VCD
4. getRelationship(Movie, Film)
SISM
Manag.
Terms that cannot be related are passed to the distributed
emergent semantics service [19] (discussed in more detail in
the following subsection). This service tries to evolve the
device’s domain ontology to include possible relationships that
link the terms together, (this does not necessarily mean a
relationship exists because in most cases terms will be
unrelated). Depending on the result, terms will either be
semantically related or marked as unmatched. If all the IOPEs
in the service request are matched with IOPEs in the service
ontologies this constitutes an abstract match. When abstract
matches are found, the device retrieves all the service
ontologies [18], along with the service interface and creates a
table containing the matched IOPEs from the service request.
The matched IOPEs act as keys in the table and have
corresponding values, which represent the names of the IOPEs
used in the service ontologies. This process is important
because the service request and service ontologies may refer to
semantically equivalent IOPEs differently – the table of keyvalue pairs creates a semantic mapping between the different
terms used.
MPEG-1
subClassOf
SeCEn
Film
subClassOf
MPEG-2
subClassOf
subClassOf
DVD
Fig. 5 Dynamic Service Compositions between Devices
equivalentTo
Movie
5. equivalentTo
(Movie, Film)
3. Service Request,
Service Profile
SISM
6. Get Service
Ontologies
7. Extended
Interface
Service
Ontologies
2. SERVICE PROFILE
Input: [Film svcd], Output: vcd
Precondition: Real-time, Effect: Converted
DVD Player
SeCEn
SISM
Manag.
SISM
Profiles
DistrES Ontology
Picture
Service
8. Extended Interface
Fig. 6 IOPE Matching
Devices can form compositions between devices or
services either directly or indirectly. For example in Figure 7
‘DVD Player 1’ reads the data from an inserted movie disk.
The ‘Player’ service discovers that the media format is ‘Xvid’,
which it cannot process because it only has an MPEG-2
decoder. ‘DVD Player 1’ tries to resolve this conflict using an
intermediary service, which takes as input an ‘Xvid’ data
stream and generates an ‘MPEG-2’ output stream.
Reformulated service requests are propagated in the
network describing the IOPE requirements. ‘DVD Player 1’
finds ‘DVD Player 2’, which can indirectly stream an Xvid
movie into an ‘MPEG-2’ media format using a service
provided by a Laptop. ‘DVD Player 2’ uses the Laptop to
convert the’ Xvid’ format into a ‘DivX’ format, which it can
process and convert into an ‘MPEG-2’ stream. ‘DVD Player 1’
is not aware of the composition between ‘DVD Player 2’ and
the Laptop and is only concerned that ‘DVD Player 2’ can
successfully convert the ‘Xvid’ data into ‘MPEG-2’.
This is achieved using an extended interface metadata
object. It describes how signatures are constructed and
indicates whether the intermediary service itself can be directly
invoked or whether it also requires intermediary services. This
process allows services to dynamically discover and resolve IO
conflicts that may occur and proactively establish
compositions with intermediary services. This may result in
several candidate services that provide the same functionality.
Services that best match the device capability requirements
defined in the service request are added to the extended
interface metadata object.
DVD Player 2
DVD Player 1
DistrES Ontology
DistrES Ontology
SISM
Manag.
SISM
Profiles
EI Table
SeCEn
SISM
Manag.
SISM
Service
Request
Profiles
SeCEn
EI Table
CS Metadata
CS Metadata
1. Xvid
MPEG-2
Codec
Player
Service
8. MPEG-2
9. MPEG-2
Television
6. Divx
EI
Service
2. Xvid
10. Binary
5. DivX
Laptop
4. DivX
EI
Service
EI Table
Profiles
SISM
Manag.
3. Xvid
EI Table
CS Metadata
DistrES Ontology
SISM
EI
Service
Visual
Service
Service
Response
DivX to
MPEG-2
7. MPEG-2
Xvid to
DivX
CS Metadata
DistrES Ontology
SISM
Profiles
SeCEn
SISM
Manag.
SeCEn
Fig. 7 Dynamic Service Composition
The extended interface (EI) service, illustrated in Figure 7,
is invoked when a service provided by the device does not
directly support a method invocation. This service has a fixed
operation name called ‘EI’ which takes two parameters – the
first parameter is the extended interface metadata object and
the second parameter is an array containing all the parameters
required to invoke the service. This service processes the
extended interface metadata object, which provides
information about the operation name for the intermediary
service, the parameters it takes, including the associated data
type information, and the order in which the parameters appear
in the signature.
If the connection mode is ‘direct’ the extended interface
service uses the metadata for the intermediary service to
construct the required signature using the parameters in the
array, before binding with it and executing the required
method. In this instance ‘direct’ means that device A can
directly use a service S1 provided by device B without having
to use any intermediary services. If the connection mode is
‘composite’ the extended interface service processes the
extended interface metadata object for the intermediary service
it needs before connecting to its extended interface service and
passing it the metadata and the parameters. In this instance
‘composite’ means that device A indirectly uses a service S1
provided by device B via service S2 provided by device C. This
process continues until a ‘direct’ connection with a service in
the composition is made.
Using these techniques, service interfaces can be evolved
over time to accommodate inputs they were not initially
designed to process. For example a DVD Player that only
implements an MPEG-2 decoder can read a number of
different media formats and interact with the ‘Visual’ service
using data adaptation services as described above.
B. Managing Distributed Device Ontologies
Networked appliances provide zero or more functions. For
example, a television offers visual and audio functions, as well
as terrestrial communication channels. Discovering and
utilising these functions within and across different networks
presents a significant problem. Although proprietary
communication protocols are commonplace, it is clearly
becoming apparent that alternative approaches are required to
discover resources more accurately. One approach is to use
ontologies, often described as a shared understanding of some
domain [20]. Formally describing domains within our
framework allows devices to achieve better communication
and interoperability.
Typically, ontologies are managed by centralised
consortiums where agreements have to be reached on what
information an ontology should contain and how it should be
described. This is subjective and difficult to maintain. In order
to provide a more efficient approach, the collaborative peer
nature of the framework is used, allowing devices to
automatically evolve ontologies. This facilitates devices by
extending and/or reifying concepts they already have.
Furthermore, it allows devices to understand different
vocabularies used by other devices. Coupled with peer-to-peer
technologies and the principles of general consensus (what the
majority believe to be true), our approach moves away from
centralised ontology management. It provides a scalable
approach that treats each device as a self-contained knowledge
node, where, through interactions and self-management
algorithms, global ontologies emerge. This is achieved using
the distributed emergent semantics service [19].
Devices initially have knowledge to support the
vocabularies used to describe their own services. However,
over time they are extended to include those used by other
devices. Devices propagate queries containing concepts they
wish to evolve, within the network. Queries are processed by
devices and used to query local ontologies to determine if
concepts exist. Any concepts found are extracted along with
any dependents and associated relationships and returned to
the querying device. This may result in several responses,
containing subjective ontological structures that lead to
structural and possibly lexical variations between all responses
received. To accommodate this, structural patterns
(commonalities found within all ontological structures) are
extracted and used to produce an optimal structure that
captures the general consensus (what most devices believe to
be true).
Figure 8 illustrates a subset of a device’s ontology (C1) and
three responses (R1 – R3). This represents the results the
device has received from the network after a query has been
propagated. It is clear that although structurally R1 – R3 are
different, commonalities exist within all structures. For
example, given the nodes “Movie” and “MPEG2”, the
framework determines that these nodes are common by
calculating the number of times they occur in all structures. In
this instance both nodes appear in all four structures, therefore
they will appear in the optimal structure. In contrast the nodes
“Film”, “VCD”, “DVD” and “MP3” are low scoring nodes
because each node appears in one structure only. These are
classed as low-scoring nodes and the probability of them
appearing in the optimal structure is reduced.
Using two fitness functions [19], nodes and relationships
are extracted and used to build the optimal structure. The
higher the fitness function the more specific the extraction
process is. In contrast, the lower the fitness function the more
general the optimal structure will be. Setting fitness functions
is dependent on a number of factors, such as accuracy, concept
size and processing time. For example, a mobile phone, which
is processor and memory restrictive, will set its fitness
functions high to ensure that less common information is
excluded. This is assuming that a mobile device would
explicitly implement the distributed emergent semantics
service (devices with limited capabilities may choose to use
such services remotely).
be obtained by specifying that the optimal binary vector must
have the top n nodes and the top n relationships. For example,
if the nodes and relationships in C1 are used, as illustrated in
Figure 8, the following vector, ordered based on fitness, will
be produced.
[1,1,1,0,0,0,0,0,1,1,0,0,0,0,0,0,0]
The first eight bits represent the nodes and the last nine bits
represent the relationships. The position of the bit is important
because it corresponds to particular word representation. For
example, a word version of the above vector may be as
follows:
[Movie, MPEG-2, MPEG-1, SVCD, Film,VCD,
DVD, MP3, Movie|MPEG-2, Movie|MPEG-1,
Movie|VCD,
Movie|Film,
Movie|DVD,
Movie|MP3, MPEG-2|SVCD, MPEG-1|SVCD,
MPEG-1|MPEG-2]
If a value of one is in the third position then this means that
the structure has a node called “MPEG-1”. Furthermore, if a
value of one is in the fifteenth position this means the structure
has a relationship between the node “MPEG-2” and SVCD.
For illustrative purposes the “Result” structure in Figure 8 is
generated by using the top four nodes within the vector of
nodes found and using the top three relationships. This means
that the optimal structure, given these rules, would be as
follows.
[1,1,1,1,0,0,0,0,1,1,0,0,0,0,1,0,0]
Fig. 8 Statistical Pattern Extraction Engine
The first fitness function places all the unique nodes, found
in the device’s current structure (C1), and in the responses
received (R1 – R3). These are placed into an array. Each node
is given a fitness value based on the number of times it appears
within all structures. This is called term frequency. For
example, the node “Movie” is given a fitness value of four
because it appears in all structures. The second fitness function
places all the unique relationships that exist between any two
nodes and places them into an array. Again, the fitness value
for each relationship is calculated based on the number of
times a relationship occurs in all structures. In this paper we
have only shown that two fitness functions are used, however
the distributed emergent semantics service can accommodate
any number of fitness functions to improve the evolution of
ontologies. This is the focus of future work.
Once a list of ranked nodes and relationships has been
created, they are used to produce a binary vector. Each
position in the vector represents a node or relationship. The
vector is used to convert all the structures where a value of one
in the structure is placed in the vector based on the presence of
a node or relationship in that structure. Optimal structures can
Optimal structures are used to evaluate each individual
structure to determine how fit each structure is. For each
matching bit in the vector the structure’s fitness value is
incremented by one. With the optimal vector illustrated above
we can say that an optimal structure has been obtained when a
given structure has a fitness value of 17.
There are several ways of obtaining the optimal structure.
Simple statistics could be used or feedback loops could be
used to evaluate how successful compositions are. Our
framework currently provides functions for statistical analysis
and genetic evolution. However in the latter case the user is
required to input the optimal structure required. Future work
aims to investigate how this could be automated using device
compositions and the feedback loop technique described
above.
Optimal structures are merged with the device’s local
ontology. This process begins by extracting the nodes from the
optimal structure and checking whether they exist in the
device’s local ontology – any nodes that don’t are added. Once
this is complete the process is repeated for all the relationships
that exist between nodes in the structure. These principles
allow the framework to manage semantic information within
and across all devices connected within the network, where the
collective knowledge provided by all devices is seen as a
distributed ontology.
This technique is novel because it utilises peer-to-peer
technologies and the principles of general consensus rather
than centralised ontology management. However, it is not
reasonable to suggest that all aspects of ontology evolution can
be addressed. For example we only consider the nodes and the
relationships. However, ontologies also consist of properties
and instances [19]. Nevertheless, we show that our approach
can apply new perspectives to distributed ontology evolution
and semantic interoperability. It illustrates how simple
taxonomical structures can be constructed and evolved over
time to enable basic semantic interoperability [19].
resource the service request deems important and compares it
to the device capability model defined in the service request.
This is achieved using a technique called the Multi-Attribute
Utility Theory (MAUT) [22, 23], which produces an overall
capability score for some device D given the attributes defined
in the device’s capability model. This formula is defined as,
C. Selecting the Best Devices to Compose
where DCScore is the overall capability score for device D
according to the device capability model DCM, d is the
number of capabilities for the type of device, cwi(DCM) is the
importance rating of attribute i according to the device’s DCM,
and D(vi) is the status rating for attribute i. The importance
rating describes how important a given attribute is in relation
to all the attributes used, e.g. the CPU attribute may be the
second most important attribute with an importance rating of
30, which means that the CPU is considered three times more
important than an attribute with an importance rating of 10.
The status rating describes how well the device supports a
particular attribute, e.g. a device may have “Excellent” for its
CPU attribute, which may equate to a value of 75.
Home environments may contain many devices that offer
the same functionality. For example, a plasma television and a
video-enabled mobile phone are both able to process video
information. However, the quality of these services will differ,
i.e. a plasma television is considered better equipped to process
high definition video rather than a mobile phone.
Consequently, selecting and composing devices is dependent
on quality of service and application specific requirements. To
address this, our framework allows devices to be selected
based on how well they can execute a service [21]. Metadata
models are used and dynamically generated when service
requests are received from within the network. Each model
contains information about each resource the device
manufacturer deems important.
Several steps are performed to assess a device’s
capabilities. First, the device’s current computational load and
the additional load required to execute the required service are
calculated. By adapting existing approaches [22, 23] the
formula defined in (1) is used to calculate the quality of a
required resource, where a resource r offers a service s that
requires acs, r units of some total resource value trr.
resc s ,r =
ac s ,r
tr r
(1)
This formula determines what proportion of some resource
will be used given the total value of the resource available. For
example, if a service requires 1 megabyte of RAM and the
device provides a total of 32 megabytes, then the service is
said to require 3.1% of that total.
In parallel, the framework determines if a device is
overloaded by calculating the amount of a particular resource
the device uses. For example, if the device has 75% CPU
utilisation the device may struggle to take on the increased
computational overhead if the service is executed. Determining
what constitutes a device being overloaded is application
specific. For example, if the service is a transcoding service,
the application may state that CPU utilisation should be no
more than 10% because transcoding is processor intensive.
Conversely, a service that processes simple commands such as
“Light switch on” may require nominal computation thus a
device that has 75% CPU utilisation could accommodate the
additional computational overhead without any adverse effects.
Quality of service may also be affected through shared
computation. The framework calculates the overhead for each
d
DCScore( D, DCM ) = ! cw i ( DCM ) " D(v i )
i =1
(2)
Given the two formulas, the device’s operating system
calculates the service ratings programmatically by estimating
the average attribute values and assigning the appropriate
status ratings. For example, if the device uses on average 25%
of its CPU when the required service is executed, the operating
system may assign the CPU_Load a status assessment of
“Excellent” with a status rating of 75.
The equation in (3) amends the MAUT formula to take into
account the current resource load and the load required to
execute a service. In this instance the DCScore and the rescs, r
are multiplied to give a combined resource load value,
indicating whether the device can effectively execute a service
it provides.
d
DCScore( D, DCM ) = # cw i ( DCM ) " D(v i ) " (1 ! resc s ,r )
i =1
(3)
When the formula in (3) is used to calculate the score for
the device capability model, it is compared with the score
generated for the device capability profile. If the device
capability model score is equal to or greater than the score for
the device capability profile the device is said to be capable of
effectively executing the service, whilst ensuring the quality of
service is maintained. In this instance the service details are
returned to the service requester. Using this technique provides
a rudimentary mechanism that allows devices to proactively
select the best devices and functionality that increase the
overall quality of high-level applications created.
This section has considered all of the secondary services
that comprise our framework and the following section
demonstrates how they can be used in an intelligent home
environment.
IV.
INTELLIGENT HOME ENVIRONMENT
In this section we discuss how our framework can be
implemented. Using the architecture described above, we have
designed a distributed service-oriented platform for use within
an intelligent home environment. In this way we have been
able to: (i) test our design decisions and illustrate how the
framework addresses the limitations with current approaches;
(ii) demonstrate how the operational capacities provided by
devices can be dispersed and better utilised; and (iii) underpin
interconnected devices with management services for selfadaptation.
The demonstration prototype includes four wirelessly
connected computers used to simulate two televisions, a Media
player and two audio speaker systems. The televisions host
video and audio services able to process video and audio data
streams. The Media player hosts a player service for outputting
MPEG-1 multimedia data, and the audio speaker systems host
audio services able to process audio data streams.
When devices are initially switched on they perform three
tasks. First, they publish the services they provide. Second,
they try to discover devices within the environment they have
a relationship with (for example the Media player tries to
discover devices capable of processing audio and video
streams outputted by the player.) Third, they monitor the
communication links they have with other devices and selfadapt to changes that occur. Using the simple control interface
illustrated in Figure 9, users can discover, use and control any
device in the network including the services it provides.
Users select device and service capability models to
describe the quality of service factors the device must support
and the service functionality required. This is achieved using
the interface illustrated in Figure 9. These models are
serialised as XML and appended to service requests before
being propagated within the network using the “Send Query”
button. Discovered services are added to the “Services” list
box. Any dependency services are added to the
“Dependencies” list box. For example the player service
discovered in Figure 9 has four dependency services: two
audio and two video (these were automatically discovered
when the device was initialised.)
The dropdown box directly under the “Services” list box
contains all the commands that can be sent to the player
service. These are extracted via the service ontologies, from
the service interface (WSDL file). Any of these commands can
be selected and sent to the device using the “Send Command”
button. For example, selecting “play” and pressing the “Send
Command” button results in the player streaming audio and
video data to the “audio” and “video” dependency services.
Fig. 9 Framework User Interface
The prototype demonstrates how devices self-adapt when
exceptions occur within compositions. When the user sends a
“play” command, the player instructs the audio speaker system
and the television to begin processing the media streams sent
from the player. For demonstration purposes the current audio
speaker system was removed from the network, whilst a movie
was being played. This conflict is detected by the media player
and a previously discovered audio service is instructed to begin
processing the audio data. The disconnected service was then
reconnected to the network. The media player sensed this
change and compared the device capability model for this
speaker system with the device capability model for the current
speaker system being used. It discovered that the newly
published speaker system provides a better auditory experience
than the speaker system currently in use. The media player
instructed the current audio speaker system to stop processing
the audio stream and instructed the newly published audio
speaker system to begin processing the audio stream. This
functionality was also successfully tested on the video
services.
Rather than using a centralised monitoring service, devices
are empowered to monitor the local connections they have
between other devices and services they use. This allows
management to emerge through low-level changes making our
approach highly scalable.
A. Technical Details
We have adopted a multidisciplinary approach whereby
several tools and standards have been combined to implement
our framework. This is not simply an integration exercise, but
rather a novel approach that provides a new perspective on
seamlessly interconnecting devices. The primary component
and all secondary services that comprise the framework have
been developed using the JXTA protocols [24]. These
protocols allow any device to be connected to the network
independent of platform, programming language, or transport
protocol. Framework services are predetermined and each
device understands how to discover and invoke them. Bindings
between devices and secondary services are achieved using
pipe advertisements. Specific secondary services use the same
pipe advertisement. This ensures that devices do not
continually create and publish new advertisements each time
the device is connected to the network. This minimises
discovery overheads and ensures that advertisement caches do
not inflate over time. All secondary services have been
developed in Java and implemented within the service layer of
JXTA. This is a necessary step that extends JXTA and utilises
the mechanisms already provided by JXTA to manage how
services are dispersed.
Application specific services are used to expose device
functionality. Many functions may exist, consequently pipe
advertisements used are not known by devices beforehand. As
discussed in this paper, service ontologies describe device
functionality by mapping high-level semantics onto low-level
service interfaces. This is achieved using OWL-S [18]. This
standard is also used to describe service requests (serialised as
Service Profiles). This extends the service discovery
mechanisms in JXTA. Using matching algorithms we
developed, IOPEs in the service request are matched with
IOPEs in the service ontologies. Matches result in service
ontologies being returned to the querying device. This provides
an effective mechanism to discover required services.
Devices propagate messages in peer groups using the
JXTA ResolverService protocol. Using ResolverService
listeners devices define the type of messages they are able to
process. We have extended the ResolverService objects to
include additional XML tags relating to device capability
models and service behaviour. A device that receives a
message retrieves the device capability model and uses it to
determine whether the capabilities it supports match or surpass
the actual capabilities the device requires. Device capability
models are serialised using the CC/PP specification [25].
JXTA service advertisements are used to describe highlevel information about services, such as the provider. These
advertisements have been extended to include a Peer ID. The
JXTA Peer Advertisement could have been used, however to
reduce the number of discovery requests, the Peer ID is placed
in the service advertisement. This allows all required
information to be discovered in a single request, thus
minimising network traffic. Using the Peer ID ensures that,
although more than one service may exist of the same type,
devices only bind and use the service initially discovered when
a connection request to that service is made. This guarantees
other pipe listeners will not receive messages destined for
others. The decision to adopt this technique was based on a
number of undesirable results we encountered within earlier
implementations, whereby connection requests could be made
to any pipe at the same time irrespective of the initial device or
service discovered.
The framework is underpinned with semantic annotations.
To address ambiguities between the different vocabularies
device manufacturers use, mechanisms have been developed to
use ontologies as a means of semantic interoperability.
Resolving ambiguities between terms that are syntactically
distinct but semantically related is achieved using an OWL
ontology implemented on the device. The first level of the
ontology for a media processing device is illustrated in Figure
10. This ontology is evolved over time to include ontological
constructs used by other devices. This ensures devices learn
the vocabularies used by different device manufactures.
Local device ontologies are processed using the ProtégéOWL API [26]. This API supports OWL-DL serialisations (a
formally constrained ontology serialisation that can be used by
most reasoners), and is a well developed tool used in a large
number of academic and industrial projects. The Protégé-OWL
Reasoner API [27] is used with the Racer reasoner [28] to
process these serialisations. Jena [29] reasoners were
considered, however a number of performance problems were
encountered. For example when an inferred model was created
using internal and external reasoners, out of memory errors
occurred. Nevertheless, Jena is used to perform simple
querying on OWL-S serialisations. This is achieved using the
ontology models provided by Jena and RDQL [29]. In some
instances it is easier to query RDF serialisations using RDQL
rather than using an inference engine, which can be
computationally more expensive. Furthermore OWL-S
serialisations do not conform to description logics so it is
difficult to load them into reasoners such as Racer.
Fig. 10 First level of Media Processing Device Ontology
Audio and video application services were developed using
Java. Media streams were broadcast using the Java Media
Framework (JMF) and the Real-time Transport Protocol (RTP)
[30]. We developed a conversion service to transcode AVI
encodings into MPEG-1. The JFFMPEG API [31] was used to
perform this transcoding.
Devices and services are managed using the Device
abstract class. Every device instance subclasses this class. The
Device class provides management functions to marshal the
relationships between devices. This is a custom management
component we have developed in Java that uses caching
techniques in conjunction with threaded listeners to monitor
incoming messages. Management services have been
developed to continually monitor and change compositions to
extend and maintain quality of service requirements. This
functionality extends the current version of JXTA to support
zero-configuration and allows devices to self-manage. Using
the tools defined in this section we successfully developed the
working prototype that implements the intelligent home
environment described above.
VI. CONCLUSIONS
It is evident that the number of devices that are networkenabled is increasing rapidly. More and more products are
offering communication functions in a bid to capture market
share. Users require heterogeneous devices to seamlessly work
together irrespective of their capabilities or conventional usage
scenarios. Whilst this brings considerable benefits, little work
is being carried out in parallel to effectively manage how
networked appliances will operate. Our proposed framework
does however move us closer to this vision. It is novel and
shows that we can apply new perspectives to device
interoperability; function utilisation; and device and service
management.
We are still in the early stages of networked appliance
development and not every potentially networked device
currently enjoys networking capabilities. Nonetheless, the area
is expanding and we expect products, such as iReady, to
become more widespread. Inevitably networked appliances
will become commonplace. Whilst there is considerable scope
for research initiatives such as OSGi and UPnP to embrace
these new environments, the rudimentary management services
provided by such services fall far short of those required to
fully benefit from the technology.
Our framework is not designed to replace existing
approaches but to provide a flexible platform on which
different approaches can interoperate. Its real strength relies on
the collaborative interactions between ad hoc devices and the
functions they provide. A technique that has been successfully
applied to other research domains such as peer-to-peer
multimedia networks. By describing and processing semantic
information in large distributed environments, devices can
learn patterns to automatically form explicit relationships with
each other. By harnessing this interaction emergent behaviour
can surface, whereby high-level applications are created
through low-level compositions.
Nonetheless, our approach is in the initial stages and we
acknowledge that more research is still required. Whilst our
working prototype demonstrates it is possible to develop such
a framework, its full effectiveness remains to be tested in a
real-world situation. In particular there are a number of known
issues with our framework. The ontology evolution
mechanisms are problematic – only simple serialisations can
be processed. Security is an issue. Ad hoc environments raise
an important question regarding the trustworthiness of service
providers [32]. Service composition mechanisms require
further research to include better matching algorithms. Feature
interaction [33] is also challenging. Services may operate well
when used in isolation or within small compositions however
problems arise when trying to interwork a large number of
services at the same time.
However, the development of a capable middleware
framework represents an essential step towards solving these
important issues. We believe that we have provided a
foundation for much further work beyond that described
above. This strand of research will become increasingly
important as we see more devices becoming network-enabled.
Our goal is to embrace this new interconnected world and
provide a viable framework to help manage it.
REFERENCES
[1]
[2]
[3]
[4]
[5]
[6]
[7]
[8]
[9]
[10]
[11]
[12]
[13]
[14]
[15]
[16]
[17]
[18]
[19]
[20]
[21]
ePerSpace: Towards the era of personal services at home and
everywhere. 2005, France Telecom, Accessed: 2006, http://www.isteperspace.org/.
C. Koumpis, L. Hanna, M. Anderson, and M. Johansson, Wireless
Industrial Control and Monitoring beyond Cable Replacement. 2nd
Profibus International Conference, 2005, Warwickshire, UK, p.
T. Berners-Lee, J. Hendler, and O. Lassila, The Semantic Web.
Scientific America, 2001. 284(5): p. 34-43.
A. Maedche and S. Staab, Ontology Learning for the Semantic Web.
IEEE Intelligent Systems, 2001. 16(2): p. pp. 72-79.
B. Chandrasekaran, J. R. Josephson, and V. R. Benjamins, What are
Ontologies and Why Do We Need Them? IEEE Intelligent Systems,
1999. 14(1): p. 20 - 26.
A. Doan, J. Madhavan, P. Domingos, and A. Halevy, Learning to
Map between Ontologies on the Semantic Web. The Eleventh
International World Wide Web Conference (WWW2002), 2002,
Honolulu, Hawaii, USA: ACM Press, p. 662--673.
L. M. Stephens and M. N. Huhns, Consensus Ontologies Reconciling the Semantics of Web Pages and Agents. IEEE Internet
Computing, 2001. 5(5): p. 92-95.
M. Jacob, RDF in the Semantic Hifi European project. 1st Italian
Workshop on Semantic Web Applications and Perspecitives (SWAP),
2004, Ancona, Italy, p. 50-54.
DLNA: Overview and Vision. 2004, DLNA, Accessed: October 2006,
http://www.dlna.org/about/DLNA_Overview.pdf.
Home Appliances Get Connected. 2004, Y. Miwa, Accessed: 2006,
http://www.ipv6style.jp/en/netapplnc/20041022/index.shtml.
Consumer Electronics Powerline Communication Alliance (CEPCA).
2005, CEPCA, Accessed: 2006, http://www.cepca.org/home.
The OSGi Service Platform - Dynamic services for networked
devices. 2005, OSGi Alliance, Accessed: 2006, http://www.osgi.org/.
M. Minoh and T. Kamae, Networked Appliances and their Peer-toPeer Architecture AMIDEN. IEEE Communications Magazine, 2001.
39(10): p. 80-84.
UPnP Forum. 2005, Microsoft Corp., Accessed: 2006,
http://www.upnp.org/.
S. Moyer, D. Marples, S. Tsang, and A. Ghosh, Service Portability of
Networked Appliances. IEEE Communications Magazine, 2000.
40(1): p. 116-121.
P. Fergus, A. Mingkhwan, M. Merabti, and M. Hanneghan, DiSUS:
Mobile Ad Hoc Network Unstructured Services. (PWC'2003)
Personal Wireless Communications, 2003, Venice, Italy: Springer, p.
484-491.
P. Fergus, M. Merabti, M. B. Hanneghan, A. Taleb-Bendiab, and A.
Minghwan, A Semantic Framework for Self-Adaptive Networked
Appliances. (CCNC'05) IEEE Consumer Communications &
Networking Conference, 2005, Las Vegas, Nevada, USA: IEEE
Computer Society, p. 229-234.
OWL-S 1.0 Release. 2003, DAML, Accessed: 2006,
http://www.daml.org/services/owl-s/1.0/.
P. Fergus, A. Mingkhwan, M. Merabti, and M. Hanneghan,
Distributed Emergent Semantics in P2P Networks. (IKS'2003)
Information and Knowledge Sharing, 2003, Scottsdale, Arizona,
USA: ACTA Press, p. 75-82.
M. Uschold and M. Gruninger, Ontologies: Principles, Methods and
Applications. The Knowleddge Engineering Review, 1996. 11(2): p.
93-155.
A. Mingkhwan, P. Fergus, O. Abuelma'atti, M. Merabti, B. Askwith,
and M. Hanneghan, Dynamic Service Composition in Home
[22]
[23]
[24]
[25]
[26]
[27]
Appliance Networks. Multimedia Tools and Applications: A Special
Issue on Advances in Consumer Communications and Networking,
2006. 29(3): p. 257 - 284.
R. Kumar, V. Poladian, I. Geenberg, A. Messer, and D. Milojicic,
Selecting Devices for Aggregation. (WMCSA'03) Fifth IEEE
Workshop on Mobile Computing Systems and Applications, 2003,
Monterey, California, USA: IEEE Computer Society, p. 150-159.
J. Liu and V. Issarny, QoS-Aware Service Location in Mobile AdHoc Networks. (MDM'04) IEEE International Conference on Mobile
Data Management, 2004, Berkeley, California, USA: IEEE Computer
Society, p. 224-235.
L. Gong, JXTA: A Network Programming Environment. IEEE
Internet Computing, 2001. 5(3): p. 88-95.
Composite Capability/Preference Profiles (CC/PP): Structure and
Vocabularies 1.0. 2004, G. Klyne, F. Reynolds, C. Woodrow, H.
Ohto, J. Hjelm, M. H. Butler, and L. Tran, Accessed: 2006,
http://www.w3.org/TR/2004/REC-CCPP-struct-vocab-20040115/.
Protege OWL Plugin API. 2005, Stanford University, Accessed:
2006, http://protege.stanford.edu/plugins/owl/api/index.html.
Using the Protege-OWL Reasoning API. 2005, Stanford University,
Accessed:
2006,
[28]
[29]
[30]
[31]
[32]
[33]
http://protege.stanford.edu/plugins/owl/api/ReasonerAPIExamples.ht
ml.
V. Haarslev and R. Moller, Description of the RACER System and its
Applications. International Workshop on description Logics, 2001,
Stanford, USA, p. 131-141.
B. McBride, Jena: Implementing the RDF Model and Syntaxn
Specification. The Second International Workshop on the Semantic
Web - SemWeb'2001, 2001, Hong Kong, China, p. 23 -28.
Java Media Framework. 2005, Sun Microsystems Inc., Accessed:
2006, http://java.sun.com/products/java-media/jmf/.
Codec pack for the Java Media Framework. 2006, JFFMPEG,
Accessed: August, http://jffmpeg.sourceforge.net/index.html.
J. Haggerty, Q. Shi, P. Fergus, and M. Merabti, Data Authentication
and Trust within Distributed Intrusion Detection System InterComponent Communications. (EC2ND'05) 1st European Conference
on Computer Network Defence, 2005, University of Glamorgan, UK:
Springer, p. 197-206.
M. Kolberg, E. H. Magill, and M. Wilson, Compatibility Issues
between Services Supporting Networked Appliances. IEEE
Communications Magazine, 2003. 41(11): p. 136 - 147.