The world contains a large amount of sensors that produce new data at a high frequency. It is currently very hard to find public services that expose these measurements as dynamic Linked Data. We investigate how sensor data can be published continuously on the Web at a low cost. This paper describes how the publication of various sensor data sources can be done by continuously mapping raw sensor data to rdf and inserting it into a live, low-cost server. This makes it possible for clients to continuously evaluate dynamic queries using public sensor data. For our demonstration, we will illustrate how this pipeline works for the publication of temperature and humidity data originating from a microcontroller, and how it can be queried.
Countless sensors that are connected to the Internet produce various streams of continuous
data. Even though there are many sensors, no public interfaces are available which these
measurements can be consumed as dynamic Linked Data [
Dynamic Linked Data can be published through rdf Stream Processing (rsp) query
engines, like c-sparql [
In this work, we present a continuous pipeline for publishing dynamic sensor data
using a low-cost Triple Pattern Fragments (tpf) [
Our continuous pipeline for publishing sensor data consists of a data reader, mapper and
publisher. These components connect a sensor with a dynamic data source, as can be seen
in Fig. 1. The reader receives data from a sensor. The mapper converts this data to rdf
using the rdf Mapping Language (rml) [
For this demonstration, we use a Tessel1 microcontroller to capture sensor data from
the environment. Tessel provides a Node.js2 module that can be used to listen to sensor
measurements from the device using JavaScript events. json objects are emitted for each
measurement at a configurable rate. These objects contain all required data to describe
each measurement.
The mapper component [
{ "humidity" : { "value":47.0815124512 }, "device" : "TM-00-04-f000da30-0062473d-20a82586", "module" : "climate", "temperature": { "value":30.0167749023 } } In order to add semantical value to the measurements, the mapper component maps each json object to rdf.
<http://www.example.com/TM-00-04-f000da30-0062473d-20a82586>
a <https://w3id.org/saref#Sensor> ;
<http://vocab.datex.org/terms#humidity> "47.0815124512"^^xsd:double ;
<http://dbpedia.org/ontology/temperature> "30.0167749023"^^xsd:double .
Next, the triples are time-annotated by the publisher component to make the triples valid
up until a certain time. This is represented with the TriG [
After the data is published, it can be consumed by clients. We use the client-side tpf Query Streamer to continuously evaluate the following sparql query in order to fetch the published measurements from our pipeline.
PREFIX dat: <http://vocab.datex.org/terms#> PREFIX saref: <https://w3id.org/saref#> PREFIX dbp: <http://dbpedia.org/ontology/> SELECT ?temperature ?humidity WHERE { ?sensor a saref:Sensor; dat:humidity ?humidity; dbp:temperature ?temperature.
} This query selects the temperature and humidity data from all sensors. The tpf Query Streamer is able to interpret this query as being dynamic, so it will automatically re-evaluate the query from the moment new measurements become available. The query can for example show the following intermediary result.
Temperature: "30.0167749023"
Humidity: "47.0815124512" These continuously updating query results could, instead of printing it as text, be used as input to various types of applications.
During the demo, we will show the different steps conducted on temperature and humidity data measurements by the different components of the pipeline and the query results. These steps will be shown as continuously updating log outputs for each component. The Tessel microcontroller will be part of the demonstration, this will make it possible for users to modify the temperature or humidity and immediately see the changes in the query output. We recorded a screencast4 containing these live logs for temperature and humidity data. The source code of our pipeline prototype can be found at https://github.com/mmlab/demo-tessel-continuous-datasource.
The demonstration illustrates the simplicity of hosting any kind of sensor data using this technique. For future work, this solution can be improved and extended to support all kinds of sensors and sensor streams. The pipeline could be extended to support composing different pipelines and streams in order to create more complex dynamic data.
With this demonstration we aim to show that publishing dynamic Linked Data does not have to be complex or costly. We hope to trigger more efforts for making dynamic data publicly available, in order to promote the development of more dynamic applications.