Cyclone DDS: Sharing Data in the IoT Age

Advanced Technology Office
28 rue Jean Rostand
91400, Orsay
France
Angelo Corsaro, PhD
Chief Technology Officer
ADLINK Tech. Inc.
angelo.corsaro@adlinktech.com
AT()
Cyclone
Sharing Data in the IoT Age
DDS

Data is the Currency of IoT
The value of IoT systems is
proportional to their ability to
ubiquitously and timely access data
and use it to derive relevant insights
As reported in the Eclipse IoT
Developer Survey Data collection
has grown to become the second
major concern with an year on year
increase of 50%

Data Sharing in IoT
Data should ﬂow where needed transparently
and independently from the location its source
so to allow for analytics to be deployed/
migrate where it makes the most sense, i.e.
edge, cloud, etc.
Location Transparency

Data Sharing in IoT
Peer-to-Peer and brokered architectures for
data sharing are essential to address the edge
and scale-out
Peer-to-Peer and Brokered

Data Sharing in IoT
Temporal decoupling is an essential property to
build system that scale, thus data production
and consumption should be decoupled in time.
Additionally, historical data needs to be
available for query and non-real-time analytics.
Durability

Data Sharing in IoT
Data-Level security should be provided to
simplify the deployment of secure IoT
systems, while not impacting they scalability
and performance requirements
Security

Data Sharing in IoT
Data sharing standard are a pre-prerequisite
for IoT.
Without standards there is not interoperability,
without interoperability there is not IoT
Interoperability

Cyclone DDS is a standard-based
technology for ubiquitous, interoperable,
secure, platform independent, and real-
time data sharing across network
connected devices

CopyrightPrismTech,2015
DDS is used to integrate and
normalise data sharing
among the various elements
of a smart grid at scale
Duke’s Energy COW
showed how only with DDS
it was possible to distribute
the phase alignment signal
at scale with the required
20ms periodicity
Smart Grid

DDS leveraged to
virtualise I/O and
provide better
decoupling between I/
O, Control and
Management functions
of the system
Smart Green
Houses

The NASA Kennedy Space
Centre uses DDS to collect
the Shuttle Launch System
Telemetry.
DDS streams over 400.000
Msgs/sec
In comparison, world-wide,
Twitter deals with less than
7000 msgs/sec
NASA Launch
Systems

DDS is used to share
Flight Data within and
across Air Traﬀic Control
Centres.
These applications have
extremely high
dependability constraints.
Air Traffic
Control

DDS is used in Smart
Factories to provide
horizontal and
vertical data
integration across the
traditional SCADA
layers.
Smart
Factory

DDS used to control
the 100.000 mirrors
that make up ELT’s
optics.
These mirrors are
adjusted 100 times per
second
Extremely Large
Telescope (ELT)

DDS is used inside
several medical
devices to share data
between the various
stages of data
acquisition, processing
and visualisation
Medical
Devices

DDS is heavily used
for data sharing in
Robotics and is today
at the heart of the
Robot Operating
System (ROS)
Robotics

Why are these
applications using DDS?

DDS PROVIDES AN EXTREMELY HIGH
LEVEL AND POWERFUL ABSTRACTIONS
ALONG WITH A ROCK SOLID
INFRASTRUCTURE TO BUILD HIGHLY
MODULAR AND DISTRIBUTED SYSTEMS

dds makes it much easier to solve some very
hard distributed system problems, such as
fault-tolerance, scalability and
asymmetry

DDS is like a universal glue that allows to
seal together highly heterogeneous
environments while maintaining a single,
elegant and efficient abstraction

AT()
Abstraction
DDS applications
cooperate by
autonomously and
asynchronously
reading and writing
data on a Data Space
that provides spatial and
temporal decoupling DDS Global Data Space
...
Data
Writer
Data
Writer
Data
Writer
Data
Reader
Data
Reader
Data
Reader
Data
Reader
Data
Writer
TopicA
QoS
TopicB
QoS
TopicC
QoS
TopicD
QoS

AT()
Topic
DDS uses Topics to capture
the properties of data
A DDS Topic is domain-wide
information’s class Topic
deﬁned by means of a <name,
type, qos> tuple
DDS Global Data Space
...
Data
Writer
Data
Writer
Data
Writer
Data
Reader
Data
Reader
Data
Reader
Data
Reader
Data
Writer
TopicA
QoS
TopicB
QoS
TopicC
QoS
TopicD
QoS
Topic
Type
Name
QoS

AT()
QoS
DDS provides a rich set
of QoS policies to
express temporal and
availability
constraints of data
...
Data
Writer
Data
Writer
Data
Writer
Data
Reader
Data
Reader
Data
Reader
Data
Reader
Data
Writer
TopicA
QoS
TopicB
QoS
TopicC
QoS
TopicD
QoS

AT()
Dynamic Discovery
DDS has built-in
dynamic discovery
isolates applications
from network
topology and
connectivity details
...
Data
Writer
Data
Writer
Data
Writer
Data
Reader
Data
Reader
Data
Reader
Data
Reader
Data
Writer
TopicA
QoS
TopicB
QoS
TopicC
QoS
TopicD
QoS

AT()
Decentralised Data-Space
DDS data space is
decentralised.
Thus it has no
single point of
failure or
bottleneck
Data
Writer
Data
Writer
Data
Writer
Data
Reader
Data
Reader
Data
Reader
Data
Writer
TopicA
QoS
TopicB
QoS
TopicC
QoS
TopicD
QoS
TopicD
QoS
TopicD
QoS
TopicA
QoS
...
Data
Writer
Data
Writer
Data
Writer
Data
Reader
Data
Reader
Data
Reader
Data
Reader
Data
Writer
TopicA
QoS
TopicB
QoS
TopicC
QoS
TopicD
QoS

AT()
Adaptive Connectivity
Connectivity is
dynamically adapted to
chose the most eﬀective
way of sharing data
Data
Writer
Data
Writer
Data
Writer
Data
Reader
Data
Reader
Data
Reader
Data
Writer
TopicA
QoS
TopicB
QoS
TopicC
QoS
TopicD
QoS
TopicD
QoS
TopicD
QoS
TopicA
QoS
The communication between
the DataWriter and matching
DataReaders can be peer-to-
peer exploiting UDP/IP
(Unicast and Multicast)or
TCP/IP
The communication between
the DataWriter and matching
DataReaders can be
“brokered” but still
exploiting UDP/IP (Unicast
and Multicast)or TCP/IP

AT()
Platform Independent
DDS implementation are
available for an incredible
numbers of platforms,
including enterprise,
desktop, embedded,
real-time, mobile, and
web

AT()
Polyglot
DDS applications can be
written in your favourite
programming language.
Interoperability across
languages is taken care
by DDS

Writing Data in Python
import cdds
import time 
 
if __name__ == '__main__': 
topic = dds.Topic("SmartMeter", "Meter") 
dw = dds.Writer(topic) 
 
while True: 
m = readMeter() 
dw.write(m) 
time.sleep(0.1)
enum UtilityKind {
ELECTRICITY,
GAS,
WATER
};

struct Meter {
string sn;
UtilityKind utility;
float reading;
float error;
};
#pragma keylist Meter sn

Reading Data in Python enum UtilityKind {
ELECTRICITY,
GAS,
WATER
};

struct Meter {
string sn;
float reading;
float error;
};
import cdds 
import sys 
 
def readData(dr):  
samples = dds.range(dr.read()) 
for s in samples: 
sys.stdout.write(str(s.getData())) 
 
if __name__ == '__main__': 
t = dds.Topic("SmartMeter", "Meter") 
dr = dds.Reader(t) 
dr.onDataAvailable = readData

Writing Data in C++
#include <dds.hpp>
int main(int, char**) {
DomainParticipant dp(0);
Topic<Meter> topic(“SmartMeter”);
Publisher pub(dp);
DataWriter<Meter> dw(pub, topic);
while (!done) {
auto value = readMeter()
dw.write(value);
std::this_thread::sleep_for(SAMPLING_PERIOD);
}
return 0;
}
enum UtilityKind {
ELECTRICITY,
GAS,
WATER
};

struct Meter {
string sn;
float reading;
float error;
};

Reading Data in C++
#include <dds.hpp>
int main(int, char**) {
DomainParticipant dp(0);
Topic<Meter> topic(”SmartMeter”);
Subscriber sub(dp);
DataReader<Meter> dr(dp, topic);
LambdaDataReaderListener<DataReader<Meter>> lst;
lst.data_available = [](DataReader<Meter>& dr) {
auto samples = data.read();
std::for_each(samples.begin(), samples.end(), [](Sample<Meter>& sample) {
std::cout << sample.data() << std::endl;
}
}
dr.listener(lst);
// Print incoming data up to when the user does a Ctrl-C
std::this_thread::join();
return 0;
}
enum UtilityKind {
ELECTRICITY,
GAS,
WATER
};

struct Meter {
string sn;
float reading;
float error;
};

Writing Data in Scala enum UtilityKind {
ELECTRICITY,
GAS,
WATER
};

struct Meter {
string sn;
float reading;
float error;
};
import dds._ 
import dds.prelude._ 
import dds.config.DefaultEntities._ 
object SmartMeter { 
 
def main(args: Array[String]): Unit = { 
val topic = Topic[Meter](“SmartMeter”) 
val dw = DataWriter[Meter](topic)
while (!done) {
val meter = readMeter() 
dw.write(meter)
Thread.sleep(SAMPLING_PERIOD)
} 
} 
}

Reading Data in Scala enum UtilityKind {
ELECTRICITY,
GAS,
WATER
};

struct Meter {
string sn;
float reading;
float error;
};
import dds._ 
import dds.prelude._ 
import dds.config.DefaultEntities._ 
object SmartMeterLog { 
def main(args: Array[String]): Unit = { 
val topic = Topic[Meter](“SmartMeter”) 
val dr = DataReader[Meter](topic) 
dr listen { 
case DataAvailable(_) => dr.read.foreach(println) 
} 
} 
}

AT()
Making it Simpler
IDL-less Topic Definition.
This will reduce the need for newcomers to learn about IDL and will reduce the
steps required to get started.
Pluggable Serialisation
Extend the API to allow the use of user-specified serialisers/deserialisers.
First Class State and Event.
Introduce first class concepts for State and Events so that user can avoid
understanding the various QoS.
DDS Browser.
Simple tool to list discovered participants, readers, writers and matches. This will be
quite useful for visualising and debugging DDS applications.

AT()
Networking
TSN Support.
TSN is very important for upcoming Industrial applications and we want
to have this in Cyclone ASAP. Thus thus will be made available in 2018.
Raw Ethernet Support.
The ability to run on Raw-Ethernet is useful for (1) performance and (2)
those cases in which DDS is used to provision the IP network.
ROS2
Replace OpenSplice with Cyclone in ROS2 and try to get eventually
Cyclone as the default implementation.

AT()
DDS Security
We are working on DDS Security for
Cyclone DDS.
This will provide protection against:
• Unauthorised Subscription
• Unauthorised Publication
• Tampering and Replay
• Unauthorised data access [See DDS Security Specification v1.0 p.9]

Open Source Fog Stack
The fogOS uniﬁes the compute,
storage and communication
fabric that spans across things,
edge and cloud infrastructure
It uniﬁes administration,
management and monitoring
end-to-end
Designed to unify Fog and MEC
VM
C
UK C
BE UK
VM: Virtual Machine
C: Container
UK: Uni Kernel
BE: Binary Executable
uS: micro Service
uS
BE
UKUK

AT()
Architecture
fogOS is composed by:
NDN. At its lowest level, it leverages a Named Data
Network (NDN) infrastructure based on zenoh. DDS can
also be used as a transport — not necessarily an NDN
YAKS. A distributed key-value store that leverages the
NDN for scalability
Agent. The core logic of fogOS, it takes care of managing,
monitoring and orchestrating entities through plugins
Plugins. Plugins provide supports for atomic entities, OS,
networks, etc.
DDS | zenoh
YAKS
AgentPlugins
Network
Data Link
Physical
Transport

AT()
Action #1
DDS is still a niche
technology used
mostly in IIoT
applications
MESSAGING STANDARDS - TRENDS
62.61%
54.10%
34.95%
24.92%
22.49%
18.24%
12.77%
6.69%
5.78%
4.86%
4.26%
4.26%
1.52%
0%
10%
20%
30%
40%
50%
60%
70%
2016
2017
2018
Copyright (c) 2018, Eclipse Foundation, Inc. | Made available under a Creative Commons Attribution 4.0 International License (CC BY 4.0). 39

AT()
Action #1
We want to
collaborate with
Eclipse IoT
community to expand
the adoption of DDS
and have this be the
standard-de-facto for
applications that
require peer-to-peer
62.61%
54.10%
34.95%
24.92%
22.49%
18.24%
12.77%
6.69%
5.78%
4.86%
4.26%
4.26%
1.52%
0%
10%
20%
30%
40%
50%
60%
70%
2016
2017
2018
Copyright (c) 2018, Eclipse Foundation, Inc. | Made available under a Creative Commons Attribution 4.0 International License (CC BY 4.0).
62.61%
54.10%
34.95%
24.92%
22.49%
18.24%
12.77%
6.69%
5.78%
4.86%
4.26%
4.26%
1.52%
0%
10%
20%
30%
40%
50%
60%
70%
2016
2017
2018
62.61%
54.10%
34.95%
24.92%
22.49%
18.24%
12.77%
6.69%
5.78%
4.86%
4.26%
4.26%
1.52%
0%
10%
20%
30%
40%
50%
60%
70%
2016
2017
2018
62.61%
54.10%
34.95%
24.92%
22.49%
18.24%
12.77%
6.69%
5.78%
4.86%
4.26%
4.26%
1.52%
0%
10%
20%
30%
40%
50%
60%
70%
2016
2017
2018
62.61%
54.10%
34.95%
24.92%
22.49%
18.24%
12.77%
6.69%
5.78%
4.86%
4.26%
4.26%
1.52%
0%
10%
20%
30%
40%
50%
60%
70%
2016
2017
2018
Copyright (c) 2018, Eclipse Foundation, Inc. | Made available under a Creative Commons Attribution 4.0 International License (CC BY 4.0).

AT()
Action#2
Work with the Eclipse IoT
ecosystem to establish a
platform for fog computing

AT()
References
http://github.com/eclipse/cyclonedds
http://github.com/atolab/fog05
http://github.com/atolab/zhe

Cyclone DDS: Sharing Data in the IoT Age

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a Cyclone DDS: Sharing Data in the IoT Age

Semelhante a Cyclone DDS: Sharing Data in the IoT Age (20)

Mais de Angelo Corsaro

Mais de Angelo Corsaro (19)

Último

Último (20)

Cyclone DDS: Sharing Data in the IoT Age