As the amount of generated sensor data is increasing, semantic interoperability becomes an important aspect in order to support e cient data distribution and communication. Therefore, the integration of (sensor) data is important, as this data is coming from di erent data sources and might be in di erent formats. Furthermore, reusable and extensible methods for this integration are required in order to be able to scale with the growing number of applications that generate semantic sensor data. Current research e orts allow to map sensor data to Linked Data in order to provide semantic interoperability. However, they lack support for multiple data sources, hampering the integration. Furthermore, the used methods are not available for reuse or are not extensible, which hampers the development of applications. In this paper, we describe how the rdf Mapping Language (rml) and a Triple Pattern Fragments (tpf) server are used to address these shortcomings. The demonstration consists of a micro controller that generates sensor data. The data is captured and mapped to rdf triples using module-speci c rml mappings, which are queried from a tpf server.
In the Internet of Things paradigm, many real-world objects are connected
through the Internet [
Research is being conducted towards making the produced data available as
Linked Data, speci cally as Resource Description Framework (rdf) triples.
Publishing sensor data as Linked Data enables nding other related data and relevant
information, and facilitates interconnection and integration of data from di
erent communities and sources [
In the demo, we will show how these challenges can be addressed. We will
generate rdf based on the sensor data stream of modules connected to a Tessel
micro controller. The sensor data, available as json objects, is mapped to rdf
using the rdf mapping language (rml) [
In this section, we discuss how the two challenges are addressed by using rml mappings and making them available through a tpf server.
Integration of (Sensor) Data We use rml to de ne how sensor data is mapped to rdf triples, because rml supports multiple heterogeneous data sources. Data might come from di erent sensors that each use a di erent data format. The use of di erent solutions for each data format to generate triples requires users to install, learn, use and maintain these solutions. This hampers the generation of triples. Furthermore, the data can come from multiple sensors and other sources. Therefore, a solution is required that allows to integrate multiple data sources at the same time. rml solves these two problems by o ering a declarative way to de ne how data in multiple heterogeneous data sources is mapped to rdf triples.
Rapid Development of Applications We use a tpf server to publish the rml mappings, because this allows applications and users to reuse the existing mappings. The rapid development of applications that need to map (a stream of) sensor data to rdf triples is only possible when existing mapping methods are reusable and extensible. rml mappings can be published using any Linked Data Fragments (ldf) server, because the mappings are expressed as rdf triples. This Linked Sensor Data Generation using Queryable RML Mappings Tessel module (1) data (2) query
Application (3)
RMLMapper (4)
RDF-Based
Application
allows applications to dynamically query the server for sensor-speci c mappings
on-demand. Additionally, when the mappings are updated, these applications
can query for the new version. Subsequently, when new rdf triples are
generated, the new mappings are used. Furthermore, when users need to update or
extend the mappings, they can do so without the need to de ne a completely
new mapping that includes their changes, as opposed to the api provided by
Patni et al. [
Our demo consists of four steps, as shown in Fig. 1. First, the data of a Tessel RFID module is captured by the application as json objects: 1 { "device":"TM-00-04-f000da30-006d4744-20bc2586", 2 "module":"rfid-pm532", 3 "uid":"3c527c00" }
Each object contains the unique id of the RFID card that is tapped on the module. Second, the ldf-server3, an implementation of a tpf server, is dynamically queried for the module-speci c mapping. This showcases the rapid development of applications as developers can reuse the existing mappings. Additionally, the mappings can be cached to improve performance. Besides mapping the sensor data to rdf triples, this mapping also maps the location of the sensor, which is available in an xml le:
This showcases the integration of multiple heterogeneous (sensor) data sources to triples. Third, the mapping is executed by the rmlmapper4, which produces the triples. Finally, they are outputted to the users: 1 @prefix ex: <http://www.example.com/>. 2 @prefix geo: <http://www.w3.org/2003/01/geo/wgs84_pos#>. 3 4 ex:TM-00-04-f000da30-006d4744-20bc2586 a <https://w3id.org/saref#Sensor> ; 5 <http://www.schema.org/location> ex:loc/50_41 ; 6 <http://dbpedia.org/ontology/access> "3c527c00". 7 8 ex:loc/50_41 geo:lat "50"; geo:long "41".
During the demo, users will be able to see the original data stream in the json format, the mapped rdf triples, and the rml mappings, provided by the tpf server. Furthermore, users can update the mappings, and see the changes when new rdf triples are generated. A screencast of the demo can be found at http://users.ugent.be/~pheyvaer/sensor2rdf/. The open source code is available at https://github.com/mmlab/demo-sensor2rdf.