Near Field Communication (NFC) technologies are mature and are meeting the mass market in many application domains. They provide the possibility to automate many processes that had been lacking such features. Museum exhibits are one such case, and have traditionally been static pieces that do not interact with users or provide any additional context. In this demonstration we present an open-source middleware for museology. Our work uses external devices such as media renderers to create an augmented reality environment around visitors to improve interaction and the overall experience from the exhibit, while giving museum management valuable information about visitor behavior. The NFCMuseum middleware is part of the ASPIRE project funded by the European Union and is available for download at the OW2 Consortium website.
Service-orientation enables cooperation between multiple organizations and has become a solution of choice to tackle the complexity of ubiquitous computing. The very nature of ubiquitous applications implies a need for dynamic solutions. Service oriented computing provides support for these dynamic applications. However, current solutions overlook important aspects, particularly when dynamically substituting services. Some applications may be mission-critical and therefore the disruption of a particular service could be harmful. Other applications may tolerate the disappearance of a service if the service returns within a predefined amount of time. Hence, guarantees regarding availability of services that compose an application are required. In this paper we propose to take into account service disruptions through service level agreements for dynamic service-oriented applications.
RFID middleware is a cornerstone of non-trivial RFID deployments in complex heterogeneous environments. In this demonstration, we introduce and present the AspireRfid middleware platform using demonstrators in the area of Supply Chain management and Near Field Communications. The AspireRfid platform provides support for non-trivial RFID applications in several fields including supply-chain management, logistics, access control, asset management and pharmaceuticals. In this demonstration we present a traceability application for logistics and supply chain management, as well as a pick and pack application. AspireRfid implements several building blocks of the EPCglobal architecture. However, it also extends the EPCglobal architecture with several middleware modules, which can greatly facilitate RFID application development and deployment. Hence, prior to presenting the demonstrations, we provide a brief discussion of the EPCglobal architecture and the extensions implemented by AspireRFid. We end-up with an illustration of the demonstrators.
Radio Frequency Identification (RFID) is the generic name given to systems that use radio frequency signals for the identification of objects, animals and humans . In comparison with optical bar scanners, RFID has the advantage of being non-line of sight, automatic and faster (up to hundreds of items per second). RFID systems consist of readers and tags. Readers, which have higher processing capabilities than tags, request and process information from tags. Conversely, tags or transponders have the function of responding to reader’s requests by sending an identification signal and possibly extra sensing information. Active tags are fed by an inboard battery which enhances their reading ranges and cryptographic features at the expense of a limited life-time and higher costs. In contrast, passive tags scavenge their power from the energy radiated by the readers, thus being long lasting and inexpensive but with limited reading ranges and reduced cryptographic features . A common issue of all radio frequency systems is the collision of signals. Collisions in RFID systems arise when two or more tags reply at the same time to a reader request or possibly to another neighbor reader. Therefore, a collision resolution algorithm or multiple access protocol is needed that is adapted to the characteristics and constraints of an RFID system, i.e. tags with limited power supply and processing capabilities, fixed or mobile readers with better processing capabilities than tags, and the existence of bad behaving eavesdropper readers which might attempt to track the identity of the tags. In this paper we concentrate on the possible collisions between tags in a multi-tag environment and not on the collisions between readers that operate in the same frequency band, which is known as the reader collision problem . The related literature is scarce and directed towards typical collision resolution methods , thus ignoring a series of recent developments on random access, e.g. . The objective of this paper is to present a review of these new algorithms, emphasizing those suitable for implementation in passive RFID systems, and to identify algorithms which at the same time achieve high reading rates and the lowest power consumption. Additionally, a description of security issues at the medium access control (MAC) layer is presented by identifying packet collisions as a method to reduce and control unauthorized access to tags’ information, particularly from eavesdropper readers. Details are given later on this paper.
RFID middleware is a cornerstone of non-trivial RFID deployments in complex heterogeneous environments. In this paper we introduce the principal middleware building blocks specified in the scope of the EPCglobal architecture. Alternative protocols and implementation frameworks for realizing these middleware blocks are also presented. At the same time we outline several middleware extensions to the EPCglobal architecture, towards meeting common requirements of automatic identification applications. Furthermore, we classify RFID applications into various categories based on their simplicity, as well as based on their closed or open loop nature. Accordingly, we highlight the middleware blocks that are most important to each application category.
REFiLL: A Lightweight Programmable Middleware Platform for Cost Effective RFID Application Development
Middleware platforms for RFID data filtering and collection tend to be resource intensive, costly and/or provide a low degree of programmability. In this paper, we introduce REFiLL, a lightweight middleware framework that can significantly ease the development of RFID systems. The introduced framework fits within the overall EPC global network architecture as a programmable filtering solution, sitting between the EPC (Electronic Product Code) reader virtualization layer and EPC application level events. Thanks to a set of well defined programming constructs, REFiLL renders application development a task of authoring a set of XML-based files, which are also editable within a visual development environment. Following the presentation of the REFiLL framework, we also describe the process of application development, along with sample prototype applications.
The EPCglobal has recently ratified the EPC-IS standard, which insulates enterprise applications from understanding the details of how individual steps in a business process are carried out. However, few processes are described on the basis of this framework. In this paper, we present an overview of EPC-IS and accordingly leverage its event semantics to formulate the business context for prominent warehouse management (WM) processes. Specifically, we provide a fairly general description of WM business processes in terms of EPC-IS events. These events have been validated and used in the scope of realistic RFID deployments in different enterprises. Based on this experience we believe that these baseline descriptions could serve as templates for a wide range of RFID WM deployments. We also provide insights on how these descriptions could be used in the scope of a wider business process management framework, which could be amenable by graphical tools.
When dealing with dynamic component environments such as the OSGi Service Platform, where components can come from different sources and may be known only during runtime, evaluating third party components trustworthiness at runtime is difficult. The traditional namespace based isolation and the security mechanisms provided in the Java platform (the base platform for OSGi) can restrict the access of such components but can not provide fault isolation. In this paper we present a dynamic component isolation approach for the OSGi platform, based on a recently standardized Java mechanism. When an untrusted component is activated during runtime, it is isolated in a fault contained environment but it can still collaborate with the application. If it is observed that the untrusted code does not bring any threat to the application, at runtime it can be dynamically promoted to the safe environment. Tests have been performed in a controlled environment where misbehaving components hosted in the sandbox were not able to disturb the main application.
Despite the proliferating number of tools and techniques for building RFID applications, their integration with legacy enterprise applications (such as ERP and WMS systems) and corporate databases is still a very tedious task. Integration effort is therefore still a set-back to rapid and cost-effective RFID deployments in non-trivial enterprise environments. In this paper, we introduce a middleware component (conveniently called “Connector”), which abstracts the interfacing of RFID systems with enterprise applications. Our Connector component considers RFID deployments that adopt the EPC Global architecture, i.e. deployments populating RFID events into repositories compliant with the EPC-IS standards. Developers using the “connector” components are offered with handlers for the main interaction messages between EPC-IS repositories and enterprise applications. The paper ends-up presenting the implementation and use of the “Connector” middleware for the interfacing between a WMS system and an EPC-IS repository in the scope of a logistics application. Lessons learnt from this validating case study are also outlined.
Radio Frequency Identification (RFID) is a technology which is spreading more and more as a medium to identify, locate and track assets through the productive chain. As all the wireless communication devices sharing the same transmission channel, RFID readers and tags experience collisions whenever deployed over the same area. In this work, the RFID reader collision problem is studied and a centralized scheduling-based algorithm is proposed as possible candidate solution, especially for those scenarios involving static or low mobility readers.
Taking into account the circuitry limitations of the tags, which do not allow to use frequency or code division multiple access schemes in the RFID systems, this paper proposes an algorithm aiming to prevent the readers collisions, while keeping the access delay of the readers to the channel possibly low. The simulation results show that this algorithm performs well as far as it concerns the collision avoidance also when the mobility of readers is taken into account and it exhibits low access delay especially in static scenarios.
The usage of dynamic languages is increasing among developers. As components are static entities, the usage of scripting languages, which are usually dynamically typed and interpreted, would bring flexibility in the development of components allowing component reconfiguration and adaptation at runtime without needing either to recompile the component code or to restart the application. This paper presents a general approach for creating adaptable components by using dynamic scripting languages combined with component models. This concept has been implemented and validated in two different contexts: in the OSGi platform and in a Fractal-like approach.
High Altitude Objects (HAO), typically sounding balloons, are mobile objects that gather information (e.g. weather data) during their trip and send it to base stations using wireless communication. Once launched, these objects need to be tracked and recovered, and ideally monitored to exploit data in real-time. This paper discusses about middleware and embedded system concerns when monitoring such objects. The architecture that is presented in the following relies on both a monitoring middleware based on a modified RFID suite (part of the OW2 Aspire project, primarily targeting the management of objects in an Internet of Things for RFID-based and sensor-based applications), and on an embedded system (part of the HAO) with multimodal communication capabilities. This approach has been validated by two experiments consisting in a real time monitoring of a sounding balloon. The whole application is generic enough to be used to track and monitor other kinds of mobile objects, including sounding rockets and Unmanned Aerial Vehicles (UAVs).
Exhibit sites, such as museums and commercial conventions, do not usually allow or motivate visitor interaction with the exhibited items. In this work we present an architecture for providing an augmented experience for exhibits. In our concept, visitors can use wireless handheld devices to scan the identifiers (e.g. RFID tags, 2D barcodes) of exhibit items and receive information about them or trigger events in the surrounding environment. We present a generic middleware which is dynamic, extensible and configurable, and is capable of generating different responses to visitor interactions. Responses can consider the visitor’s profile, the exhibit’s or visitor’s history, administrative preferences, and other information. They include sending events to the visitor’s device or to devices surrounding the exhibit. The architecture hides development complexity and takes advantage of various technologies, integrating them into our middleware and our handset application. We also provide administration capabilities, such as reporting and exhibit configuration. Our concept has been implemented and validated in a museum scenario and uses multiple technologies for communication, unique exhibit identification, and software dynamicity and extensibility.
This paper presents an architecture and implementation of a self-healing sandbox for the execution of third party code dynamically loaded which may potentially put in risk application stability. By executing code in a fault contained sandbox, no faults are propagated to the trusted part of the application. The sandbox is monitored by a control loop that is able to predict and avoid known types of faults. If the sandbox crashes or hangs, it can be automatically recovered to normal activity without needing to stop the main application. A comparison between an implementation of the sandbox in a domain-based isolation and operating-system based isolation analyses performance overhead, memory footprint and sandbox reboot time in both approaches. The implementation has been tested in a simulation of an RFID and sensor-based application.
In this paper we present a modular, flexible and extensible RFID middleware architecture. The functionalities needed by an RFID middleware are already well studied; also there exists some standards which define them. We propose an architecture where these functionalities are developed in an event-oriented component model. This provides extra benefits such as loose coupling between components and an easy-to-scale architecture.
Since recently, it is accepted that mediation can take many forms depending on the application domains: for example, mediation can be seen as a means to deal with interoperability between legacy applications in large Information Systems in a variety of environments including Cloud or to synchronize, integrate and route data from sensor networks in pervasive applications. In this paper we present a lightweight, modular, dynamic and distributed framework called Cilia dedicated to mediation. Cilia aims at bringing an homogeneous solution to deal with mediation both in big and little systems and to ensure the seamless integration of the two systems. In this paper we demonstrate the benefits of the Cilia approach through a case study from an RFID project.
Dynamic platforms where components can be loaded at runtime can introduce risks to applications stability if components are not previously known before deployment. It may be needed anyway to execute such untrustworthy code, even if it is not malicious. The OSGi platform presents such a scenario where components can be installed, started, stopped, updated or uninstalled during application execution. In this paper we describe how we introduced dependability and monitoring as crosscutting concerns in the OSGi platform for improving applications resistance to such risks. These concerns crosscut different software layers which are well defined in the OSGi specification but scattered over different places in the OSGi API. We also created a level of indirection by representing software layers as aspects, enhancing the API’s modularity as well as reuse by avoiding redundant pointcut definitions. The dependability aspects helped us validating the layer aspect abstraction reuse. Since the aspects targeted the OSGi API, it was possible to weave our solution into distinct versions of three different OSGi implementations, namely Apache Felix, Equinox and Knopflerfish. We validate our approach on all of the woven platforms in a simulation of an RFID and sensor-based application that uses untrustworthy components.
Over the last few years significant work has been done in defining interfaces, standards, reader protocols and middleware platforms for RFID (Radio Frequency Identification) systems. However, current solutions are mainly dedicated to environments where readers or interrogators are located in the same premises that host the middleware and database servers, thus leaving unattended an accurate analysis of how efficiently to integrate them into wireless mobile telecommunication networks. This is particularly critical in cases where readers need to be placed in geographically distant and mobile locations, and where bandwidth limitations of the underlying public wireless networks might restrict the deployment of certain RFID applications. This paper aims at partially filling this gap by first proposing an approximate and heuristic theoretical model for the effects of the traffic generated by a mobile RFID reader upon the communication links to be used, and then by analyzing the possibilities of integrating readers into known mobile telecommunication technologies. Based on the proposed approximation, basic relationships between different RFID parameters such as reader complexity, tag reading rate and the total utilized bandwidth are here found and discussed. Although the models and assumptions used here still need to be validated and/or adjusted to real system scenarios, it is expected that this work will bring further research on the interesting problem of designing RFID systems, where not only variables from different layers of the OSI (Open System Interconnection) model interact with each other, but many others coming from privacy, security, business and regulatory fields must also be addressed.
With the spread of passive Radio Frequency Identification (RFID) systems, new applications will see the coexistence of more and more RFID readers in the same area. As for wireless devices, also RFID readers experience collisions whenever sharing the same communication channel. In this paper, an anti-collision protocol has been proposed in order to solve the reader collision problem. The aims of the proposed solution are: (1) to prevent and avoid collisions among readers; and (2) to limit the access delay of the readers on the channel, while guaranteeing them fairness with respect to the channel contention. The reader anti-collision here proposed, referred as to High Fairness Reader Anti-Collision Protocol (HF-RACP), has been designed taking into account passive tags and their limitations in terms of computational and frequency selectivity capabilities. In this paper, after presenting the reader collision problem and discussing the simulation models and the evaluation methodology used herein, the simulation results for several anti-collision algorithms are shown in terms of collision avoidance and access delay. The comparison with contention-based schemes, like Listen Before Talk (LBT), demonstrates that HF-RACP is more effective against collisions, improves the fairness among readers and considerably reduces the maximum access delay.
It is widely recognized that applications need to be administered remotely. In general, application management and monitoring is supported by textual management consoles while graphical user interfaces specialized for their tasks are preferred by average users. Defining what must be monitored and what are the admin actions one wants to perform on an application cannot be defined during the application development due to the fact that these needs evolve after the application deployment as we cannot completely predict the execution environment such as available devices. This paper presents an architecture and the corresponding infrastructure that allow administrators to define what they want to monitor and manage and automate the discovery and deployment of corresponding probes and related management console graphical plug-ins. This work has been validated on two different application domains.