The document discusses Digital Twin, a key element of Industry 4.0. It provides an overview of Digital Twin including definitions, examples, and the features and capabilities of Eclipse Ditto, an open source Digital Twin platform. Specifically, it allows [1] creation of virtual representations of physical devices through abstractions and APIs, [2] interaction with and modification of Digital Twins, and [3] searching across large sets of Digital Twins through filtering and querying. The presentation aims to demonstrate how Digital Twin technologies like Eclipse Ditto can help implement key Industry 4.0 use cases.

1. © Fraunhofer
Pankesh Patel
Digital Twin: a key element of Industry
4.0

2. © Fraunhofer 2
n Motivation
n Industry 4.0 use cases
n Digital Twin
n State of the art
n Digital Twin technology
n Eclipse Ditto, Features
n Demo
n Summary and Q&A
Agenda

3. © Fraunhofer 3
Deep integration
Image source: https://assets.dm.ux.sap.com/de-leonardolive/pdfs/50982_acatech_v1.pdf

4. © Fraunhofer 4
Service-oriented architecture use cases
Sensor-Service Valve-Service Pump-Service Control-Service Communication-Service
Digital Twin
hardware-independent
Device Control
hardware-dependent
Slide source: https://bit.ly/2ylnEjQ
• Self-organization
• Flexible manufacturing
• Fault tolerance

5. © Fraunhofer 5
n Quality assurance
n Asset maintenance
n early fault detection
n New business model
n Subscription-based
services
Track & Trace
Tech Mahindra Track & Trace : https://bit.ly/2OcAloW
Slide Source: https://bit.ly/2Qe1aX6

6. © Fraunhofer 6
n Reduce downtime, extend lifetime of an asset, increase energy efficiency
n Optimized operational planning and schedule
n Potential business models
n Monitoring services, sensors
n New features and integration offerings over time (new apps, security updates,
subscription based services, cloud-based platforms)
Smart maintenance
ABB Ability smart sensor solutions - source: https://bit.ly/2Q6izB5

7. © Fraunhofer 7
Digital twin and edge computing
HTTP WS
Web
App
Mobile
App
Reference: https://bit.ly/2NvGTzF
Cloud
Service/App
AMQP
Devices
App
Store
Chatbot Market
place
Services
<<Protocol Adapter>>
MQTT
<<Protocol Adapter>>
HTTP
<<Protocol Adapter>>
Custom
IoTSuite

8. © Fraunhofer 8
Let's try to find out if Digital Twin can help
Digital Twin: A key element of "Industry 4.0"
Reference: https://bit.ly/2NvGTzF

9. © Fraunhofer 9
n A digital twin is a virtual representation of its real world counterpart
n Examples : production equipment, production facilities
n Similar terms: "Device shadow" (AWS), "Device twin" (Azure), "Asset administration
shell" (Germany)
n A digital twin
n Mirrors physical devices
n Provides services around devices
n Keeps real and digital worlds in sync
What is digital twin?
Source: https://www.eclipse.org/ditto/intro-digitaltwins.html
Digital twin
Physical device
Image source: https://bit.ly/2O1hkFV

10. © Fraunhofer 10
n Open source technology for implementing digital twins
n The goal is to free IoT solutions from the need of implementing backend services for
devices.
n Focus on business requirements and applications
n Active community
n Chat: https://gitter.im/eclipse/ditto
n Github: https://github.com/eclipse/ditto (commits: 2000+)
Eclipse ditto
Image source: https://www.eclipse.org/ditto/

11. © Fraunhofer 11
n Device-as-a-Service
n Provide a higher abstraction level in form of an API used to work with individual
devices
n providing an API abstracting from the hardware,
n routing requests between hardware and customer apps,
n ensuring only authorized access,
n persisting last reported state of hardware as cache and for providing the
data when hardware is currently not connected,
n notifying interested parties about changes,
Eclipse Ditto Features
Source: https://www.eclipse.org/ditto/intro-overview.html

12. © Fraunhofer 12
curl –u ditto:ditto –X PUT –d '{
"attributes": {
"manufacturer": "ACME",
"VIN": "0815666337"
},
"features": {
"transmission": {
"properties": {
"cur_speed": 90,
}
},
"environment-scanner": {
"properties": {
"temperature": 20.8,
"humidity": 73,
}' 'http://localhost:8080/things/namespace:car1'
n PUT APIs to create a digital twin
n Static metadata (attributes)
n Dynamic state data (features)
n Real-time (fed by sensors)
Abstractions to create a Digital Twin
Image source: https://zd.net/2NZPBoZ l
username password
Thing ID

13. © Fraunhofer 13
n Querying an existing a Digital Twin
n curl -u ditto:ditto -X GET
'http://localhost:8080/api/1/things/car1'
n Querying one specific state value of a Digital Twin
n curl -u ditto:ditto -X GET
'http://localhost:8080/api/1/things/car1/features/tran
smission/properties/cur_speed'
n Updating one specific state value of a Digital Twin
n curl -u ditto:ditto -X PUT -d '77'
'http://localhost:8080/api/1/things/car1/features/tran
smission/properties/cur_speed'
Abstractions to interact with an existing digital twin
Eclipse Ditto HTTP API : https://www.eclipse.org/ditto/http-api-doc.html#/Things
HTTP API Concepts : https://www.eclipse.org/ditto/httpapi-concepts.html

14. © Fraunhofer 14
n The functionality and data is protected by using
n Authentication to make sure the requester is the one she claims to be
n HTTP Basic authentication by providing username and password
n A JWT issued by google or other openID connect providers
n Authorization to make sure the requester is allowed to see, use or change the
information she wants to access
n Authorization is implemented with ACL and a policy
Authentication and authorization
Source: https://www.eclipse.org/ditto/basic-auth.html

15. © Fraunhofer 15
n APIs contains an inline ACL defining which authenticated parties may READ, WRITE,
and ADMINISTRATE the thing
Access control list (ACL)
curl –u ditto:ditto –X PUT –d '{
"thingId" : "org.eclipse.ditto:car1",
"acl": {
"ditto": {
READ: true,
WRITE: false,
"ADMINISTRATE": true
}
},
"attributes": { … }
"features": { … },
}' 'http://localhost:8080/things/ns:car1'
User
name
Access
Control
READ: allows to read things (reading ACL and receives notification;
reading attributes and features)
WRITE: allows to write/modify a thing (e.g., create/update /delete
a thing, attributes, and features)
ADMINISTRATE: allows to modify ACL of a Thing and to
create/update/delete attributes, features
"acl":{
"ditto":{
"READ":true,"WRITE":false,"ADMINISTRATE":false
},
"adam":{
"READ":true,"WRITE":true,"ADMINISTRATE":true
}
}

16. © Fraunhofer 16
n A Policy enables developers to
configure fine-grained access control in
an easy way.
n A specific policy defines who (subject)
is granted or revoked permissions
(rights) on a specific resource.
n The resource can be defined as rough
or as fine-grained as necessary for the
respective use case.
n Granted and prohibited
Policy
"policyId": "namespace:policy-a",
"entries": {
"owner": {
"subjects": {
"nginx:ditto": {
"type": "nginx basic auth user"
}
},
"resources": {
"thing:/": {
"grant": ["READ", "WRITE"],
},
"policy:/": {
"grant": ["READ", "WRITE"],
},
"thing:/features/firmware": {
"revoke": ["WRITE"]
}
For comprehensive example refer: https://www.eclipse.org/ditto/basic-policy.html

17. © Fraunhofer 17
n State management for digital twins
n Differ between reported (last known), desired (target), and current state (live)
of devices, including support for synchronization and publishing of state
changes.
n Last known state of an offline device
n Allows to filter for specific criteria on notification
n RQL (Resource Query Language) expression to filter events
Eclipse ditto features

18. © Fraunhofer 18
Twin vs live
- Uses ditto as persistence
- Enforces access control
- Processes commands
- Uses ditto as router
- Enforces access control
- Processes commands
Source: https://bit.ly/2NvGTzF

19. © Fraunhofer 19
Notification about changes
Via WebSocket
send/receive ditto protocol message
Via HTML5 Sever Sent Events
receive changes in Thing JSON form
Server Sent Events (SSEs) https://bit.ly/2NvGTzF
Web Socket Binding https://www.eclipse.org/ditto/httpapi-protocol-bindings-websocket.html
Slide source: https://bit.ly/2NvGTzF

20. © Fraunhofer 20
n Support finding and selecting sets of digital twins by providing search functionality
on meta data and state data
n Search over a large number of digital twins
n Tagging devices – What are the advantages?
Searching sets of digital twins
Eclipse Ditto
Industry 4.0 App
Industrial Assets, deployed at
factory floors
Image source: https://thenounproject.com/ l
Search

21. © Fraunhofer 21
n Ditto utilizes a subset of Resource Query Language (RQL) as language for specifying
queries.
n Enforces access control over search results
n Supported RQL expressions to write a complex query
n RQL filter: It specifies “what” to filter.
n RQL sorting: It specifies in which order the result should be returned.
n Example:
n Search for all things located in “factory-area1”, reorder the list to start
with the lowest thing ID as the first element, return the first 5 results.
Feature: search
Source: RQL: https://github.com/persvr/rql
Source: RQL for Ditto: https://www.eclipse.org/ditto/basic-rql.html
Filter: eq(attributes/location,“factory-area1")
Sorting: sort(+thingId)
Paging: limit(0,5)
HTTP API Search:: https://www.eclipse.org/ditto/httpapi-search.html

22. © Fraunhofer 22
n Searching all things with the same manufacturer name “Siemens”
curl -u ditto:ditto -X GET
'http://localhost:8080/api/1/search/things?filter=eq(attributes/
manufacturer,"Siemens")‘
n Filter all things, whose manufacturer differnet than ABB
curl -u ditto:ditto -X GET
'http://localhost:8080/api/1/search/things?filter=ne(attr
ibutes/manufacturer,"ABB")‘
Examples: searching on meta data

23. © Fraunhofer 23
n Filter all things with ID greater than "A000"
n gt(thingId, "A000")
n Filter all things with thingID "A000" or "AB00" or "AZ99"
n in(thingId, "A000", "AB00", "AZ99")
n Filter all electrical-motors, which are located in the "factory-area1"
n and(exists(features/electrical-motors),
eq(attributes/location, "factory-area1"))
Examples: searching on meta data
Reference: :https://www.eclipse.org/ditto/basic-search.html
https://www.eclipse.org/ditto/basic-rql.html

24. © Fraunhofer 24
n Searching all things with the temperature greater than 60'C
curl -u ditto:ditto -X GET
'http://localhost:8080/api/1/search/things?filter=eq(sensors/pro
perties/temperature, 60)‘
n Combining meta data and state value
n Searching all things, which has ABB manufacturer and temperature
greather than 60'C
curl -u ditto:ditto -X GET 'http://localhost:8080/api/1/search
/things? filter=and(eq(attributes/manufacturer, "ABB"),
eq(features/properties/temperature, 60))'
Examples: searching on state data

25. © Fraunhofer 25
n Router of message, Enforcement of access control
n Examples
n Enhance a location aware Twin with the current weather
n Enhance a Twin with an API for its known spare parts
Orchestration (Horizontal Integration)
Image source : https://bit.ly/2xwj0xP Slide source: https://bit.ly/2NvGTzF

26. © Fraunhofer 26
Demo
Digital Twin: A key element of "Industry 4.0"
Reference: https://bit.ly/2NvGTzF

27. © Fraunhofer 27
n Digital Twin
n Exciting area with a lot of business opportunities in Industry 4.0/IoT domain
n Open source framework – Ditto to implement Digital Twins
n Features:
n Devices as a Service
n Discovery
n Orchestration/Integration
Summary…

28. © Fraunhofer
THANK YOU FOR YOUR ATTENTION
Questions?

29. © Fraunhofer 29
Contact…
Pankesh Patel, PhD
Senior Research Scientist,
Fraunhofer USA/ Center for Experimental Software Engineering (CESE),
College Park, Maryland, USA.
Mobile: +1 240-302-3609, Fax: 240 487 2960
Email: ppatel@fc-md.umd.edu / ppatel@cese.fraunhofer.org

30. © Fraunhofer 30
Backup slides

31. © Fraunhofer
Project overview
IOTSUITE: A TOOLKIT FOR PROTOTYPING INTERENT OF
THINGS APPLICATIONS

32. © Fraunhofer 32
Motivation
Different types of devices,
Platforms, Runtime systems
Heterogeneity
Node-centric programming
- Large number of devices

33. © Fraunhofer 33
State of the art – IoT application development
Programming
Languages
RAD tools
Cloud
- Full control on AL (app logic)
- More development effort
- Reduce development effort
- Platform-specific design (Language, Runtime)
- Reduce development effort, ease of deployment & evolutio
(due to centralized system)
- Cloud-dependent design
Database
- Reduce development effort
- Less flexible to introduce customized
application logic

34. © Fraunhofer 34
n Separation of Concerns (reusability)
n Integration of existing DSL (reduce
complexity & effort)
n Automation wherever possible (reduce
effort)
n Macroprogramming
Our approach
Code generators
PIM
PSM
Node
PSM
…
C1 C2 Cn
…
Horizontal Separation of
Concerns
Vertical Separation of
Concerns
PIM – Platform Independent Model
PSM – Platform Specific Model

35. © Fraunhofer 35
IoTSuite: Overview
Domain Spec. Functional
Spec.
Deployment Spec.
Compiler Deployment Module
Generated Programming
Framework (GPL)
Android
Packages
Node.js
Packages
Java
Packages
Developer
Developer
Application
Logic (GPL)
Sensing/Actuating
Framework

36. © Fraunhofer 36
IoTSuite: Detail view
Domain
spec.
Compilation of
vocabulary
Deployment
spec.
Mapper
Mapping
files
Compilation of
architecture
Developer
Application
logic
Architecture
framework
Sensing/actuating
framework
Domain framework
Architecture
spec.
Linker
Android
devices
PC
PC
Developer
Developer
Developer

37. © Fraunhofer 37
Domain
Concepts that are responsible
for interacting with EoI of a
domain
- Sensor, actuator, storage
Actuator
Sensor Storage
Domain
Room
temperature
(e.g. building
automation)
Building fire
state

38. © Fraunhofer 38
Functional
Actuator
Sensor Storage
Computational
service
Computational
service
response
request
publish/
subscribe
command
Concepts that are responsible for
- processing data and taking decisions
Domain
Room
temperature
(e.g. building
automation)
Functionality
Home fire
detection
Building
HVAC
Building fire
state

39. © Fraunhofer 39
Computational
service
Deployment
Actuator
Storage
Sensor
response
request
publish/
subscribe
command
Computational
service
Device Device
Device
Device
Device
Concepts to describe various
properties of devices
Domain
Room
temperature
(e.g. building
automation)
Functionality
Deployment
Building fire
state
Home fire
detection
Building
HVAC
Site1 Site 2

40. © Fraunhofer 40
IoTSuite: Platform Independent
Parser
Code generator
IoTSuite
Domain Spec. Architecture Spec. Deployment Spec.
JavaSE Android Node Python Other
System specification
(Platform independent)
Adding a new platform
as a plugin
Code generation of a
framework in a target
platform
ANTLR, a parser
generator from a
grammar
StringTemplate, a
template engine for
generating source
code

41. © Fraunhofer 41
IoTSuite: Platform independent
Runtime System
Device
Middleware wrapper
Generated code
For Device X
It runs on each individual device & provide
support for executing distributed tasks.
IoTSuite generates code for a device
It plugs “generated code for a device” & runtime
system. It implements interface specified in a
support library, specific to a runtime system.
Support for MQTT & iBICOOP,

42. © Fraunhofer 42
Demo
IoTSuite: A toolsuite for building rapid Industry 4.0 applications
Reference: https://bit.ly/2NvGTzF