Interoperability for the Internet of Things - Eclipse Vorto Toolset
Interoperability (i14y)
Based on multiple research sources over 13 billion devices will be connected up to the end of 2016. An actual statistic says that 5.5 million new devices come online every day. As it is a growing trend, an assumption is that by the year 2020 will be around 38.5 billion total devices in the world and the number of connected devices will reach more than 20 billion (www. gartner.com/newsroom/id/3165317). According to this and similar predictions, the management of many devices with different resources will increase software complexity especially in the area of data (inter)exchange.
At that stage, the Internet of Things can be introduced as the main player referring “Things” to any wire or wirelessly connected object. From the technical point of view, objects are developed from independent components and with the component ability to interact and cooperate freely, safely and semantically interpreted.
From the software architect perspective the interoperability is introduced. It is the degree to which independently developed components exchange the data and share services. To make communication between these elements simple, it is necessary to establish a common language that will be the uniform agreement with each other.
From today’s perspective it can be aggravating due to a large number of different protocols. Software architects and developers would like to have a tool that can help on establishing some sort of translator between different protocols and enable modeling of IoT system in a simple manner no matter what is the individual interpretation language.
Addressing to all previous this article is intended to introduce an open source project that provides technical – software design capabilities for interoperability.
What is Eclipse Vorto
Vorto is an open source toolset from the Eclipse IoT family that provides a language independent description of devices. These simple language descriptions – so called information models (generic descriptions) rely on technology agnostic and abstract device descriptions which help us to manage the attributes and the capabilities of real world devices (characteristics and functionality) using a domain-specific language (DSL).
Due to the large number of standards it is not always easy to create an information model that is an abstraction of the real world. In that direction, a generic support for interoperability by Vorto introduces a Meta information model to avoid technical silos. So created information models are managed by the Vorto Information repository – a REST API which allows integration of all the functions in a final solution. Another very useful feature is the code generator – part of the IoT toolset. Realized as a microservice it has the ability to be once registered and used afterward through the repository. In other words this means that the information models shall be converted into different formats as well as executable platform specific code available to the user via REST interface (describe once – integrate anywhere).
Eclipse Vorto with the above described components enables the interaction of IoT system stakeholders:
- Device manufacturers – device descriptions (information models) which enables various devices to interact and integrate with different platforms
- Vendors of IoT platforms – simple platform specific Vorto code generator that helps in transforming device descriptions into formats required for an integration into a specific platforms (large variety of smart devices in the market),
- Solution developers – during process of the device integration into specific platforms solution developer need to write a lot of code. Vorto reduces development efforts with overtaking most of the generation job scenarios.
Source: https://www.eclipse.org/vorto
With this mechanism Eclipse Vorto Toolset can implement interoperability in an IoT system architecture as a runtime quality attribute and can be provided at design time, build time or runtime.
By using the Vorto toolset, manufacturers are able to provide a generic description of their devices, share via repository and easily integrate into different vendor platforms.
How to – simple project example
The best way to describe the principle of interoperability and have a closer look is a practical example. In this case, a simplified IoT scenario is used with no abstraction or determination levels of general scenario but two base elements of well-formed scenario (stimulus and response) shall be mentioned.
Assume the following requirement:
Local producers of chemical substances possess a machine for automatic filling. In the previous period some faults occurred which were hard to be examined as the system had no monitoring. The customer request is to obtain a web application that can monitor some parameters as improper operation may cause malfunctions.
Let’s assume the technical department introduces the following IoT sensors:
- Noise
- Vibration
- Temperature
- Voltage
- Pressure
Furthermore the hardware/technical department will provide operating parameters (generic descriptions) for the mentioned sensors.
The first step of the solution is the creation of the information model based on the generic description.
Vibration sensor:
Property
| vibrations | float, valid: samples per second | 50 |
| duration | float, valid: number of seconds | 10 |
| threshold | int, valid | 100 |
| sleep mode | boolean |
Functions
| vibrations | get: deliver current sample value |
| sleep | set: puts the sensor to sleep |
The grammar of the DSL is based on the meta information model and need to fulfill also a datatype declaration section. Datatype represent reusable entities that can be shared between function blocks.
|
1 2 3 4 5 6 7 8 9 10 |
namespace com.novatec.example.fillingmachine.unit version 1.0.0 displayname "Vibration" description "Type for Vibration" category demo enum VibrationUnit { NUMBER_OF_SECONDS "10", SAMPLES_PER_SECOND, THRESHOLD "100" } |
Additional to this Java enum the entity itself is introduced:
|
1 2 3 4 5 6 7 8 9 10 11 |
namespace com.novatec.example.fillingmachine.entities version 1.0.0 displayname "VibrationEntity" description "Type for VibrationEntity" category demo using com.novatec.example.fillingmachine.unit.VibrationUnit ; 1.0.0 entity VibrationEntity { mandatory samples_per_second as float with {measurementUnit:VibrationUnit.SAMPLES_PER_SECOND} "Number of the samples per second - sensor sampling rate" mandatory treshold as double with {measurementUnit:VibrationUnit.THRESHOLD} "Treshold value" } |
On the similar way the Datatype section needs to be declared for all other components.
Such formalized descriptions are the base for the DSL function block that has to be created with Eclipse Vorto Toolset. A function block provides an abstract view of a device to which functionality is application addressed.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
namespace com.novatec.example.fillingmachine.fb version 1.0.0 displayname "VibrationSensor" description "Function block model for VibrationSensor" category demo using com.novatec.example.fillingmachine.unit.VibrationUnit ; 1.0.0 using com.novatec.example.fillingmachine.entities.VibrationEntity ; 1.0.0 functionblock VibrationSensor { status { mandatory currentVibration as VibrationEntity "the current vibration value" mandatory sleep as VibrationUnit "the sensor is in sleep mode" } events { currentVibration { mandatory value as VibrationEntity "propagates the current vibration value" mandatory threshold as VibrationEntity "the sensor threshold" } } operations { getCurrentVibration() returns VibrationEntity "deliver current sample value " } } |
Like for the Datatypes also for all other components (Sensors) functional blocks need to be created.
With completing all of functional blocks and the related entities the final information model can be created. Eclipse Vorto simplifies this step. In the initialized information model simply by drag-and-drop functional blocks, the estimated information model will be created.
The next step is code generation. This step is about generating platform-specific code for both functional blocks and information models. There are several ways to do this:
- Via the Eclipse Vorto Toolset
- Via the Vorto Repository
- Via the Vorto CLI Tool
The first option is selected – the Eclipse Vorto Toolset. Generating code is now quite easy. For this demo Web UI Generator is selected among the other listed. It will generate necessary Java web application code.
Switching to Eclipse Java perspective the generated code can be reviewed, updated and deployed.
Generated application is ready to use. It has a Maven nature and it can be deployed as web application with Jetty Maven Plugin mvn jetty:run.
Instead of the conclusion…
This part was the short introduction to the principles of interoperability and how it can take place in the Internet of Things using Eclipse Vorto Toolset. In the next part it will continue with creating, sharing and re-using Vorto Information Model Repository.
Recent posts
Comment article