Monitoring IoT Objects in Wearable Applications: An Alloy-Based Approach

With the rise of Internet of Things, end-users expect to obtain data from well-connected smart sensors and stations. Wearables are lightweight devices that rely on such a data-driven communication to keep people connected for specific purposes (e.g., fire-fighting, health check-up). The state machine of the wearable as a whole is governed by business rules and application logic in the said enterprise context. At a finer level of granularity, the states represented for these wearables could be further refined into the data values of the Internet of Things objects involved. In this paper, we propose an approach to monitoring the states of these objects against the said enterprise rules and the algorithmic logic that are logically expressed in a lightweight, declarative language called Alloy. Our monitoring machinery would detect any abnormal situation where the application logic of the said wearable is violated, allowing an external entity (e.g., a supervising robot, a software agent, a smart device) to step in to take action in due course. We illustrate our techniques using a case-study that describes an Internet of Things solution given to a fast-food restaurant.

I. Introduction

The notion of networked enterprise meets up with the Internet of Things (IoT) as a paradigm shift in computing of late, giving rise to new kinds of enterprise engineering. IoT is becoming a newly-emerging enabling platform for services provisioning and software engineering. This would open the door to another leading software architecture for the next decade, e.g., a counterpart of the so-called -tier architecture in the design of e-commerce Web-based applications [1]. Enterprise engineering in this distributed architecture relies on: (a) software services that are mounted on loosely-coupled IoT devices (e.g., wearable) and machines (e.g., a server); (b) data provisioning enabled by means of IoT smart sensors. Observable enterprise-wise situations in this truly distributed architecture depend in large part on the states of these smart devices and the values of IoT objects that take part in data provisioning. To this end, keeping track of events that trigger the transition of these observable situations is of paramount importance. Of equal importance would be monitoring the IoT objects against rules declared in the application logic and business layer combined. A few techniques and methods have emerged in this realm. To handle the transition of situations in a multi-layer enterprise architecture, we need to handle change propagation [2], i.e, to keep track of how the change of origin could lead to a series of changes all of which need to be materialized in order to maintain the integrity of the said architecture. Event guarding is popular among those who wish to monitor workflows at run-time [3]. Enterprise-wise exception handling aims at specifying what a business process should do when exceptional situations arise, making it derail from a normative model [4]. Programmatically, it is possible to introduce a mechanism to watch state transitions of critical objects at the expense of the system performance [5]. With this being said, tracking rules is crucial for monitoring situations in the above-mentioned IoT-enabled architecture. Should a violation (of rules) occur, for the shake of system integrity, an alert needs to be issued reporting which rule(s) have been violated in what situation, allowing agents and non-human entities to step in when necessary. In today's IoT-enabled systems, smart objects and devices situationally change their states throughout their lifecycle. For instance, an aerator used in smart shrimp farming is supposed to spin at designated speeds. At a fast-food restaurant, customers who have ordered might be given a little device that will vibrate to notify the customers that their meal is ready to be collected. Objects in these cyber-physical solutions get engaged with physical things at run-time. A change of state made to them is physically noticeable, as opposed to that of plain programming objects and software components.